@trezor/connect 9.7.3 → 10.0.0-beta.1

package/README.md

@@ -1,15 +1,19 @@
 # @trezor/connect
 
-API version 9.7.3
+API version 10.0.0-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)
-[![Known Vulnerabilities](https://snyk.io/test/github/trezor/connect/badge.svg?targetFile=package.json)](https://snyk.io/test/github/trezor/trezor-suite?targetFile=packages/connect/package.json)
 
 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](https://github.com/trezor/trezor-suite/blob/develop/packages/connect-web/README.md).
 
+> **Building a web app?** Use [@trezor/connect-web](https://www.npmjs.com/package/@trezor/connect-web) instead — it adds browser transport handling and popup-based UI.
+>
+> **Building a browser extension?** Use [@trezor/connect-webextension](https://www.npmjs.com/package/@trezor/connect-webextension) instead — it handles Manifest V3 and service worker constraints.
+>
+> **Building a React Native app?** Use [@trezor/connect-mobile](https://www.npmjs.com/package/@trezor/connect-mobile) instead — it communicates with Trezor Suite via deep links.
+
 ## Installation
 
 Install library as npm module:
@@ -36,51 +40,11 @@ For more instructions [refer to this document](https://github.com/trezor/trezor-
 
 ## Versioning
 
-Since version 9 we are adopting a new versioning strategy. With every release, we are going to update two urls
-
-- A) The latest release will always be available on https://connect.trezor.io/9/trezor-connect.js.
-- B) For those who like to have more control over their dependencies, there will be also a new url created in form of https://connect.trezor.io/9.1../trezor-connect.js. Please note that these endpoints will not receive any further updates including security updates.
-
-Version 9 is available as `@trezor/connect` and `@trezor/connect-web` npm packages.
-
-### Major version
-
-New major version is released when there are breaking changes on API level. Previous major version will be maintained for 12 months and after this period it can be taken down without notice.
-
-Current major version 9 is being developed on top of `develop` branch. When there is a new major version a new branch should be created (`v-<major-version>`) and mantained separately.
-
-### Minor version
-
-Minor versions are released when there are:
-
-- considerable additions to API
-- changes in npm package
-
-### Patch version
-
-Everything else that does not fall under major or minor version.
-
-## Version 8 (legacy)
-
-Legacy version 8 is accessible from url https://connect.trezor.io/8/trezor-connect.js.
-
-Version 8 is available as `trezor-connect` npm package.
-
-If you would like to find out which version is deployed precisely simply run:
-
-`curl -s https://connect.trezor.io/8/trezor-connect.js | grep VERSION`
-
-With regards to this repo - All updates should go to current version branch, the previous releases are in corresponding branches. The gh-pages is the same older version, that is used at trezor.github.io/connect/connect.js, and it's there for backwards compatibility; please don't touch.
-
-For deployment process of trezor-connect v8 refer to [trezor/connect repository](https://github.com/trezor/connect/blob/develop/docs/deployment/index.md)
-
-Version 8 will go offline by the end of 2023.
+Version 10 is the current major version and is currently in beta. New major versions are released when there are breaking API changes.
 
 ## Docs
 
-Interactive API explorer is available on https://connect.trezor.io/9/#/
-
-Documentation is available [docs/packages/connect](https://github.com/trezor/trezor-suite/blob/develop/docs/packages/connect/index.md)
+Interactive API explorer is available on https://connect.trezor.io/
 
 ## Examples
 

package/lib/api/applyFlags.d.ts

@@ -1,17 +1,20 @@
+import { type PermissionRequest } from '@trezor/connect-common';
 import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../core/AbstractMethod';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 export default class ApplyFlags extends AbstractMethod<'applyFlags', PROTO.ApplyFlags> {
-    init(): void;
-    get confirmation(): {
-        view: "device-management";
-        customConfirmButton: {
-            className: string;
-            label: string;
-        };
-        label: string;
+  constructor(message: MethodMessage<'applyFlags'>);
+  get requiredPermissions(): PermissionRequest[];
+  init(): void;
+  get confirmation(): {
+    view: "device-management";
+    customConfirmButton: {
+      className: string;
+      label: string;
     };
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=applyFlags.d.ts.map
+    label: string;
+  };
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/applyFlags.js

@@ -1,24 +1,25 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const protobuf_1 = require("@trezor/protobuf");
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-class ApplyFlags extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['management'];
-    this.useDeviceState = false;
-    this.skipFinalReload = false;
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class ApplyFlags extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(protobuf_1.MessagesSchema.ApplyFlags, payload);
-    this.params = {
+    } = message;
+    Assert(PROTO.ApplyFlags, payload);
+    const params = {
       flags: payload.flags
     };
+    super(message, params);
+    this.useDeviceState = false;
+    this.skipFinalReload = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
+  init() {}
   get confirmation() {
     return {
       view: 'device-management',
@@ -30,10 +31,8 @@ class ApplyFlags extends AbstractMethod_1.AbstractMethod {
     };
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     const response = await cmd.typedCall('ApplyFlags', 'Success', this.params);
     return response.message;
   }
-}
-exports.default = ApplyFlags;
-//# sourceMappingURL=applyFlags.js.map
+}

package/lib/api/applySettings.d.ts

@@ -1,17 +1,20 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../core/AbstractMethod';
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 export default class ApplySettings extends AbstractMethod<'applySettings', PROTO.ApplySettings> {
-    init(): void;
-    get confirmation(): {
-        view: "device-management";
-        customConfirmButton: {
-            className: string;
-            label: string;
-        };
-        label: string;
+  constructor(message: MethodMessage<'applySettings'>);
+  get requiredPermissions(): PermissionRequest[];
+  init(): void;
+  get confirmation(): {
+    view: "device-management";
+    customConfirmButton: {
+      className: string;
+      label: string;
     };
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=applySettings.d.ts.map
+    label: string;
+  };
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/applySettings.js

@@ -1,25 +1,26 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const applySettings_1 = require("../types/api/applySettings");
-class ApplySettings extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['management'];
-    this.useDeviceState = false;
-    this.skipFinalReload = false;
+import { ApplySettings as ApplySettingsSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class ApplySettings extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(applySettings_1.ApplySettings, payload);
-    this.params = {
+    } = message;
+    Assert(ApplySettingsSchema, payload);
+    const params = {
       ...payload,
       _passphrase_source: payload.passphrase_source
     };
+    super(message, params);
+    this.useDeviceState = false;
+    this.skipFinalReload = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
+  init() {}
   get confirmation() {
     return {
       view: 'device-management',
@@ -31,12 +32,16 @@ class ApplySettings extends AbstractMethod_1.AbstractMethod {
     };
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const device = this.getDevice();
+    const cmd = device.getCommands();
     const homescreenBytes = this.params.homescreen ? Buffer.from(this.params.homescreen, 'hex') : undefined;
-    if (this.device.atLeast('2.9.0') && homescreenBytes) {
+    if (device.atLeast('2.9.0') && homescreenBytes) {
       this.params.homescreen = undefined;
       this.params.homescreen_length = homescreenBytes.length;
     }
+    if (homescreenBytes !== undefined) {
+      device.startPiggybackAck();
+    }
     let response = await cmd.typedCall('ApplySettings', ['DataChunkRequest', 'Success'], this.params);
     while (response.type !== 'Success') {
       const start = response.message.data_offset;
@@ -46,8 +51,7 @@ class ApplySettings extends AbstractMethod_1.AbstractMethod {
         data_chunk
       });
     }
+    await device.stopPiggybackAck();
     return response.message;
   }
-}
-exports.default = ApplySettings;
-//# sourceMappingURL=applySettings.js.map
+}

package/lib/api/authenticateDevice.d.ts

@@ -1,11 +1,25 @@
-import { VerifyAuthenticityProofResult } from '@trezor/device-authenticity';
-import { AbstractMethod } from '../core/AbstractMethod';
-import { AuthenticateDeviceParams } from '../types/api/authenticateDevice';
+import type { PermissionRequest } from '@trezor/connect-common';
+import { AuthenticateDeviceParams } from '@trezor/device-authenticity';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 export default class AuthenticateDevice extends AbstractMethod<'authenticateDevice', AuthenticateDeviceParams> {
-    init(): void;
-    run(): Promise<{
-        optigaResult: VerifyAuthenticityProofResult;
-        tropicResult: VerifyAuthenticityProofResult | null;
-    }>;
-}
-//# sourceMappingURL=authenticateDevice.d.ts.map
+  constructor(message: MethodMessage<'authenticateDevice'>);
+  get requiredPermissions(): PermissionRequest[];
+  streamAuthenticityProofs(challenge: Buffer): Promise<{
+    tropic_signature?: string | undefined;
+    mcu_signature?: string | undefined;
+    optiga_certificates: string[];
+    optiga_signature: string;
+    tropic_certificates: string[];
+    mcu_certificates: string[];
+  }>;
+  getAuthenticityProofs(challenge: Buffer): Promise<{
+    tropic_signature?: string | undefined;
+    mcu_signature?: string | undefined;
+    optiga_certificates: string[];
+    optiga_signature: string;
+    tropic_certificates: string[];
+    mcu_certificates: string[];
+  }>;
+  run(): Promise<import("@trezor/device-authenticity/lib/types").ResultsToValidate>;
+}

package/lib/api/authenticateDevice.js

@@ -1,44 +1,128 @@
-"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 events_1 = require("../events");
-const paramsValidator_1 = require("./common/paramsValidator");
-const authenticateDevice_1 = require("../types/api/authenticateDevice");
-class AuthenticateDevice extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.useEmptyPassphrase = true;
-    this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
-    this.requiredPermissions = ['management'];
-    this.skipFinalReload = false;
-    this.useDeviceState = false;
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+import { UI_REQUEST } from "@trezor/connect-common";
+import { AuthenticateDeviceParams, deviceAuthenticityBlacklistConfig, deviceAuthenticityConfig, getRandomChallenge, prepareDeviceAuthenticityData, validateSerialNumbers, verifyAuthenticityProof } from "@trezor/device-authenticity";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class AuthenticateDevice extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(authenticateDevice_1.AuthenticateDeviceParams, payload);
-    this.params = {
+    } = message;
+    Assert(AuthenticateDeviceParams, payload);
+    const params = {
       config: payload.config,
       blacklistConfig: payload.blacklistConfig,
       allowDebugKeys: payload.allowDebugKeys
     };
+    super(message, params);
+    this.useEmptyPassphrase = true;
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
+    this.skipFinalReload = false;
+    this.useDeviceState = false;
   }
-  async run() {
-    const challenge = (0, device_authenticity_1.getRandomChallenge)();
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
+  }
+  async streamAuthenticityProofs(challenge) {
+    const cmd = this.getDevice().getCommands();
+    const MAX_CHUNK_SIZE = 500;
+    this.getDevice().startPiggybackAck();
+    const {
+      message: proofSizes
+    } = await cmd.typedCall('AuthenticateDevice', 'AuthenticityProofSizes', {
+      challenge: challenge.toString('hex'),
+      stream: true
+    });
+    const proofTypes = [{
+      name: 'optiga',
+      type: PROTO.AuthenticityProofType.OPTIGA,
+      certSizes: proofSizes.optiga_certificates,
+      sigSize: proofSizes.optiga_signature
+    }, {
+      name: 'tropic',
+      type: PROTO.AuthenticityProofType.TROPIC,
+      certSizes: proofSizes.tropic_certificates,
+      sigSize: proofSizes.tropic_signature
+    }, {
+      name: 'mcu',
+      type: PROTO.AuthenticityProofType.MCU,
+      certSizes: proofSizes.mcu_certificates,
+      sigSize: proofSizes.mcu_signature
+    }];
+    const authenticityProof = {
+      optiga_certificates: [],
+      optiga_signature: '',
+      tropic_certificates: [],
+      tropic_signature: undefined,
+      mcu_certificates: [],
+      mcu_signature: undefined
+    };
+    const getChunk = async (params, chunkSize) => {
+      const chunks = [];
+      let offset = 0;
+      while (offset < chunkSize) {
+        const size = Math.min(MAX_CHUNK_SIZE, chunkSize - offset);
+        const {
+          message
+        } = await cmd.typedCall('GetAuthenticityProofChunk', 'AuthenticityProofChunk', {
+          ...params,
+          offset,
+          size
+        });
+        chunks.push(message.chunk);
+        offset += size;
+      }
+      return chunks.join('');
+    };
+    for (const {
+      name,
+      type,
+      certSizes,
+      sigSize
+    } of proofTypes) {
+      for (const [i, certSize] of certSizes.entries()) {
+        const cert = await getChunk({
+          proof_type: type,
+          index: i
+        }, certSize);
+        authenticityProof[`${name}_certificates`].push(cert);
+      }
+      if (sigSize) {
+        authenticityProof[`${name}_signature`] = await getChunk({
+          proof_type: type
+        }, sigSize);
+      }
+    }
+    await cmd.typedCall('GetAuthenticityProofChunk', 'Success', {
+      offset: 0,
+      size: 0
+    });
+    await this.getDevice().stopPiggybackAck();
+    return authenticityProof;
+  }
+  async getAuthenticityProofs(challenge) {
     const {
       message
-    } = await this.device.getCommands().typedCall('AuthenticateDevice', 'AuthenticityProof', {
+    } = await this.getDevice().getCommands().typedCall('AuthenticateDevice', 'AuthenticityProof', {
       challenge: challenge.toString('hex')
     });
-    const config = this.params.config || device_authenticity_1.deviceAuthenticityConfig;
-    const blacklistConfig = this.params.blacklistConfig || device_authenticity_1.deviceAuthenticityBlacklistConfig;
+    return message;
+  }
+  async run() {
+    const challenge = getRandomChallenge();
+    const {
+      unavailableCapabilities
+    } = this.getDevice();
+    const authenticityProof = !unavailableCapabilities['authenticityProofChunk'] ? await this.streamAuthenticityProofs(challenge) : await this.getAuthenticityProofs(challenge);
+    const config = this.params.config || deviceAuthenticityConfig;
+    const blacklistConfig = this.params.blacklistConfig || deviceAuthenticityBlacklistConfig;
     const commonParams = {
-      challenge,
-      deviceModel: this.device.features.internal_model,
+      signedData: prepareDeviceAuthenticityData({
+        payload: challenge
+      }),
+      deviceModel: this.getDevice().features.internal_model,
       allowDebugKeys: this.params.allowDebugKeys,
       config,
       blacklistConfig
@@ -47,10 +131,10 @@ class AuthenticateDevice extends AbstractMethod_1.AbstractMethod {
       const {
         optiga_signature: signature,
         optiga_certificates: certificates
-      } = message;
-      const isAvailable = signature !== undefined && certificates.length > 0;
+      } = authenticityProof;
+      const isAvailable = signature && certificates.length > 0;
       if (isAvailable) {
-        return await (0, device_authenticity_1.verifyAuthenticityProof)({
+        return await verifyAuthenticityProof({
           ...commonParams,
           certificates,
           signature
@@ -61,35 +145,51 @@ class AuthenticateDevice extends AbstractMethod_1.AbstractMethod {
         error: 'RESPONSE_PAYLOAD_MISSING'
       };
     };
+    const hasTropicAbility = !unavailableCapabilities['tropicDeviceAuthentication'];
     const getTropicResult = async () => {
       const {
         tropic_signature: signature,
         tropic_certificates: certificates
-      } = message;
-      const isAvailable = signature !== undefined && certificates.length > 0;
-      const isRequired = !this.device.unavailableCapabilities['tropicDeviceAuthentication'];
+      } = authenticityProof;
+      const isAvailable = signature && certificates.length > 0;
+      const isRequired = hasTropicAbility;
       if (isAvailable) {
-        return await (0, device_authenticity_1.verifyAuthenticityProof)({
+        return await verifyAuthenticityProof({
           ...commonParams,
           certificates,
           signature
         });
       }
-      if (isRequired) {
-        return {
-          valid: false,
-          error: 'RESPONSE_PAYLOAD_MISSING'
-        };
+      return isRequired ? {
+        valid: false,
+        error: 'RESPONSE_PAYLOAD_MISSING'
+      } : null;
+    };
+    const getMCUResult = async () => {
+      const {
+        mcu_signature: signature,
+        mcu_certificates: certificates
+      } = authenticityProof;
+      const isAvailable = signature && certificates.length > 0;
+      const isRequired = !unavailableCapabilities['mcuDeviceAuthentication'];
+      if (isAvailable) {
+        return await verifyAuthenticityProof({
+          ...commonParams,
+          certificates,
+          signature
+        });
       }
-      return null;
+      return isRequired ? {
+        valid: false,
+        error: 'RESPONSE_PAYLOAD_MISSING'
+      } : null;
     };
-    const optigaResult = await getOptigaResult();
-    const tropicResult = await getTropicResult();
-    return {
+    const [optigaResult, tropicResult, mcuResult] = await Promise.all([getOptigaResult(), getTropicResult(), getMCUResult()]);
+    const results = {
       optigaResult,
-      tropicResult
+      tropicResult,
+      mcuResult
     };
+    return hasTropicAbility ? validateSerialNumbers(results) : results;
   }
-}
-exports.default = AuthenticateDevice;
-//# sourceMappingURL=authenticateDevice.js.map
+}

package/lib/api/authorizeCoinjoin.d.ts

@@ -1,9 +1,11 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../core/AbstractMethod';
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 export default class AuthorizeCoinjoin extends AbstractMethod<'authorizeCoinjoin', PROTO.AuthorizeCoinJoin> {
-    init(): void;
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=authorizeCoinjoin.d.ts.map
+  constructor(message: MethodMessage<'authorizeCoinjoin'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/authorizeCoinjoin.js

@@ -1,26 +1,18 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const coinInfo_1 = require("../data/coinInfo");
-const authorizeCoinjoin_1 = require("../types/api/authorizeCoinjoin");
-const pathUtils_1 = require("../utils/pathUtils");
-class AuthorizeCoinjoin extends AbstractMethod_1.AbstractMethod {
-  init() {
+import { AuthorizeCoinjoin as AuthorizeCoinjoinSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getBitcoinNetwork } from "../data/coinInfo.js";
+import { getScriptType, validatePath } from "../utils/pathUtils.js";
+export default class AuthorizeCoinjoin extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(authorizeCoinjoin_1.AuthorizeCoinjoin, payload);
-    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 = {
+    } = message;
+    Assert(AuthorizeCoinjoinSchema, payload);
+    const address_n = validatePath(payload.path, 3);
+    const script_type = payload.scriptType || getScriptType(address_n);
+    const coinInfo = getBitcoinNetwork(payload.coin || address_n);
+    const params = {
       coordinator: payload.coordinator,
       max_rounds: payload.maxRounds,
       max_coordinator_fee_rate: payload.maxCoordinatorFeeRate,
@@ -30,9 +22,15 @@ class AuthorizeCoinjoin extends AbstractMethod_1.AbstractMethod {
       script_type,
       amount_unit: payload.amountUnit
     };
+    super(message, params);
+    this.requiredFirmwareCoins = [coinInfo];
+    this.preauthorized = payload.preauthorized;
+  }
+  get requiredPermissions() {
+    return [this.coinPerm('internal', this.requiredFirmwareCoins[0])];
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     if (this.preauthorized) {
       if (await cmd.preauthorize(false)) {
         return {
@@ -43,6 +41,4 @@ class AuthorizeCoinjoin extends AbstractMethod_1.AbstractMethod {
     const response = await cmd.typedCall('AuthorizeCoinJoin', 'Success', this.params);
     return response.message;
   }
-}
-exports.default = AuthorizeCoinjoin;
-//# sourceMappingURL=authorizeCoinjoin.js.map
+}