@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/monero/api/moneroSignTransaction.js

@@ -1,14 +1,12 @@
-"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 MoneroSignTransactionMethod extends AbstractMethod_1.AbstractMethod {
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { HD_HARDENED_PATH_PART } from "@trezor/crypto-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+export default class MoneroSignTransactionMethod extends AbstractMethod {
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
+  }
   state = {
     hmacs: [],
     vinis: [],
@@ -19,30 +17,27 @@ class MoneroSignTransactionMethod extends AbstractMethod_1.AbstractMethod {
     tx_outs: [],
     rsig_parts: []
   };
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.requiredDeviceCapabilities = ['Capability_Monero'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Monero'), this.firmwareRange);
+  constructor(message) {
     const {
       payload
-    } = this;
-    const path = (0, pathUtils_1.validatePath)(payload.path, 3);
-    const allHardened = path.every(component => (component & pathUtils_1.HD_HARDENED) !== 0);
+    } = message;
+    const path = validatePath(payload.path, 3);
+    const allHardened = path.every(component => (component & HD_HARDENED_PATH_PART) !== 0);
     if (!allHardened) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Monero requires all path components to be hardened. Use m/44'/128'/0' format.`);
+      throw ERRORS.TypedError('Method_InvalidParameter', `Monero requires all path components to be hardened. Use m/44'/128'/0' format.`);
     }
     if (payload.inputs.length < 1) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'At least one input is required');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'At least one input is required');
     }
     if (payload.tsx_data.outputs.length < 2) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'At least 2 outputs are required');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'At least 2 outputs are required');
     }
     const rsigData = payload.tsx_data.rsig_data;
     if (rsigData.grouping.length < 1) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Missing required fields in rsig_data');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Missing required fields in rsig_data');
     }
     if (payload.inputs.length !== payload.tsx_data.num_inputs) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Number of inputs does not match tsx_data.num_inputs');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Number of inputs does not match tsx_data.num_inputs');
     }
     const transformedTsxData = {};
     transformedTsxData.num_inputs = payload.tsx_data.num_inputs;
@@ -99,18 +94,21 @@ class MoneroSignTransactionMethod extends AbstractMethod_1.AbstractMethod {
       }
       return transformedInput;
     });
-    this.params = {
+    const params = {
       address_n: path,
       network_type: payload.networkType,
       tsx_data: transformedTsxData,
       inputs: transformedInputs
     };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Monero'];
+    this.requiredFirmwareCoins = [getMiscNetwork('xmr')];
   }
   get info() {
     return 'Sign Monero transaction';
   }
   async run() {
-    const initResponse = await this.device.getCommands().typedCall('MoneroTransactionInitRequest', 'MoneroTransactionInitAck', {
+    const initResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionInitRequest', 'MoneroTransactionInitAck', {
       version: 0,
       address_n: this.params.address_n,
       network_type: this.params.network_type,
@@ -118,8 +116,12 @@ class MoneroSignTransactionMethod extends AbstractMethod_1.AbstractMethod {
     });
     this.state.hmacs = initResponse.message.hmacs;
     for (let i = 0; i < this.params.inputs.length; i++) {
-      const setInputResponse = await this.device.getCommands().typedCall('MoneroTransactionSetInputRequest', 'MoneroTransactionSetInputAck', {
-        src_entr: this.params.inputs[i]
+      const {
+        inputs
+      } = this.params;
+      const input = inputs[i];
+      const setInputResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionSetInputRequest', 'MoneroTransactionSetInputAck', {
+        src_entr: input
       });
       this.state.vinis.push({
         vini: setInputResponse.message.vini,
@@ -128,13 +130,16 @@ class MoneroSignTransactionMethod extends AbstractMethod_1.AbstractMethod {
         pseudo_out_hmac: setInputResponse.message.pseudo_out_hmac,
         pseudo_out_alpha: setInputResponse.message.pseudo_out_alpha,
         spend_key: setInputResponse.message.spend_key,
-        src_entr: this.params.inputs[i],
+        src_entr: input,
         orig_idx: i
       });
     }
     for (let i = 0; i < this.state.vinis.length; i++) {
-      const viniData = this.state.vinis[i];
-      await this.device.getCommands().typedCall('MoneroTransactionInputViniRequest', 'MoneroTransactionInputViniAck', {
+      const {
+        vinis
+      } = this.state;
+      const viniData = vinis[i];
+      await this.getDevice().getCommands().typedCall('MoneroTransactionInputViniRequest', 'MoneroTransactionInputViniAck', {
         src_entr: viniData.src_entr,
         vini: viniData.vini,
         vini_hmac: viniData.vini_hmac,
@@ -143,12 +148,17 @@ class MoneroSignTransactionMethod extends AbstractMethod_1.AbstractMethod {
         orig_idx: viniData.orig_idx
       });
     }
-    await this.device.getCommands().typedCall('MoneroTransactionAllInputsSetRequest', 'MoneroTransactionAllInputsSetAck', {});
+    await this.getDevice().getCommands().typedCall('MoneroTransactionAllInputsSetRequest', 'MoneroTransactionAllInputsSetAck', {});
     const outputs = this.params.tsx_data.outputs || [];
     for (let i = 0; i < outputs.length; i++) {
-      const setOutputResponse = await this.device.getCommands().typedCall('MoneroTransactionSetOutputRequest', 'MoneroTransactionSetOutputAck', {
-        dst_entr: outputs[i],
-        dst_entr_hmac: this.state.hmacs[i]
+      const output = outputs[i];
+      const {
+        hmacs
+      } = this.state;
+      const hmac = hmacs[i];
+      const setOutputResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionSetOutputRequest', 'MoneroTransactionSetOutputAck', {
+        dst_entr: output,
+        dst_entr_hmac: hmac
       });
       if (setOutputResponse.message.out_pk) {
         this.state.out_pks.push(setOutputResponse.message.out_pk);
@@ -163,13 +173,16 @@ class MoneroSignTransactionMethod extends AbstractMethod_1.AbstractMethod {
         this.state.rsig_parts.push(setOutputResponse.message.rsig_data.rsig);
       }
     }
-    const allOutSetResponse = await this.device.getCommands().typedCall('MoneroTransactionAllOutSetRequest', 'MoneroTransactionAllOutSetAck', {});
+    const allOutSetResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionAllOutSetRequest', 'MoneroTransactionAllOutSetAck', {});
     this.state.tx_prefix_hash = allOutSetResponse.message.tx_prefix_hash;
     this.state.rv = allOutSetResponse.message.rv;
     this.state.extra = allOutSetResponse.message.extra;
     for (let i = 0; i < this.state.vinis.length; i++) {
-      const viniData = this.state.vinis[i];
-      const signResponse = await this.device.getCommands().typedCall('MoneroTransactionSignInputRequest', 'MoneroTransactionSignInputAck', {
+      const {
+        vinis
+      } = this.state;
+      const viniData = vinis[i];
+      const signResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionSignInputRequest', 'MoneroTransactionSignInputAck', {
         src_entr: viniData.src_entr,
         vini: viniData.vini,
         vini_hmac: viniData.vini_hmac,
@@ -184,7 +197,7 @@ class MoneroSignTransactionMethod extends AbstractMethod_1.AbstractMethod {
         this.state.pseudo_outs.push(signResponse.message.pseudo_out);
       }
     }
-    const finalResponse = await this.device.getCommands().typedCall('MoneroTransactionFinalRequest', 'MoneroTransactionFinalAck', {});
+    const finalResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionFinalRequest', 'MoneroTransactionFinalAck', {});
     return {
       signatures: this.state.signatures,
       tx_prefix_hash: this.state.tx_prefix_hash,
@@ -202,6 +215,4 @@ class MoneroSignTransactionMethod extends AbstractMethod_1.AbstractMethod {
       extra: this.state.extra
     };
   }
-}
-exports.default = MoneroSignTransactionMethod;
-//# sourceMappingURL=moneroSignTransaction.js.map
+}

package/lib/api/nostr/nostrGetPublicKey.d.ts

@@ -0,0 +1,15 @@
+import { type PROTO } from '@trezor/connect-common';
+import type { MethodMessage } from "../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../core/AbstractMethod.js";
+export default class NostrGetPublicKey extends AbstractMethod<'nostrGetPublicKey', PROTO.NostrGetPubkey> {
+  constructor(message: MethodMessage<'nostrGetPublicKey'>);
+  get requiredPermissions(): import("@trezor/connect-common").PermissionRequest[];
+  get info(): string;
+  get confirmation(): {
+    view: "export-xpub";
+    label: string;
+  };
+  run(): Promise<{
+    pubkey: string;
+  }>;
+}

package/lib/api/nostr/nostrGetPublicKey.js

@@ -0,0 +1,38 @@
+import { ExperimentalMethod, GetPublicKey as GetPublicKeySchema } 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";
+export default class NostrGetPublicKey extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(GetPublicKeySchema, payload);
+    Assert(ExperimentalMethod, payload);
+    const params = {
+      address_n: validatePath(payload.path)
+    };
+    super(message, params);
+    this.requiredFirmwareCoins = [getMiscNetwork('nostr')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_xpub', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Export nostr public key';
+  }
+  get confirmation() {
+    return {
+      view: 'export-xpub',
+      label: 'Export Nostr public key'
+    };
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const {
+      message
+    } = await cmd.typedCall('NostrGetPubkey', 'NostrPubkey', this.params);
+    return message;
+  }
+}

package/lib/api/nostr/nostrSignEvent.d.ts

@@ -0,0 +1,13 @@
+import { type PROTO } from '@trezor/connect-common';
+import type { MethodMessage } from "../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../core/AbstractMethod.js";
+export default class NostrSignEvent extends AbstractMethod<'nostrSignEvent', PROTO.NostrSignEvent> {
+  constructor(message: MethodMessage<'nostrSignEvent'>);
+  get requiredPermissions(): import("@trezor/connect-common").PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    signature: string;
+    id: string;
+    pubkey: string;
+  }>;
+}

package/lib/api/nostr/nostrSignEvent.js

@@ -0,0 +1,36 @@
+import { ExperimentalMethod, NostrSignEvent as NostrSignEventSchema } 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";
+export default class NostrSignEvent extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(NostrSignEventSchema, payload);
+    Assert(ExperimentalMethod, payload);
+    const params = {
+      address_n: validatePath(payload.path),
+      created_at: payload.created_at,
+      kind: payload.kind,
+      tags: payload.tags,
+      content: payload.content
+    };
+    super(message, params);
+    this.requiredFirmwareCoins = [getMiscNetwork('nostr')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Sign Nostr event';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const {
+      message
+    } = await cmd.typedCall('NostrSignEvent', 'NostrEventSignature', this.params);
+    return message;
+  }
+}

package/lib/api/pingDevice.d.ts

@@ -0,0 +1,11 @@
+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 PingDevice extends AbstractMethod<'pingDevice', PROTO.Ping> {
+  constructor(message: MethodMessage<'pingDevice'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/pingDevice.js

@@ -0,0 +1,29 @@
+import { UI_REQUEST } from "@trezor/connect-common";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class PingDevice extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(PROTO.Ping, payload);
+    const params = {
+      message: payload.message,
+      button_protection: payload.button_protection
+    };
+    super(message, params);
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS, UI_REQUEST.BOOTLOADER];
+    this.useDeviceState = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('Ping', 'Success', this.params);
+    return response.message;
+  }
+}

package/lib/api/pushTransaction.d.ts

@@ -1,16 +1,19 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import type { CoinInfo } from '../types';
-import { PushTransaction as PushTransactionSchema } from '../types/api/pushTransaction';
+import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
+import { PushTransaction as PushTransactionSchema } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 type Params = {
-    tx: PushTransactionSchema['tx'];
-    coinInfo: CoinInfo;
-    identity?: string;
+  tx: PushTransactionSchema['tx'];
+  coinInfo: CoinInfo;
+  identity?: string;
 };
 export default class PushTransaction extends AbstractMethod<'pushTransaction', Params> {
-    init(): void;
-    run(): Promise<{
-        txid: string;
-    }>;
+  constructor(message: MethodMessage<'pushTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    txid: string;
+  }>;
 }
-export {};
-//# sourceMappingURL=pushTransaction.d.ts.map
+export {};

package/lib/api/pushTransaction.js

@@ -1,44 +1,39 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const coinInfo_1 = require("../data/coinInfo");
-const pushTransaction_1 = require("../types/api/pushTransaction");
-class PushTransaction extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['push_tx'];
-    this.useUi = false;
-    this.useDevice = false;
+import { PushTransaction as PushTransactionSchema } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { Assert } from "@trezor/schema-utils";
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+export default class PushTransaction extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(pushTransaction_1.PushTransaction, payload);
-    const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
-    if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-    }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+    } = message;
+    Assert(PushTransactionSchema, payload);
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(coinInfo);
     if (coinInfo.type === 'bitcoin' && (typeof payload.tx !== 'string' || !/^[0-9A-Fa-f]*$/.test(payload.tx))) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Transaction must be hexadecimal');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Transaction must be hexadecimal');
     }
-    this.params = {
+    const params = {
       tx: payload.tx,
       coinInfo,
       identity: payload.identity
     };
+    super(message, params);
+    this.useUi = false;
+    this.useDevice = false;
+  }
+  get requiredPermissions() {
+    return [this.coinPerm('push_tx', this.params.coinInfo)];
   }
-  async run() {
-    const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
     const txid = await backend.pushTransaction(this.params.tx);
     return {
       txid
     };
   }
-}
-exports.default = PushTransaction;
-//# sourceMappingURL=pushTransaction.js.map
+}

package/lib/api/recoveryDevice.d.ts

@@ -1,18 +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 RecoveryDevice extends AbstractMethod<'recoveryDevice', PROTO.RecoveryDevice> {
-    init(): void;
-    get confirmation(): {
-        view: "device-management";
-        customConfirmButton: {
-            className: string;
-            label: string;
-        };
-        label: string;
+  constructor(message: MethodMessage<'recoveryDevice'>);
+  get requiredPermissions(): PermissionRequest[];
+  get confirmation(): {
+    view: "device-management";
+    customConfirmButton: {
+      className: string;
+      label: string;
     };
-    run(): Promise<{
-        message: string;
-    }>;
-    get info(): string;
-}
-//# sourceMappingURL=recoveryDevice.d.ts.map
+    label: string;
+  };
+  run(): Promise<{
+    message: string;
+  }>;
+  get info(): string;
+}

package/lib/api/recoveryDevice.js

@@ -1,22 +1,14 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const events_1 = require("../events");
-const recoveryDevice_1 = require("../types/api/recoveryDevice");
-class RecoveryDevice extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['management'];
-    this.skipFinalReload = false;
-    this.useEmptyPassphrase = true;
+import { UI_REQUEST } from "@trezor/connect-common";
+import { RecoveryDevice as RecoveryDeviceSchema } from "@trezor/connect-common/lib/types/api/management/recoveryDevice.js";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class RecoveryDevice extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(recoveryDevice_1.RecoveryDevice, payload);
-    this.params = {
+    } = message;
+    Assert(RecoveryDeviceSchema, payload);
+    const params = {
       word_count: payload.word_count,
       passphrase_protection: payload.passphrase_protection,
       pin_protection: payload.pin_protection,
@@ -25,10 +17,19 @@ class RecoveryDevice extends AbstractMethod_1.AbstractMethod {
       enforce_wordlist: payload.enforce_wordlist,
       input_method: payload.input_method,
       type: payload.type,
-      u2f_counter: payload.u2f_counter
+      u2f_counter: payload.u2f_counter,
+      backup_method: payload.backup_method
     };
-    this.allowDeviceMode = [...this.allowDeviceMode, events_1.UI.INITIALIZE];
+    super(message, params);
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
     this.useDeviceState = false;
+    this.skipFinalReload = false;
+    this.useEmptyPassphrase = true;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
   get confirmation() {
     return {
@@ -41,13 +42,11 @@ class RecoveryDevice extends AbstractMethod_1.AbstractMethod {
     };
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     const response = await cmd.typedCall('RecoveryDevice', 'Success', this.params);
     return response.message;
   }
   get info() {
     return 'Recover device';
   }
-}
-exports.default = RecoveryDevice;
-//# sourceMappingURL=recoveryDevice.js.map
+}

package/lib/api/requestLogin.d.ts

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

package/lib/api/requestLogin.js

@@ -1,32 +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 paramsValidator_1 = require("./common/paramsValidator");
-const DataManager_1 = require("../data/DataManager");
-const requestLogin_1 = require("../types/api/requestLogin");
-class RequestLogin extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
-    this.useEmptyPassphrase = true;
+import { RequestLoginSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class RequestLogin extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(requestLogin_1.RequestLoginSchema, payload);
+    } = message;
+    Assert(RequestLoginSchema, payload);
     const identity = {};
-    const settings = DataManager_1.DataManager.getSettings();
-    let origin;
-    if (settings.trustedHost && payload.origin) {
-      origin = payload.origin;
-    } else if (settings.origin) {
-      origin = settings.origin;
-    }
+    const {
+      origin
+    } = payload;
     if (origin) {
-      const [proto, host, port] = origin.split(':');
+      const originParts = origin.split(':');
+      const proto = originParts[0] ?? '';
+      const host = originParts[1] ?? '';
+      const port = originParts[2];
       identity.proto = proto;
       identity.host = host.substring(2);
       if (port) {
@@ -34,17 +23,24 @@ class RequestLogin extends AbstractMethod_1.AbstractMethod {
       }
       identity.index = 0;
     }
-    this.params = {
+    const params = {
       identity,
       challenge_hidden: payload.challengeHidden || '',
       challenge_visual: payload.challengeVisual || ''
     };
+    super(message, params);
+    this.useEmptyPassphrase = true;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'sign'
+    }];
   }
   get info() {
     return 'Login';
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     const {
       message
     } = await cmd.typedCall('SignIdentity', 'SignedIdentity', this.params);
@@ -54,6 +50,4 @@ class RequestLogin extends AbstractMethod_1.AbstractMethod {
       signature: message.signature
     };
   }
-}
-exports.default = RequestLogin;
-//# sourceMappingURL=requestLogin.js.map
+}