@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/cardano/api/cardanoSignMessage.js

@@ -1,45 +1,42 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const tslib_1 = require("tslib");
-const cbor = tslib_1.__importStar(require("cbor"));
-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 formatUtils_1 = require("../../../utils/formatUtils");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-const cardanoAddressParameters_1 = require("../cardanoAddressParameters");
-const cardanoUtils_1 = require("../cardanoUtils");
-class CardanoSignMessage extends AbstractMethod_1.AbstractMethod {
+import { CARDANO, CardanoSignMessage as CardanoSignMessageSchema } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import cardano from "@trezor/network-cardano/runtime";
+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 { hasHexPrefix, isHexString } from "../../../utils/formatUtils.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+import { addressParametersToProto } from "../cardanoAddressParameters.js";
+import { hexStringByteLength } from "../cardanoUtils.js";
+export default class CardanoSignMessage extends AbstractMethod {
   static VERSION = 1;
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), this.firmwareRange);
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(cardano_1.CardanoSignMessage, payload);
-    if (!(0, formatUtils_1.isHexString)(payload.payload) || (0, formatUtils_1.hasHexPrefix)(payload.payload)) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Message payload must be a hexadecimal string without a "0x" prefix.');
+    } = message;
+    Assert(CardanoSignMessageSchema, payload);
+    if (!isHexString(payload.payload) || hasHexPrefix(payload.payload) || payload.payload.length % 2 !== 0) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Message payload must be a byte-aligned hexadecimal string (even number of characters) without a "0x" prefix.');
     }
-    this.params = {
-      path: (0, pathUtils_1.validatePath)(payload.path, 5),
+    const params = {
+      path: validatePath(payload.path, 5),
       payload: payload.payload,
       preferHexDisplay: payload.preferHexDisplay ?? false,
       networkId: payload.networkId,
       protocolMagic: payload.protocolMagic,
-      addressParameters: payload.addressParameters && (0, cardanoAddressParameters_1.addressParametersToProto)(payload.addressParameters),
-      derivationType: payload.derivationType ?? constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR
+      addressParameters: payload.addressParameters && addressParametersToProto(payload.addressParameters),
+      derivationType: payload.derivationType ?? PROTO.CardanoDerivationType.ICARUS_TREZOR
     };
+    super(message, params);
+    this.requiredFirmwareCoins = [getMiscNetwork('ada')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
   }
   async run() {
-    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    const payloadSize = (0, cardanoUtils_1.hexStringByteLength)(this.params.payload);
+    const typedCall = this.getDevice().getCommands().typedCall.bind(this.getDevice().getCommands());
+    const payloadSize = hexStringByteLength(this.params.payload);
     let response = await typedCall('CardanoSignMessageInit', ['CardanoMessageSignature', 'CardanoMessageDataRequest'], {
       signing_path: this.params.path,
       payload_size: payloadSize,
@@ -64,18 +61,21 @@ class CardanoSignMessage extends AbstractMethod_1.AbstractMethod {
       address,
       pub_key
     } = response.message;
+    const {
+      createCose
+    } = await cardano();
     return {
       signature,
       payload: this.params.payload,
       headers: this._createHeaders(address),
       pubKey: pub_key,
-      ...this._createCose(this.params.payload, signature, address, pub_key)
+      ...createCose(this.params.payload, signature, address, pub_key)
     };
   }
   _createHeaders(address) {
     return {
       protected: {
-        1: constants_1.CARDANO.ALGORITHM_IDS.EdDSA,
+        1: CARDANO.ALGORITHM_IDS.EdDSA,
         address
       },
       unprotected: {
@@ -84,17 +84,7 @@ class CardanoSignMessage extends AbstractMethod_1.AbstractMethod {
       }
     };
   }
-  _createCose(payload, signature, address, pubKey) {
-    const coseSignature = cbor.encode([Buffer.from(cbor.encode(new Map().set(1, -8).set('address', Buffer.from(address, 'hex')))), new Map().set('hashed', false), Buffer.from(payload, 'hex'), Buffer.from(signature, 'hex')]);
-    const coseKey = cbor.encode(new Map().set(1, 1).set(3, -8).set(-1, 6).set(-2, Buffer.from(pubKey, 'hex')));
-    return {
-      coseSignature: Buffer.from(coseSignature).toString('hex'),
-      coseKey: Buffer.from(coseKey).toString('hex')
-    };
-  }
   get info() {
     return 'Sign Cardano message';
   }
-}
-exports.default = CardanoSignMessage;
-//# sourceMappingURL=cardanoSignMessage.js.map
+}

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

@@ -1,79 +1,81 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-import { type CardanoSignedTxData } from '../../../types/api/cardano';
-import type { CertificateWithPoolOwnersAndRelays } from '../cardanoCertificate';
-import { CollateralInputWithPath, InputWithPath, Path } from '../cardanoInputs';
-import type { OutputWithData } from '../cardanoOutputs';
-import type { AssetGroupWithTokens } from '../cardanoTokenBundle';
+import { type CardanoSignedTxData, 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 { CertificateWithPoolOwnersAndRelays } from "../cardanoCertificate.js";
+import type { CollateralInputWithPath, InputWithPath, Path } from "../cardanoInputs.js";
+import type { OutputWithData } from "../cardanoOutputs.js";
+import type { AssetGroupWithTokens } from "../cardanoTokenBundle.js";
 declare const CardanoSignTransactionFeatures: Readonly<{
-    Conway: string[];
+  Conway: string[];
 }>;
 export type CardanoSignTransactionParams = {
-    signingMode: PROTO.CardanoTxSigningMode;
-    inputsWithPath: InputWithPath[];
-    outputsWithData: OutputWithData[];
-    fee: PROTO.CardanoSignTxInit['fee'];
-    ttl?: PROTO.CardanoSignTxInit['ttl'];
-    certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[];
-    withdrawals: PROTO.CardanoTxWithdrawal[];
-    mint: AssetGroupWithTokens[];
-    auxiliaryData?: PROTO.CardanoTxAuxiliaryData;
-    validityIntervalStart?: PROTO.CardanoSignTxInit['validity_interval_start'];
-    scriptDataHash?: string;
-    collateralInputsWithPath: CollateralInputWithPath[];
-    requiredSigners: PROTO.CardanoTxRequiredSigner[];
-    collateralReturnWithData?: OutputWithData;
-    totalCollateral?: PROTO.CardanoSignTxInit['total_collateral'];
-    referenceInputs: PROTO.CardanoTxReferenceInput[];
-    protocolMagic: number;
-    networkId: number;
-    witnessPaths: Path[];
-    additionalWitnessRequests: Path[];
-    derivationType: PROTO.CardanoDerivationType;
-    includeNetworkId?: boolean;
-    tagCborSets?: boolean;
-    unsignedTx?: {
-        body: string;
-        hash: string;
-    };
-    testnet?: boolean;
-    chunkify?: boolean;
+  signingMode: PROTO.CardanoTxSigningMode;
+  inputsWithPath: InputWithPath[];
+  outputsWithData: OutputWithData[];
+  fee: PROTO.CardanoSignTxInit['fee'];
+  ttl?: PROTO.CardanoSignTxInit['ttl'];
+  certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[];
+  withdrawals: PROTO.CardanoTxWithdrawal[];
+  mint: AssetGroupWithTokens[];
+  auxiliaryData?: PROTO.CardanoTxAuxiliaryData;
+  validityIntervalStart?: PROTO.CardanoSignTxInit['validity_interval_start'];
+  scriptDataHash?: string;
+  collateralInputsWithPath: CollateralInputWithPath[];
+  requiredSigners: PROTO.CardanoTxRequiredSigner[];
+  collateralReturnWithData?: OutputWithData;
+  totalCollateral?: PROTO.CardanoSignTxInit['total_collateral'];
+  referenceInputs: PROTO.CardanoTxReferenceInput[];
+  protocolMagic: number;
+  networkId: number;
+  witnessPaths: Path[];
+  additionalWitnessRequests: Path[];
+  derivationType: PROTO.CardanoDerivationType;
+  includeNetworkId?: boolean;
+  tagCborSets?: boolean;
+  unsignedTx?: {
+    body: string;
+    hash: string;
+  };
+  testnet?: boolean;
+  chunkify?: boolean;
+  payment_req?: PROTO.PaymentRequest;
 };
 export default class CardanoSignTransaction extends AbstractMethod<'cardanoSignTransaction', CardanoSignTransactionParams> {
-    init(): void;
-    get info(): string;
-    _isFeatureSupported(feature: keyof typeof CardanoSignTransactionFeatures): boolean;
-    _ensureFeatureIsSupported(feature: keyof typeof CardanoSignTransactionFeatures): void;
-    _ensureFirmwareSupportsParams(): void;
-    _sign_tx(): Promise<CardanoSignedTxData>;
-    run(): Promise<{
-        auxiliaryDataSupplement?: {
-            cVoteRegistrationSignature?: string | undefined;
-            type: PROTO.CardanoTxAuxiliaryDataSupplementType;
-            auxiliaryDataHash: string;
-        } | undefined;
-        hash: string;
-        witnesses: {
-            chainCode?: string | undefined;
-            type: PROTO.CardanoTxWitnessType;
-            signature: string;
-            pubKey: string;
-        }[];
-    } | {
-        serializedTx: string;
-        auxiliaryDataSupplement?: {
-            cVoteRegistrationSignature?: string | undefined;
-            type: PROTO.CardanoTxAuxiliaryDataSupplementType;
-            auxiliaryDataHash: string;
-        } | undefined;
-        hash: string;
-        witnesses: {
-            chainCode?: string | undefined;
-            type: PROTO.CardanoTxWitnessType;
-            signature: string;
-            pubKey: string;
-        }[];
-    }>;
+  constructor(message: MethodMessage<'cardanoSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  _isFeatureSupported(feature: keyof typeof CardanoSignTransactionFeatures): boolean;
+  _ensureFeatureIsSupported(feature: keyof typeof CardanoSignTransactionFeatures): void;
+  _ensureFirmwareSupportsParams(): void;
+  _sign_tx(): Promise<CardanoSignedTxData>;
+  run(): Promise<{
+    auxiliaryDataSupplement?: {
+      cVoteRegistrationSignature?: string | undefined;
+      type: PROTO.CardanoTxAuxiliaryDataSupplementType;
+      auxiliaryDataHash: string;
+    } | undefined;
+    hash: string;
+    witnesses: {
+      chainCode?: string | undefined;
+      type: PROTO.CardanoTxWitnessType;
+      signature: string;
+      pubKey: string;
+    }[];
+  } | {
+    serializedTx: string;
+    auxiliaryDataSupplement?: {
+      cVoteRegistrationSignature?: string | undefined;
+      type: PROTO.CardanoTxAuxiliaryDataSupplementType;
+      auxiliaryDataHash: string;
+    } | undefined;
+    hash: string;
+    witnesses: {
+      chainCode?: string | undefined;
+      type: PROTO.CardanoTxWitnessType;
+      signature: string;
+      pubKey: string;
+    }[];
+  }>;
 }
-export {};
-//# sourceMappingURL=cardanoSignTransaction.d.ts.map
+export {};

package/lib/api/cardano/api/cardanoSignTransaction.js

@@ -1,58 +1,51 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const coin_selection_1 = require("@fivebinaries/coin-selection");
-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");
-const cardanoAuxiliaryData_1 = require("../cardanoAuxiliaryData");
-const cardanoCertificate_1 = require("../cardanoCertificate");
-const cardanoInputs_1 = require("../cardanoInputs");
-const cardanoOutputs_1 = require("../cardanoOutputs");
-const cardanoTokenBundle_1 = require("../cardanoTokenBundle");
-const cardanoWitnesses_1 = require("../cardanoWitnesses");
+import { CardanoSignTransactionExtended, CardanoSignTransaction as CardanoSignTransactionSchema } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import cardano from "@trezor/network-cardano/runtime";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert, Type } 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";
+import { modifyAuxiliaryDataForBackwardsCompatibility, transformAuxiliaryData } from "../cardanoAuxiliaryData.js";
+import { transformCertificate } from "../cardanoCertificate.js";
+import { transformCollateralInput, transformInput, transformReferenceInput } from "../cardanoInputs.js";
+import { sendOutput, transformOutput } from "../cardanoOutputs.js";
+import { tokenBundleToProto } from "../cardanoTokenBundle.js";
+import { gatherWitnessPaths } from "../cardanoWitnesses.js";
 const CardanoSignTransactionFeatures = Object.freeze({
   Conway: ['0', '2.7.1']
 });
-class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.requiredDeviceCapabilities = ['Capability_Cardano'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), this.firmwareRange);
+export default class CardanoSignTransaction extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
+    } = message;
     if (payload.metadata) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Metadata field has been replaced by auxiliaryData.');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Metadata field has been replaced by auxiliaryData.');
     }
-    if (payload.auxiliaryData && payload.auxiliaryData.blob) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Auxiliary data can now only be sent as a hash.');
+    if (payload.auxiliaryData?.blob) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Auxiliary data can now only be sent as a hash.');
     }
-    if (payload.auxiliaryData && payload.auxiliaryData.catalystRegistrationParameters) {
+    if (payload.auxiliaryData?.catalystRegistrationParameters) {
       console.warn('Please use cVoteRegistrationParameters instead of catalystRegistrationParameters.');
       payload.auxiliaryData.cVoteRegistrationParameters = payload.auxiliaryData.catalystRegistrationParameters;
     }
-    if (payload.auxiliaryData && payload.auxiliaryData.governanceRegistrationParameters) {
+    if (payload.auxiliaryData?.governanceRegistrationParameters) {
       console.warn('Please use cVoteRegistrationParameters instead of governanceRegistrationParameters.');
       payload.auxiliaryData.cVoteRegistrationParameters = payload.auxiliaryData.governanceRegistrationParameters;
     }
-    (0, schema_utils_1.AssertWeak)(schema_utils_1.Type.Union([cardano_1.CardanoSignTransaction, cardano_1.CardanoSignTransactionExtended]), payload);
-    const inputsWithPath = payload.inputs.map(cardanoInputs_1.transformInput);
-    const outputsWithData = payload.outputs.map(cardanoOutputs_1.transformOutput);
+    Assert(Type.Union([CardanoSignTransactionSchema, CardanoSignTransactionExtended]), payload);
+    const inputsWithPath = payload.inputs.map(transformInput);
+    const outputsWithData = payload.outputs.map(transformOutput);
     let certificatesWithPoolOwnersAndRelays = [];
     if (payload.certificates) {
-      certificatesWithPoolOwnersAndRelays = payload.certificates.map(cardanoCertificate_1.transformCertificate);
+      certificatesWithPoolOwnersAndRelays = payload.certificates.map(transformCertificate);
     }
     let withdrawals = [];
     if (payload.withdrawals) {
       withdrawals = payload.withdrawals.map(withdrawal => ({
-        path: withdrawal.path ? (0, pathUtils_1.validatePath)(withdrawal.path, 5) : undefined,
+        path: withdrawal.path ? validatePath(withdrawal.path, 5) : undefined,
         amount: withdrawal.amount,
         script_hash: withdrawal.scriptHash,
         key_hash: withdrawal.keyHash
@@ -60,33 +53,33 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
     }
     let mint = [];
     if (payload.mint) {
-      mint = (0, cardanoTokenBundle_1.tokenBundleToProto)(payload.mint);
+      mint = tokenBundleToProto(payload.mint);
     }
     let auxiliaryData;
     if (payload.auxiliaryData) {
-      auxiliaryData = (0, cardanoAuxiliaryData_1.transformAuxiliaryData)(payload.auxiliaryData);
+      auxiliaryData = transformAuxiliaryData(payload.auxiliaryData);
     }
     let additionalWitnessRequests = [];
     if (payload.additionalWitnessRequests) {
-      additionalWitnessRequests = payload.additionalWitnessRequests.map(witnessRequest => (0, pathUtils_1.validatePath)(witnessRequest, 3));
+      additionalWitnessRequests = payload.additionalWitnessRequests.map(witnessRequest => validatePath(witnessRequest, 3));
     }
     let collateralInputsWithPath = [];
     if (payload.collateralInputs) {
-      collateralInputsWithPath = payload.collateralInputs.map(cardanoInputs_1.transformCollateralInput);
+      collateralInputsWithPath = payload.collateralInputs.map(transformCollateralInput);
     }
     let requiredSigners = [];
     if (payload.requiredSigners) {
       requiredSigners = payload.requiredSigners.map(requiredSigner => ({
-        key_path: requiredSigner.keyPath ? (0, pathUtils_1.validatePath)(requiredSigner.keyPath, 3) : undefined,
+        key_path: requiredSigner.keyPath ? validatePath(requiredSigner.keyPath, 3) : undefined,
         key_hash: requiredSigner.keyHash
       }));
     }
-    const collateralReturnWithData = payload.collateralReturn ? (0, cardanoOutputs_1.transformOutput)(payload.collateralReturn) : undefined;
+    const collateralReturnWithData = payload.collateralReturn ? transformOutput(payload.collateralReturn) : undefined;
     let referenceInputs = [];
     if (payload.referenceInputs) {
-      referenceInputs = payload.referenceInputs.map(cardanoInputs_1.transformReferenceInput);
+      referenceInputs = payload.referenceInputs.map(transformReferenceInput);
     }
-    this.params = {
+    const params = {
       signingMode: payload.signingMode,
       inputsWithPath,
       outputsWithData,
@@ -105,25 +98,32 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
       referenceInputs,
       protocolMagic: payload.protocolMagic,
       networkId: payload.networkId,
-      witnessPaths: (0, cardanoWitnesses_1.gatherWitnessPaths)(inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, payload.signingMode),
+      witnessPaths: gatherWitnessPaths(inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, payload.signingMode),
       additionalWitnessRequests,
-      derivationType: typeof payload.derivationType !== 'undefined' ? payload.derivationType : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
+      derivationType: typeof payload.derivationType !== 'undefined' ? payload.derivationType : PROTO.CardanoDerivationType.ICARUS_TREZOR,
       includeNetworkId: payload.includeNetworkId,
       tagCborSets: payload.tagCborSets,
       unsignedTx: 'unsignedTx' in payload ? payload.unsignedTx : undefined,
       testnet: 'testnet' in payload ? payload.testnet : undefined,
-      chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false
+      chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false,
+      payment_req: payload.payment_req ? encodePaymentRequestAmount(payload.payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT) : undefined
     };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Cardano'];
+    this.requiredFirmwareCoins = [getMiscNetwork('ada')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
   }
   get info() {
     return 'Sign Cardano transaction';
   }
   _isFeatureSupported(feature) {
-    return this.device.atLeast(CardanoSignTransactionFeatures[feature]);
+    return this.getDevice().atLeast(CardanoSignTransactionFeatures[feature]);
   }
   _ensureFeatureIsSupported(feature) {
     if (!this._isFeatureSupported(feature)) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Feature ${feature} not supported by device firmware`);
+      throw ERRORS.TypedError('Method_InvalidParameter', `Feature ${feature} not supported by device firmware`);
     }
   }
   _ensureFirmwareSupportsParams() {
@@ -133,7 +133,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
     params.certificatesWithPoolOwnersAndRelays.forEach(({
       certificate
     }) => {
-      if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY || certificate.type === constants_1.PROTO.CardanoCertificateType.VOTE_DELEGATION) {
+      if (certificate.type === PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY || certificate.type === PROTO.CardanoCertificateType.VOTE_DELEGATION) {
         this._ensureFeatureIsSupported('Conway');
       }
     });
@@ -144,7 +144,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
   async _sign_tx() {
     const {
       typedCall
-    } = this.device.getCommands();
+    } = this.getDevice().getCommands();
     const hasAuxiliaryData = !!this.params.auxiliaryData;
     const signTxInitMessage = {
       signing_mode: this.params.signingMode,
@@ -169,7 +169,8 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
       derivation_type: this.params.derivationType,
       include_network_id: this.params.includeNetworkId,
       chunkify: this.params.chunkify,
-      tag_cbor_sets: this.params.tagCborSets
+      tag_cbor_sets: this.params.tagCborSets,
+      payment_req: this.params.payment_req
     };
     await typedCall('CardanoSignTxInit', 'CardanoTxItemAck', signTxInitMessage);
     for (const {
@@ -178,7 +179,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
       await typedCall('CardanoTxInput', 'CardanoTxItemAck', input);
     }
     for (const outputWithData of this.params.outputsWithData) {
-      await (0, cardanoOutputs_1.sendOutput)(typedCall, outputWithData);
+      await sendOutput(typedCall, outputWithData);
     }
     for (const {
       certificate,
@@ -202,13 +203,13 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         cvote_registration_parameters
       } = this.params.auxiliaryData;
       if (cvote_registration_parameters) {
-        this.params.auxiliaryData = (0, cardanoAuxiliaryData_1.modifyAuxiliaryDataForBackwardsCompatibility)(this.params.auxiliaryData);
+        this.params.auxiliaryData = modifyAuxiliaryDataForBackwardsCompatibility(this.params.auxiliaryData);
       }
       const {
         message
       } = await typedCall('CardanoTxAuxiliaryData', 'CardanoTxAuxiliaryDataSupplement', this.params.auxiliaryData);
-      const auxiliaryDataType = constants_1.PROTO.CardanoTxAuxiliaryDataSupplementType[message.type];
-      if (auxiliaryDataType !== constants_1.PROTO.CardanoTxAuxiliaryDataSupplementType.NONE) {
+      const auxiliaryDataType = PROTO.CardanoTxAuxiliaryDataSupplementType[message.type];
+      if (auxiliaryDataType !== PROTO.CardanoTxAuxiliaryDataSupplementType.NONE) {
         auxiliaryDataSupplement = {
           type: auxiliaryDataType,
           auxiliaryDataHash: message.auxiliary_data_hash,
@@ -242,7 +243,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
       await typedCall('CardanoTxRequiredSigner', 'CardanoTxItemAck', requiredSigner);
     }
     if (this.params.collateralReturnWithData) {
-      await (0, cardanoOutputs_1.sendOutput)(typedCall, this.params.collateralReturnWithData);
+      await sendOutput(typedCall, this.params.collateralReturnWithData);
     }
     for (const referenceInput of this.params.referenceInputs) {
       await typedCall('CardanoTxReferenceInput', 'CardanoTxItemAck', referenceInput);
@@ -255,7 +256,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         path
       });
       witnesses.push({
-        type: constants_1.PROTO.CardanoTxWitnessType[message.type],
+        type: PROTO.CardanoTxWitnessType[message.type],
         pubKey: message.pub_key,
         signature: message.signature,
         chainCode: message.chain_code
@@ -284,9 +285,12 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
       witnesses
     } = result;
     if (hash !== unsignedTx.hash) {
-      throw constants_1.ERRORS.TypedError('Runtime', "Constructed transaction doesn't match the hash returned by the device.");
+      throw ERRORS.TypedError('Runtime', "Constructed transaction doesn't match the hash returned by the device.");
     }
-    const serializedTx = coin_selection_1.trezorUtils.signTransaction(unsignedTx.body, witnesses, {
+    const {
+      trezorUtils
+    } = await cardano();
+    const serializedTx = trezorUtils.signTransaction(unsignedTx.body, witnesses, {
       testnet
     });
     return {
@@ -294,6 +298,4 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
       serializedTx
     };
   }
-}
-exports.default = CardanoSignTransaction;
-//# sourceMappingURL=cardanoSignTransaction.js.map
+}

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

@@ -1,7 +1,6 @@
-export { default as cardanoGetAddress } from './cardanoGetAddress';
-export { default as cardanoGetNativeScriptHash } from './cardanoGetNativeScriptHash';
-export { default as cardanoGetPublicKey } from './cardanoGetPublicKey';
-export { default as cardanoSignTransaction } from './cardanoSignTransaction';
-export { default as cardanoComposeTransaction } from './cardanoComposeTransaction';
-export { default as cardanoSignMessage } from './cardanoSignMessage';
-//# sourceMappingURL=index.d.ts.map
+export { default as cardanoGetAddress } from "./cardanoGetAddress.js";
+export { default as cardanoGetNativeScriptHash } from "./cardanoGetNativeScriptHash.js";
+export { default as cardanoGetPublicKey } from "./cardanoGetPublicKey.js";
+export { default as cardanoSignTransaction } from "./cardanoSignTransaction.js";
+export { default as cardanoComposeTransaction } from "./cardanoComposeTransaction.js";
+export { default as cardanoSignMessage } from "./cardanoSignMessage.js";

package/lib/api/cardano/api/index.js

@@ -1,50 +1,6 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.cardanoSignMessage = exports.cardanoComposeTransaction = exports.cardanoSignTransaction = exports.cardanoGetPublicKey = exports.cardanoGetNativeScriptHash = exports.cardanoGetAddress = void 0;
-const tslib_1 = require("tslib");
-var cardanoGetAddress_1 = require("./cardanoGetAddress");
-Object.defineProperty(exports, "cardanoGetAddress", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(cardanoGetAddress_1).default;
-  }
-});
-var cardanoGetNativeScriptHash_1 = require("./cardanoGetNativeScriptHash");
-Object.defineProperty(exports, "cardanoGetNativeScriptHash", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(cardanoGetNativeScriptHash_1).default;
-  }
-});
-var cardanoGetPublicKey_1 = require("./cardanoGetPublicKey");
-Object.defineProperty(exports, "cardanoGetPublicKey", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(cardanoGetPublicKey_1).default;
-  }
-});
-var cardanoSignTransaction_1 = require("./cardanoSignTransaction");
-Object.defineProperty(exports, "cardanoSignTransaction", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(cardanoSignTransaction_1).default;
-  }
-});
-var cardanoComposeTransaction_1 = require("./cardanoComposeTransaction");
-Object.defineProperty(exports, "cardanoComposeTransaction", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(cardanoComposeTransaction_1).default;
-  }
-});
-var cardanoSignMessage_1 = require("./cardanoSignMessage");
-Object.defineProperty(exports, "cardanoSignMessage", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(cardanoSignMessage_1).default;
-  }
-});
-//# sourceMappingURL=index.js.map
+export { default as cardanoGetAddress } from "./cardanoGetAddress.js";
+export { default as cardanoGetNativeScriptHash } from "./cardanoGetNativeScriptHash.js";
+export { default as cardanoGetPublicKey } from "./cardanoGetPublicKey.js";
+export { default as cardanoSignTransaction } from "./cardanoSignTransaction.js";
+export { default as cardanoComposeTransaction } from "./cardanoComposeTransaction.js";
+export { default as cardanoSignMessage } from "./cardanoSignMessage.js";

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

@@ -1,7 +1,6 @@
-import { PROTO } from '../../constants';
-import { CardanoAddressParameters } from '../../types/api/cardano';
+import { CardanoAddressParameters } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
 export declare const validateAddressParameters: (addressParameters: CardanoAddressParameters) => void;
 export declare const modifyAddressParametersForBackwardsCompatibility: (address_parameters: PROTO.CardanoAddressParametersType) => PROTO.CardanoAddressParametersType;
 export declare const addressParametersToProto: (addressParameters: CardanoAddressParameters) => PROTO.CardanoAddressParametersType;
-export declare const addressParametersFromProto: (addressParameters: PROTO.CardanoAddressParametersType) => CardanoAddressParameters;
-//# sourceMappingURL=cardanoAddressParameters.d.ts.map
+export declare const addressParametersFromProto: (addressParameters: PROTO.CardanoAddressParametersType) => CardanoAddressParameters;