@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/cardano/api/cardanoGetAddress.js

@@ -1,59 +1,68 @@
-"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 cardano_1 = require("../../../types/api/cardano");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-const cardanoAddressParameters_1 = require("../cardanoAddressParameters");
-class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
+import { Bundle, CardanoGetAddress as CardanoGetAddressSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { getSerializedPath } from "../../../utils/pathUtils.js";
+import { bundlify } from "../../common/paramsValidator.js";
+import { addressParametersFromProto, addressParametersToProto, modifyAddressParametersForBackwardsCompatibility, validateAddressParameters } from "../cardanoAddressParameters.js";
+export default class CardanoGetAddress extends AbstractMethod {
   hasBundle;
   progress = 0;
-  init() {
-    this.noBackupConfirmationMode = 'always';
-    this.requiredPermissions = ['read'];
-    this.requiredDeviceCapabilities = ['Capability_Cardano'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), 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)(cardano_1.CardanoGetAddress), payload);
-    this.params = payload.bundle.map(batch => {
-      (0, cardanoAddressParameters_1.validateAddressParameters)(batch.addressParameters);
-      return {
-        address_parameters: (0, cardanoAddressParameters_1.addressParametersToProto)(batch.addressParameters),
-        address: batch.address,
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(CardanoGetAddressSchema), payload);
+    const params = payload.bundle.map(batch => {
+      validateAddressParameters(batch.addressParameters);
+      const proto = {
+        address_parameters: addressParametersToProto(batch.addressParameters),
         protocol_magic: batch.protocolMagic,
         network_id: batch.networkId,
-        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : PROTO.CardanoDerivationType.ICARUS_TREZOR,
         show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
         chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
       };
+      return {
+        proto,
+        address: batch.address
+      };
     });
-    const useEventListener = payload.useEventListener && this.params.length === 1 && typeof this.params[0].address === 'string' && this.params[0].show_display;
-    this.useUi = !useEventListener;
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.confirmMissingBackup = true;
+    this.requiredDeviceCapabilities = ['Capability_Cardano'];
+    this.requiredFirmwareCoins = [getMiscNetwork('ada')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_address', this.requiredFirmwareCoins);
   }
   get info() {
     if (this.params.length === 1) {
-      return `Export Cardano address for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_parameters.address_n[2]) + 1}`;
+      const {
+        params
+      } = this;
+      const first = params[0];
+      const addressN = first.proto.address_parameters.address_n;
+      const accountIndex = addressN[2];
+      return `Export Cardano address for account #${fromHardenedPathPart(accountIndex) + 1}`;
     }
     return 'Export multiple Cardano addresses';
   }
   getButtonRequestData(code) {
     if (code === 'ButtonRequest_Address') {
+      const {
+        params
+      } = this;
+      const current = params[this.progress];
       return {
         type: 'address',
-        serializedPath: (0, pathUtils_1.getSerializedPath)(this.params[this.progress].address_parameters.address_n),
-        address: this.params[this.progress].address || 'not-set'
+        serializedPath: getSerializedPath(current.proto.address_parameters.address_n),
+        address: current.address || 'not-set'
       };
     }
   }
@@ -64,37 +73,33 @@ class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
     };
   }
   async _call({
-    address_parameters,
-    protocol_magic,
-    network_id,
-    derivation_type,
-    show_display,
-    chunkify
+    proto
   }) {
-    const cmd = this.device.getCommands();
-    const response = await cmd.typedCall('CardanoGetAddress', 'CardanoAddress', {
-      address_parameters,
-      protocol_magic,
-      network_id,
-      derivation_type,
-      show_display,
-      chunkify
-    });
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('CardanoGetAddress', 'CardanoAddress', proto);
     return response.message;
   }
-  async run() {
+  async run({
+    sendCoreMessage
+  }) {
     const responses = [];
     for (let i = 0; i < this.params.length; i++) {
-      const batch = this.params[i];
-      batch.address_parameters = (0, cardanoAddressParameters_1.modifyAddressParametersForBackwardsCompatibility)(batch.address_parameters);
-      if (batch.show_display) {
+      const {
+        params
+      } = this;
+      const batch = params[i];
+      batch.proto.address_parameters = modifyAddressParametersForBackwardsCompatibility(batch.proto.address_parameters);
+      if (batch.proto.show_display) {
         const silent = await this._call({
           ...batch,
-          show_display: false
+          proto: {
+            ...batch.proto,
+            show_display: false
+          }
         });
         if (typeof batch.address === 'string') {
           if (batch.address !== silent.address) {
-            throw constants_1.ERRORS.TypedError('Method_AddressNotMatch');
+            throw ERRORS.TypedError('Method_AddressNotMatch');
           }
         } else {
           batch.address = silent.address;
@@ -102,15 +107,16 @@ class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
       }
       const response = await this._call(batch);
       responses.push({
-        addressParameters: (0, cardanoAddressParameters_1.addressParametersFromProto)(batch.address_parameters),
-        protocolMagic: batch.protocol_magic,
-        networkId: batch.network_id,
-        serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_parameters.address_n),
-        serializedStakingPath: (0, pathUtils_1.getSerializedPath)(batch.address_parameters.address_n_staking),
-        address: response.address
+        addressParameters: addressParametersFromProto(batch.proto.address_parameters),
+        protocolMagic: batch.proto.protocol_magic,
+        networkId: batch.proto.network_id,
+        serializedPath: getSerializedPath(batch.proto.address_parameters.address_n),
+        serializedStakingPath: getSerializedPath(batch.proto.address_parameters.address_n_staking),
+        address: response.address,
+        mac: response.mac
       });
       if (this.hasBundle) {
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
           total: this.params.length,
           progress: i,
           response
@@ -118,8 +124,7 @@ class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
       }
       this.progress++;
     }
-    return this.hasBundle ? responses : responses[0];
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
   }
-}
-exports.default = CardanoGetAddress;
-//# sourceMappingURL=cardanoGetAddress.js.map
+}

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

@@ -1,13 +1,12 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-import { CardanoNativeScript } from '../../../types/api/cardano';
+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 CardanoGetNativeScriptHash extends AbstractMethod<'cardanoGetNativeScriptHash', PROTO.CardanoGetNativeScriptHash> {
-    init(): void;
-    get info(): string;
-    validateScript(script: CardanoNativeScript): void;
-    scriptToProto(script: CardanoNativeScript): PROTO.CardanoNativeScript;
-    run(): Promise<{
-        scriptHash: string;
-    }>;
-}
-//# sourceMappingURL=cardanoGetNativeScriptHash.d.ts.map
+  constructor(message: MethodMessage<'cardanoGetNativeScriptHash'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    scriptHash: string;
+  }>;
+}

package/lib/api/cardano/api/cardanoGetNativeScriptHash.js

@@ -1,67 +1,60 @@
-"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 cardano_1 = require("../../../types/api/cardano");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-class CardanoGetNativeScriptHash extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read'];
-    this.requiredDeviceCapabilities = ['Capability_Cardano'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), this.firmwareRange);
+import { CardanoGetNativeScriptHash as CardanoGetNativeScriptHashSchema } from "@trezor/connect-common";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+const validateScript = script => {
+  if (script.keyPath) {
+    validatePath(script.keyPath, 3);
+  }
+  script.scripts?.forEach(validateScript);
+};
+const scriptToProto = script => {
+  let scripts = [];
+  if (script.scripts) {
+    scripts = script.scripts.map(scriptToProto);
+  }
+  let keyPath = [];
+  if (script.keyPath) {
+    keyPath = validatePath(script.keyPath, 3);
+  }
+  return {
+    type: script.type,
+    scripts,
+    key_hash: script.keyHash,
+    key_path: keyPath,
+    required_signatures_count: script.requiredSignaturesCount,
+    invalid_before: script.invalidBefore,
+    invalid_hereafter: script.invalidHereafter
+  };
+};
+export default class CardanoGetNativeScriptHash extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(cardano_1.CardanoGetNativeScriptHash, payload);
-    this.validateScript(payload.script);
-    this.params = {
-      script: this.scriptToProto(payload.script),
+    } = message;
+    Assert(CardanoGetNativeScriptHashSchema, payload);
+    validateScript(payload.script);
+    const params = {
+      script: scriptToProto(payload.script),
       display_format: payload.displayFormat,
-      derivation_type: typeof payload.derivationType !== 'undefined' ? payload.derivationType : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR
+      derivation_type: typeof payload.derivationType !== 'undefined' ? payload.derivationType : PROTO.CardanoDerivationType.ICARUS_TREZOR
     };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Cardano'];
+    this.requiredFirmwareCoins = [getMiscNetwork('ada')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_address', this.requiredFirmwareCoins);
   }
   get info() {
     return 'Get Cardano native script hash';
   }
-  validateScript(script) {
-    if (script.keyPath) {
-      (0, pathUtils_1.validatePath)(script.keyPath, 3);
-    }
-    if (script.scripts) {
-      script.scripts.forEach(nestedScript => {
-        this.validateScript(nestedScript);
-      });
-    }
-  }
-  scriptToProto(script) {
-    let scripts = [];
-    if (script.scripts) {
-      scripts = script.scripts.map(nestedScript => this.scriptToProto(nestedScript));
-    }
-    let keyPath = [];
-    if (script.keyPath) {
-      keyPath = (0, pathUtils_1.validatePath)(script.keyPath, 3);
-    }
-    return {
-      type: script.type,
-      scripts,
-      key_hash: script.keyHash,
-      key_path: keyPath,
-      required_signatures_count: script.requiredSignaturesCount,
-      invalid_before: script.invalidBefore,
-      invalid_hereafter: script.invalidHereafter
-    };
-  }
   async run() {
     const {
       message
-    } = await this.device.getCommands().typedCall('CardanoGetNativeScriptHash', 'CardanoNativeScriptHash', {
+    } = await this.getDevice().getCommands().typedCall('CardanoGetNativeScriptHash', 'CardanoNativeScriptHash', {
       script: this.params.script,
       display_format: this.params.display_format,
       derivation_type: this.params.derivation_type
@@ -70,6 +63,4 @@ class CardanoGetNativeScriptHash extends AbstractMethod_1.AbstractMethod {
       scriptHash: message.script_hash
     };
   }
-}
-exports.default = CardanoGetNativeScriptHash;
-//# sourceMappingURL=cardanoGetNativeScriptHash.js.map
+}

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

@@ -1,17 +1,22 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-interface Params extends PROTO.CardanoGetPublicKey {
-    suppressBackupWarning?: boolean;
+import { type PermissionRequest } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+interface Params {
+  proto: PROTO.CardanoGetPublicKey;
+  suppressBackupWarning?: boolean;
 }
 export default class CardanoGetPublicKey extends AbstractMethod<'cardanoGetPublicKey', Params[]> {
-    hasBundle?: boolean;
-    init(): void;
-    get info(): string;
-    get confirmation(): {
-        view: "export-xpub";
-        label: string;
-    };
-    run(): Promise<import("../../../types").CardanoPublicKey | import("../../../types").CardanoPublicKey[]>;
+  hasBundle?: boolean;
+  constructor(message: MethodMessage<'cardanoGetPublicKey'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  get confirmation(): {
+    view: "export-xpub";
+    label: string;
+  };
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<import("@trezor/connect-common").CardanoPublicKey | import("@trezor/connect-common").CardanoPublicKey[]>;
 }
-export {};
-//# sourceMappingURL=cardanoGetPublicKey.d.ts.map
+export {};

package/lib/api/cardano/api/cardanoGetPublicKey.js

@@ -1,73 +1,92 @@
-"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 cardano_1 = require("../../../types/api/cardano");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-class CardanoGetPublicKey extends AbstractMethod_1.AbstractMethod {
+import { Bundle, CardanoGetPublicKey as CardanoGetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { getSerializedPath, validatePath } from "../../../utils/pathUtils.js";
+import { bundlify } from "../../common/paramsValidator.js";
+export default class CardanoGetPublicKey extends AbstractMethod {
   hasBundle;
-  init() {
-    this.requiredPermissions = ['read'];
-    this.requiredDeviceCapabilities = ['Capability_Cardano'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), 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)(cardano_1.CardanoGetPublicKey), payload);
-    this.params = payload.bundle.map(batch => {
-      const path = (0, pathUtils_1.validatePath)(batch.path, 3);
-      return {
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(CardanoGetPublicKeySchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 3);
+      const proto = {
         address_n: path,
-        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
-        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false,
-        suppress_backup_warning: batch.suppressBackupWarning
+        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false
+      };
+      return {
+        proto,
+        suppressBackupWarning: batch.suppressBackupWarning
       };
     });
-    this.noBackupConfirmationMode = this.params.every(batch => batch.suppressBackupWarning || !batch.show_display) ? 'popup-only' : 'always';
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.confirmMissingBackup = !this.params.every(batch => batch.suppressBackupWarning || !batch.proto.show_display);
+    this.requiredDeviceCapabilities = ['Capability_Cardano'];
+    this.requiredFirmwareCoins = [getMiscNetwork('ada')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_xpub', this.requiredFirmwareCoins);
   }
   get info() {
     return 'Export Cardano public key';
   }
   get confirmation() {
+    if (this.params.length > 1) {
+      return {
+        view: 'export-xpub',
+        label: 'Export multiple Cardano public keys'
+      };
+    }
+    const {
+      params
+    } = this;
+    const first = params[0];
+    const addressN = first.proto.address_n;
+    const accountIndex = addressN[2];
     return {
       view: 'export-xpub',
-      label: this.params.length > 1 ? 'Export multiple Cardano public keys' : `Export Cardano public key for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`
+      label: `Export Cardano public key for account #${fromHardenedPathPart(accountIndex) + 1}`
     };
   }
-  async run() {
+  async run({
+    sendCoreMessage
+  }) {
     const responses = [];
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     for (let i = 0; i < this.params.length; i++) {
-      const batch = this.params[i];
+      const {
+        params
+      } = this;
+      const param = params[i];
+      const batch = param.proto;
       const {
         message
       } = await cmd.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', batch);
       responses.push({
         path: batch.address_n,
-        serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
-        publicKey: message.xpub,
+        serializedPath: getSerializedPath(batch.address_n),
+        publicKey: message.node.public_key,
+        xpub: message.xpub,
+        displayablePublicKey: message.xpub,
         node: message.node
       });
       if (this.hasBundle) {
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
           total: this.params.length,
           progress: i,
           response: message
         }));
       }
     }
-    return this.hasBundle ? responses : responses[0];
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
   }
-}
-exports.default = CardanoGetPublicKey;
-//# sourceMappingURL=cardanoGetPublicKey.js.map
+}

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

@@ -1,25 +1,22 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-import { CardanoMessageHeaders, CardanoSignedMessage } from '../../../types/api/cardano';
-import { Path } from '../cardanoInputs';
+import { type CardanoMessageHeaders, type CardanoSignedMessage, 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";
+import type { Path } from "../cardanoInputs.js";
 export type CardanoSignMessageParams = {
-    path: Path;
-    payload: string;
-    preferHexDisplay: boolean;
-    networkId?: number;
-    protocolMagic?: number;
-    addressParameters?: PROTO.CardanoAddressParametersType;
-    derivationType: PROTO.CardanoDerivationType;
+  path: Path;
+  payload: string;
+  preferHexDisplay: boolean;
+  networkId?: number;
+  protocolMagic?: number;
+  addressParameters?: PROTO.CardanoAddressParametersType;
+  derivationType: PROTO.CardanoDerivationType;
 };
 export default class CardanoSignMessage extends AbstractMethod<'cardanoSignMessage', CardanoSignMessageParams> {
-    static readonly VERSION = 1;
-    init(): void;
-    run(): Promise<CardanoSignedMessage>;
-    _createHeaders(address: string): CardanoMessageHeaders;
-    _createCose(payload: string, signature: string, address: string, pubKey: string): {
-        coseSignature: string;
-        coseKey: string;
-    };
-    get info(): string;
-}
-//# sourceMappingURL=cardanoSignMessage.d.ts.map
+  static readonly VERSION = 1;
+  constructor(message: MethodMessage<'cardanoSignMessage'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<CardanoSignedMessage>;
+  _createHeaders(address: string): CardanoMessageHeaders;
+  get info(): string;
+}