@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/resetDevice.d.ts

@@ -1,16 +1,22 @@
-import { PROTO } from '../constants';
-import { AbstractMethod } from '../core/AbstractMethod';
+import { type PermissionRequest } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 export default class ResetDevice extends AbstractMethod<'resetDevice', PROTO.ResetDevice> {
-    init(): void;
-    get info(): string;
-    get confirmation(): {
-        view: "device-management";
-        label: string;
-    };
-    private resetDeviceWorkflow;
-    private entropyCheckWorkflow;
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=resetDevice.d.ts.map
+  constructor(message: MethodMessage<'resetDevice'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  get confirmation(): {
+    view: "device-management";
+    label: string;
+  };
+  private resetDeviceWorkflow;
+  private entropyCheckWorkflow;
+  run(): Promise<{
+    message: string;
+    xpubHashes: import("@trezor/connect-common").XPubHashesPerBip43Path;
+  } | {
+    message: string;
+    xpubHashes?: undefined;
+  }>;
+}

package/lib/api/resetDevice.js

@@ -1,29 +1,20 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const utils_1 = require("@trezor/utils");
-const verifyEntropy_1 = require("../api/firmware/verifyEntropy");
-const constants_1 = require("../constants");
-const errors_1 = require("../constants/errors");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const events_1 = require("../events");
-const paramsValidator_1 = require("./common/paramsValidator");
-const pathUtils_1 = require("../utils/pathUtils");
-class ResetDevice extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
-    this.useDeviceState = false;
-    this.requiredPermissions = ['management'];
-    this.skipFinalReload = false;
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+import { UI_REQUEST } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { TransportError } from "@trezor/connect-common/lib/constants/errors.js";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { getRandomInt } from "@trezor/utils";
+import { generateEntropy, verifyEntropy } from "../api/firmware/verifyEntropy.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validatePath } from "../utils/pathUtils.js";
+import { calculateXPubHashes } from "./firmware/calculateXPubHash.js";
+export default class ResetDevice extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(constants_1.PROTO.ResetDevice, payload);
-    this.params = {
+    } = message;
+    Assert(PROTO.ResetDevice, payload);
+    const params = {
       strength: payload.strength || 256,
       passphrase_protection: payload.passphrase_protection,
       pin_protection: payload.pin_protection,
@@ -33,8 +24,18 @@ class ResetDevice extends AbstractMethod_1.AbstractMethod {
       skip_backup: payload.skip_backup,
       no_backup: payload.no_backup,
       backup_type: payload.backup_type,
+      backup_method: payload.backup_method,
       entropy_check: typeof payload.entropy_check === 'boolean' ? payload.entropy_check : true
     };
+    super(message, params);
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
+    this.useDeviceState = false;
+    this.skipFinalReload = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
   get info() {
     return 'Setup device';
@@ -46,38 +47,49 @@ class ResetDevice extends AbstractMethod_1.AbstractMethod {
     };
   }
   async resetDeviceWorkflow() {
-    const cmd = this.device.getCommands();
-    const entropy = (0, verifyEntropy_1.generateEntropy)(32).toString('hex');
+    const cmd = this.getDevice().getCommands();
+    const entropy = generateEntropy(32).toString('hex');
     await cmd.typedCall('ResetDevice', 'EntropyRequest', this.params);
     await cmd.typedCall('EntropyAck', 'Success', {
       entropy
     });
   }
   async entropyCheckWorkflow() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     const paths = ["m/84'/0'/0'", "m/44'/60'/0'"];
+    const parsedPaths = paths.map(path => ({
+      path,
+      address_n: validatePath(path)
+    }));
     const handleErr = error => {
-      throw error instanceof errors_1.TransportError ? error : constants_1.ERRORS.TypedError('Failure_EntropyCheck', error.message);
+      throw error instanceof TransportError ? error : ERRORS.TypedError('Failure_EntropyCheck', error.message);
     };
-    let entropy = (0, verifyEntropy_1.generateEntropy)(32).toString('hex');
-    let commitment = await cmd.typedCall('ResetDevice', 'EntropyRequest', this.params).then(response => response.message.entropy_commitment);
-    await cmd.typedCall('EntropyAck', 'EntropyCheckReady', {
-      entropy
-    });
-    const tries = (0, utils_1.getRandomInt)(1, 5);
-    for (let i = 0; i < tries; i++) {
+    const getXPubs = async () => {
       const xpubs = {};
-      for (const path of paths) {
+      for (const {
+        path,
+        address_n
+      } of parsedPaths) {
         const pubKey = await cmd.getPublicKey({
-          address_n: (0, pathUtils_1.validatePath)(path)
+          address_n
         }).catch(handleErr);
         xpubs[path] = pubKey.xpub;
       }
+      return xpubs;
+    };
+    let entropy = generateEntropy(32).toString('hex');
+    let commitment = await cmd.typedCall('ResetDevice', 'EntropyRequest', this.params).then(response => response.message.entropy_commitment);
+    await cmd.typedCall('EntropyAck', 'EntropyCheckReady', {
+      entropy
+    });
+    const tries = getRandomInt(1, 5);
+    for (let i = 0; i < tries; i++) {
+      const xpubs = await getXPubs();
       const {
         prev_entropy,
         entropy_commitment
       } = await cmd.typedCall('EntropyCheckContinue', 'EntropyRequest', {}).then(response => response.message).catch(handleErr);
-      const res = await (0, verifyEntropy_1.verifyEntropy)({
+      const res = await verifyEntropy({
         type: this.params.backup_type,
         strength: this.params.strength,
         commitment,
@@ -86,32 +98,36 @@ class ResetDevice extends AbstractMethod_1.AbstractMethod {
         xpubs
       });
       if (res.error) {
-        await this.device.getCurrentSession().cancelCall();
-        throw constants_1.ERRORS.TypedError('Failure_EntropyCheck', res.error);
+        await this.getDevice().getCurrentSession().cancelCall();
+        throw ERRORS.TypedError('Failure_EntropyCheck', res.error);
       }
-      entropy = (0, verifyEntropy_1.generateEntropy)(32).toString('hex');
+      entropy = generateEntropy(32).toString('hex');
       commitment = entropy_commitment;
       await cmd.typedCall('EntropyAck', 'EntropyCheckReady', {
         entropy
       }).catch(handleErr);
     }
+    const finalXPubs = await getXPubs();
     await cmd.typedCall('EntropyCheckContinue', 'Success', {
       finish: true
     });
+    return finalXPubs;
   }
   async run() {
-    if (this.params.entropy_check && this.device.unavailableCapabilities['entropyCheck']) {
+    if (this.params.entropy_check && this.getDevice().unavailableCapabilities['entropyCheck']) {
       this.params.entropy_check = false;
     }
     if (this.params.entropy_check) {
-      await this.entropyCheckWorkflow();
-    } else {
-      await this.resetDeviceWorkflow();
+      const xpubs = await this.entropyCheckWorkflow();
+      const xpubHashes = calculateXPubHashes(xpubs);
+      return {
+        message: 'Success',
+        xpubHashes
+      };
     }
+    await this.resetDeviceWorkflow();
     return {
       message: 'Success'
     };
   }
-}
-exports.default = ResetDevice;
-//# sourceMappingURL=resetDevice.js.map
+}

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

@@ -1,3 +1,2 @@
-export { default as rippleGetAddress } from './rippleGetAddress';
-export { default as rippleSignTransaction } from './rippleSignTransaction';
-//# sourceMappingURL=index.d.ts.map
+export { default as rippleGetAddress } from "./rippleGetAddress.js";
+export { default as rippleSignTransaction } from "./rippleSignTransaction.js";

package/lib/api/ripple/api/index.js

@@ -1,22 +1,2 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.rippleSignTransaction = exports.rippleGetAddress = void 0;
-const tslib_1 = require("tslib");
-var rippleGetAddress_1 = require("./rippleGetAddress");
-Object.defineProperty(exports, "rippleGetAddress", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(rippleGetAddress_1).default;
-  }
-});
-var rippleSignTransaction_1 = require("./rippleSignTransaction");
-Object.defineProperty(exports, "rippleSignTransaction", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(rippleSignTransaction_1).default;
-  }
-});
-//# sourceMappingURL=index.js.map
+export { default as rippleGetAddress } from "./rippleGetAddress.js";
+export { default as rippleSignTransaction } from "./rippleSignTransaction.js";

package/lib/api/ripple/api/rippleGetAddress.d.ts

@@ -1,27 +1,17 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-type Params = PROTO.RippleGetAddress & {
-    address?: string;
-};
-export default class RippleGetAddress extends AbstractMethod<'rippleGetAddress', 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, chunkify }: Params): Promise<{
-        mac?: string | undefined;
-        address: string;
-    }>;
-    run(): Promise<import("../../../types").Address | import("../../../types").Address[]>;
-}
-export {};
-//# sourceMappingURL=rippleGetAddress.d.ts.map
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
+import type { MiscGetAddressParams } from "../../common/AbstractMiscGetAddress.js";
+export default class RippleGetAddress extends AbstractMiscGetAddress<'rippleGetAddress'> {
+  constructor(message: MethodMessage<'rippleGetAddress'>);
+  get info(): string;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  };
+  _call({
+    proto
+  }: MiscGetAddressParams): Promise<{
+    mac?: string | undefined;
+    address: string;
+  }>;
+}

package/lib/api/ripple/api/rippleGetAddress.js

@@ -1,111 +1,22 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../../../constants");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const events_1 = require("../../../events");
-const types_1 = require("../../../types");
-const getAddress_1 = require("../../../types/api/getAddress");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-class RippleGetAddress extends AbstractMethod_1.AbstractMethod {
-  hasBundle;
-  progress = 0;
-  init() {
-    this.noBackupConfirmationMode = 'always';
-    this.requiredPermissions = ['read'];
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
+export default class RippleGetAddress extends AbstractMiscGetAddress {
+  constructor(message) {
+    super(message, 3);
     this.requiredDeviceCapabilities = ['Capability_Ripple'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Ripple'), this.firmwareRange);
-    this.hasBundle = !!this.payload.bundle;
-    const payload = !this.payload.bundle ? {
-      ...this.payload,
-      bundle: [this.payload]
-    } : this.payload;
-    (0, schema_utils_1.Assert)((0, types_1.Bundle)(getAddress_1.GetAddress), payload);
-    this.params = payload.bundle.map(batch => {
-      const path = (0, pathUtils_1.validatePath)(batch.path, 3);
-      return {
-        address_n: path,
-        address: batch.address,
-        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
-        chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
-      };
-    });
-    const useEventListener = payload.useEventListener && this.params.length === 1 && typeof this.params[0].address === 'string' && this.params[0].show_display;
-    this.useUi = !useEventListener;
+    this.requiredFirmwareCoins = [getMiscNetwork('xrp')];
   }
   get info() {
-    if (this.params.length === 1) {
-      return `Export Ripple address for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`;
-    }
-    return 'Export multiple Ripple addresses';
-  }
-  getButtonRequestData(code) {
-    if (code === 'ButtonRequest_Address') {
-      return {
-        type: 'address',
-        serializedPath: (0, pathUtils_1.getSerializedPath)(this.params[this.progress].address_n),
-        address: this.params[this.progress].address || 'not-set'
-      };
-    }
+    return this.getInfo('Ripple', true);
   }
   get confirmation() {
-    return {
-      view: 'export-address',
-      label: this.info
-    };
+    return this.getConfirmation('Ripple');
   }
   async _call({
-    address_n,
-    show_display,
-    chunkify
+    proto
   }) {
-    const cmd = this.device.getCommands();
-    const response = await cmd.typedCall('RippleGetAddress', 'RippleAddress', {
-      address_n,
-      show_display,
-      chunkify
-    });
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('RippleGetAddress', 'RippleAddress', proto);
     return response.message;
   }
-  async run() {
-    const responses = [];
-    for (let i = 0; i < this.params.length; i++) {
-      const batch = this.params[i];
-      if (batch.show_display) {
-        const silent = await this._call({
-          ...batch,
-          show_display: false
-        });
-        if (typeof batch.address === 'string') {
-          if (batch.address !== silent.address) {
-            throw constants_1.ERRORS.TypedError('Method_AddressNotMatch');
-          }
-        } else {
-          batch.address = silent.address;
-        }
-      }
-      const response = await this._call(batch);
-      responses.push({
-        path: batch.address_n,
-        serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
-        address: response.address
-      });
-      if (this.hasBundle) {
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
-          total: this.params.length,
-          progress: i,
-          response
-        }));
-      }
-      this.progress++;
-    }
-    return this.hasBundle ? responses : responses[0];
-  }
-}
-exports.default = RippleGetAddress;
-//# sourceMappingURL=rippleGetAddress.js.map
+}

package/lib/api/ripple/api/rippleSignTransaction.d.ts

@@ -1,11 +1,13 @@
-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 RippleSignTransaction extends AbstractMethod<'rippleSignTransaction', PROTO.RippleSignTx> {
-    init(): void;
-    get info(): string;
-    run(): Promise<{
-        serializedTx: string;
-        signature: string;
-    }>;
-}
-//# sourceMappingURL=rippleSignTransaction.d.ts.map
+  constructor(message: MethodMessage<'rippleSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    serializedTx: string;
+    signature: string;
+  }>;
+}

package/lib/api/ripple/api/rippleSignTransaction.js

@@ -1,29 +1,21 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const ripple_1 = require("../../../types/api/ripple");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-class RippleSignTransaction extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.requiredDeviceCapabilities = ['Capability_Ripple'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Ripple'), this.firmwareRange);
+import { RippleSignTransaction as RippleSignTransactionSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.js";
+export default class RippleSignTransaction extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.AssertWeak)(ripple_1.RippleSignTransaction, payload);
-    const path = (0, pathUtils_1.validatePath)(payload.path, 5);
+    } = message;
+    Assert(RippleSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 5);
     const {
       transaction,
       chunkify
     } = payload;
-    this.params = {
+    const params = {
       address_n: path,
       fee: transaction.fee,
       flags: transaction.flags,
@@ -34,14 +26,21 @@ class RippleSignTransaction extends AbstractMethod_1.AbstractMethod {
         destination: transaction.payment.destination,
         destination_tag: transaction.payment.destinationTag
       },
+      payment_req: payload.payment_req ? encodePaymentRequestAmount(payload.payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT) : undefined,
       chunkify: typeof chunkify === 'boolean' ? chunkify : false
     };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Ripple'];
+    this.requiredFirmwareCoins = [getMiscNetwork('xrp')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
   }
   get info() {
     return 'Sign Ripple transaction';
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     const {
       message
     } = await cmd.typedCall('RippleSignTx', 'RippleSignedTx', this.params);
@@ -50,6 +49,4 @@ class RippleSignTransaction extends AbstractMethod_1.AbstractMethod {
       signature: message.signature
     };
   }
-}
-exports.default = RippleSignTransaction;
-//# sourceMappingURL=rippleSignTransaction.js.map
+}

package/lib/api/selectAccount.d.ts

@@ -0,0 +1,15 @@
+import { type CoinInfo, type PermissionRequest } from '@trezor/connect-common';
+import { type AddressSelection } from '@trezor/connect-common/lib/types/api/selectAccount';
+import type { MethodMessage, MethodReturnType } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+type Params = {
+  coinInfo: CoinInfo;
+  addressSelection?: AddressSelection;
+};
+export default class SelectAccount extends AbstractMethod<'selectAccount', Params> {
+  constructor(message: MethodMessage<'selectAccount'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<MethodReturnType<'selectAccount'>>;
+}
+export {};

package/lib/api/selectAccount.js

@@ -0,0 +1,42 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { SelectAccount as SelectAccountSchema } from "@trezor/connect-common/lib/types/api/selectAccount.js";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+import { isUtxoBased } from "../utils/accountUtils.js";
+import { getLabel } from "../utils/pathUtils.js";
+export default class SelectAccount extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(SelectAccountSchema, payload);
+    const {
+      selectionType
+    } = payload;
+    const bounds = typeof selectionType === 'object' && selectionType !== null ? selectionType : undefined;
+    if (bounds?.minCount !== undefined && bounds.maxCount !== undefined && bounds.minCount > bounds.maxCount) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'selectionType.minCount cannot be greater than selectionType.maxCount');
+    }
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    super(message, {
+      coinInfo,
+      addressSelection: payload.addressSelection
+    });
+    this.useDevice = false;
+    this.useDeviceState = false;
+    this.useUi = true;
+    this.requiredFirmwareCoins = [coinInfo];
+  }
+  get requiredPermissions() {
+    const isFullAccount = this.params.addressSelection === undefined || this.params.addressSelection === 'fullAccount';
+    const permission = isUtxoBased(this.params.coinInfo) && isFullAccount ? 'read_xpub' : 'read_address';
+    return this.coinPerms(permission, this.requiredFirmwareCoins);
+  }
+  get info() {
+    return getLabel('Select #NETWORK account', this.params.coinInfo);
+  }
+  run() {
+    return Promise.resolve([]);
+  }
+}

package/lib/api/setBrightness.d.ts

@@ -1,9 +1,12 @@
+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 SetBrightness extends AbstractMethod<'setBrightness', PROTO.SetBrightness> {
-    init(): void;
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=setBrightness.d.ts.map
+  constructor(message: MethodMessage<'setBrightness'>);
+  get requiredPermissions(): PermissionRequest[];
+  init(): void;
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/setBrightness.js

@@ -1,29 +1,28 @@
-"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 SetBrightness extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['management'];
-    this.skipFinalReload = false;
-    this.useDeviceState = false;
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class SetBrightness extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(protobuf_1.MessagesSchema.SetBrightness, payload);
-    this.params = {
+    } = message;
+    Assert(PROTO.SetBrightness, payload);
+    const params = {
       value: payload.value
     };
+    super(message, params);
+    this.skipFinalReload = false;
+    this.useDeviceState = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
+  init() {}
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     const response = await cmd.typedCall('SetBrightness', 'Success', this.params);
     return response.message;
   }
-}
-exports.default = SetBrightness;
-//# sourceMappingURL=setBrightness.js.map
+}