@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/cardano/api/cardanoGetNativeScriptHash.mjs

@@ -0,0 +1,66 @@
+import { CardanoGetNativeScriptHash as CardanoGetNativeScriptHashSchema } from "@trezor/connect-common/libESM/types/api/cardano/index.mjs";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { validatePath } from "../../../utils/pathUtils.mjs";
+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
+    } = 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 : PROTO.CardanoDerivationType.ICARUS_TREZOR
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Cardano'];
+    this.requiredFirmwareCoins = [getMiscNetwork('Cardano')];
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Get Cardano native script hash';
+  }
+  async run() {
+    const {
+      message
+    } = await this.getDevice().getCommands().typedCall('CardanoGetNativeScriptHash', 'CardanoNativeScriptHash', {
+      script: this.params.script,
+      display_format: this.params.display_format,
+      derivation_type: this.params.derivation_type
+    });
+    return {
+      scriptHash: message.script_hash
+    };
+  }
+}

package/libESM/api/cardano/api/cardanoGetPublicKey.d.mts

@@ -0,0 +1,20 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+interface Params {
+    proto: PROTO.CardanoGetPublicKey;
+    suppressBackupWarning?: boolean;
+}
+export default class CardanoGetPublicKey extends AbstractMethod<'cardanoGetPublicKey', Params[]> {
+    hasBundle?: boolean;
+    constructor(message: MethodMessage<'cardanoGetPublicKey'>);
+    get requiredPermissions(): MethodPermission[];
+    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 {};

package/libESM/api/cardano/api/cardanoGetPublicKey.mjs

@@ -0,0 +1,72 @@
+import { Bundle, CardanoGetPublicKey as CardanoGetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { fromHardened, getSerializedPath, validatePath } from "../../../utils/pathUtils.mjs";
+import { bundlify } from "../../common/paramsValidator.mjs";
+export default class CardanoGetPublicKey extends AbstractMethod {
+  hasBundle;
+  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 : PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false
+      };
+      return {
+        proto,
+        suppressBackupWarning: batch.suppressBackupWarning
+      };
+    });
+    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('Cardano')];
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Export Cardano public key';
+  }
+  get confirmation() {
+    return {
+      view: 'export-xpub',
+      label: this.params.length > 1 ? 'Export multiple Cardano public keys' : `Export Cardano public key for account #${fromHardened(this.params[0].proto.address_n[2]) + 1}`
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const batch = this.params[i].proto;
+      const {
+        message
+      } = await cmd.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', batch);
+      responses.push({
+        path: batch.address_n,
+        serializedPath: getSerializedPath(batch.address_n),
+        publicKey: message.xpub,
+        node: message.node
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response: message
+        }));
+      }
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/libESM/api/cardano/api/cardanoSignMessage.d.mts

@@ -0,0 +1,27 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import { type CardanoMessageHeaders, type CardanoSignedMessage } from '@trezor/connect-common/libESM/types/api/cardano';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import type { Path } from '../cardanoInputs';
+export type CardanoSignMessageParams = {
+    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;
+    constructor(message: MethodMessage<'cardanoSignMessage'>);
+    get requiredPermissions(): MethodPermission[];
+    run(): Promise<CardanoSignedMessage>;
+    _createHeaders(address: string): CardanoMessageHeaders;
+    _createCose(payload: string, signature: string, address: string, pubKey: string): {
+        coseSignature: string;
+        coseKey: string;
+    };
+    get info(): string;
+}

package/libESM/api/cardano/api/cardanoSignMessage.mjs

@@ -0,0 +1,96 @@
+import * as cbor from "cbor";
+import { CARDANO } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { CardanoSignMessage as CardanoSignMessageSchema } from "@trezor/connect-common/libESM/types/api/cardano/index.mjs";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { hasHexPrefix, isHexString } from "../../../utils/formatUtils.mjs";
+import { validatePath } from "../../../utils/pathUtils.mjs";
+import { addressParametersToProto } from "../cardanoAddressParameters.mjs";
+import { hexStringByteLength } from "../cardanoUtils.mjs";
+export default class CardanoSignMessage extends AbstractMethod {
+  static VERSION = 1;
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(CardanoSignMessageSchema, payload);
+    if (!isHexString(payload.payload) || hasHexPrefix(payload.payload)) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Message payload must be a hexadecimal string without a "0x" prefix.');
+    }
+    const params = {
+      path: validatePath(payload.path, 5),
+      payload: payload.payload,
+      preferHexDisplay: payload.preferHexDisplay ?? false,
+      networkId: payload.networkId,
+      protocolMagic: payload.protocolMagic,
+      addressParameters: payload.addressParameters && addressParametersToProto(payload.addressParameters),
+      derivationType: payload.derivationType ?? PROTO.CardanoDerivationType.ICARUS_TREZOR
+    };
+    super(message, params);
+    this.requiredFirmwareCoins = [getMiscNetwork('Cardano')];
+  }
+  get requiredPermissions() {
+    return ['read', 'write'];
+  }
+  async run() {
+    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,
+      network_id: this.params.networkId,
+      protocol_magic: this.params.protocolMagic,
+      address_parameters: this.params.addressParameters,
+      prefer_hex_display: this.params.preferHexDisplay,
+      derivation_type: this.params.derivationType
+    });
+    while (response.type !== 'CardanoMessageSignature') {
+      const {
+        length,
+        offset
+      } = response.message;
+      const data = this.params.payload.slice(offset * 2, (offset + length) * 2);
+      response = await typedCall('CardanoMessageDataResponse', ['CardanoMessageSignature', 'CardanoMessageDataRequest'], {
+        data
+      });
+    }
+    const {
+      signature,
+      address,
+      pub_key
+    } = response.message;
+    return {
+      signature,
+      payload: this.params.payload,
+      headers: this._createHeaders(address),
+      pubKey: pub_key,
+      ...this._createCose(this.params.payload, signature, address, pub_key)
+    };
+  }
+  _createHeaders(address) {
+    return {
+      protected: {
+        1: CARDANO.ALGORITHM_IDS.EdDSA,
+        address
+      },
+      unprotected: {
+        hashed: false,
+        version: CardanoSignMessage.VERSION
+      }
+    };
+  }
+  _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';
+  }
+}

package/libESM/api/cardano/api/cardanoSignTransaction.d.mts

@@ -0,0 +1,81 @@
+import { type CardanoSignedTxData, type MethodPermission } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import type { CertificateWithPoolOwnersAndRelays } from '../cardanoCertificate';
+import type { CollateralInputWithPath, InputWithPath, Path } from '../cardanoInputs';
+import type { OutputWithData } from '../cardanoOutputs';
+import type { AssetGroupWithTokens } from '../cardanoTokenBundle';
+declare const CardanoSignTransactionFeatures: Readonly<{
+    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;
+    payment_req?: PROTO.PaymentRequest;
+};
+export default class CardanoSignTransaction extends AbstractMethod<'cardanoSignTransaction', CardanoSignTransactionParams> {
+    constructor(message: MethodMessage<'cardanoSignTransaction'>);
+    get requiredPermissions(): MethodPermission[];
+    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 {};

package/libESM/api/cardano/api/cardanoSignTransaction.mjs

@@ -0,0 +1,298 @@
+import { trezorUtils } from "@fivebinaries/coin-selection";
+import { CardanoSignTransactionExtended, CardanoSignTransaction as CardanoSignTransactionSchema } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert, Type } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { validatePath } from "../../../utils/pathUtils.mjs";
+import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.mjs";
+import { modifyAuxiliaryDataForBackwardsCompatibility, transformAuxiliaryData } from "../cardanoAuxiliaryData.mjs";
+import { transformCertificate } from "../cardanoCertificate.mjs";
+import { transformCollateralInput, transformInput, transformReferenceInput } from "../cardanoInputs.mjs";
+import { sendOutput, transformOutput } from "../cardanoOutputs.mjs";
+import { tokenBundleToProto } from "../cardanoTokenBundle.mjs";
+import { gatherWitnessPaths } from "../cardanoWitnesses.mjs";
+const CardanoSignTransactionFeatures = Object.freeze({
+  Conway: ['0', '2.7.1']
+});
+export default class CardanoSignTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    if (payload.metadata) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Metadata field has been replaced by auxiliaryData.');
+    }
+    if (payload.auxiliaryData && payload.auxiliaryData.blob) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Auxiliary data can now only be sent as a hash.');
+    }
+    if (payload.auxiliaryData && payload.auxiliaryData.catalystRegistrationParameters) {
+      console.warn('Please use cVoteRegistrationParameters instead of catalystRegistrationParameters.');
+      payload.auxiliaryData.cVoteRegistrationParameters = payload.auxiliaryData.catalystRegistrationParameters;
+    }
+    if (payload.auxiliaryData && payload.auxiliaryData.governanceRegistrationParameters) {
+      console.warn('Please use cVoteRegistrationParameters instead of governanceRegistrationParameters.');
+      payload.auxiliaryData.cVoteRegistrationParameters = payload.auxiliaryData.governanceRegistrationParameters;
+    }
+    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(transformCertificate);
+    }
+    let withdrawals = [];
+    if (payload.withdrawals) {
+      withdrawals = payload.withdrawals.map(withdrawal => ({
+        path: withdrawal.path ? validatePath(withdrawal.path, 5) : undefined,
+        amount: withdrawal.amount,
+        script_hash: withdrawal.scriptHash,
+        key_hash: withdrawal.keyHash
+      }));
+    }
+    let mint = [];
+    if (payload.mint) {
+      mint = tokenBundleToProto(payload.mint);
+    }
+    let auxiliaryData;
+    if (payload.auxiliaryData) {
+      auxiliaryData = transformAuxiliaryData(payload.auxiliaryData);
+    }
+    let additionalWitnessRequests = [];
+    if (payload.additionalWitnessRequests) {
+      additionalWitnessRequests = payload.additionalWitnessRequests.map(witnessRequest => validatePath(witnessRequest, 3));
+    }
+    let collateralInputsWithPath = [];
+    if (payload.collateralInputs) {
+      collateralInputsWithPath = payload.collateralInputs.map(transformCollateralInput);
+    }
+    let requiredSigners = [];
+    if (payload.requiredSigners) {
+      requiredSigners = payload.requiredSigners.map(requiredSigner => ({
+        key_path: requiredSigner.keyPath ? validatePath(requiredSigner.keyPath, 3) : undefined,
+        key_hash: requiredSigner.keyHash
+      }));
+    }
+    const collateralReturnWithData = payload.collateralReturn ? transformOutput(payload.collateralReturn) : undefined;
+    let referenceInputs = [];
+    if (payload.referenceInputs) {
+      referenceInputs = payload.referenceInputs.map(transformReferenceInput);
+    }
+    const params = {
+      signingMode: payload.signingMode,
+      inputsWithPath,
+      outputsWithData,
+      fee: payload.fee,
+      ttl: payload.ttl,
+      certificatesWithPoolOwnersAndRelays,
+      withdrawals,
+      mint,
+      auxiliaryData,
+      validityIntervalStart: payload.validityIntervalStart,
+      scriptDataHash: payload.scriptDataHash,
+      collateralInputsWithPath,
+      requiredSigners,
+      collateralReturnWithData,
+      totalCollateral: payload.totalCollateral,
+      referenceInputs,
+      protocolMagic: payload.protocolMagic,
+      networkId: payload.networkId,
+      witnessPaths: gatherWitnessPaths(inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, payload.signingMode),
+      additionalWitnessRequests,
+      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,
+      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('Cardano')];
+  }
+  get requiredPermissions() {
+    return ['read', 'write'];
+  }
+  get info() {
+    return 'Sign Cardano transaction';
+  }
+  _isFeatureSupported(feature) {
+    return this.getDevice().atLeast(CardanoSignTransactionFeatures[feature]);
+  }
+  _ensureFeatureIsSupported(feature) {
+    if (!this._isFeatureSupported(feature)) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Feature ${feature} not supported by device firmware`);
+    }
+  }
+  _ensureFirmwareSupportsParams() {
+    const {
+      params
+    } = this;
+    params.certificatesWithPoolOwnersAndRelays.forEach(({
+      certificate
+    }) => {
+      if (certificate.type === PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY || certificate.type === PROTO.CardanoCertificateType.VOTE_DELEGATION) {
+        this._ensureFeatureIsSupported('Conway');
+      }
+    });
+    if (params.tagCborSets) {
+      this._ensureFeatureIsSupported('Conway');
+    }
+  }
+  async _sign_tx() {
+    const {
+      typedCall
+    } = this.getDevice().getCommands();
+    const hasAuxiliaryData = !!this.params.auxiliaryData;
+    const signTxInitMessage = {
+      signing_mode: this.params.signingMode,
+      protocol_magic: this.params.protocolMagic,
+      network_id: this.params.networkId,
+      inputs_count: this.params.inputsWithPath.length,
+      outputs_count: this.params.outputsWithData.length,
+      fee: this.params.fee,
+      ttl: this.params.ttl,
+      certificates_count: this.params.certificatesWithPoolOwnersAndRelays.length,
+      withdrawals_count: this.params.withdrawals.length,
+      has_auxiliary_data: hasAuxiliaryData,
+      validity_interval_start: this.params.validityIntervalStart,
+      witness_requests_count: this.params.witnessPaths.length,
+      minting_asset_groups_count: this.params.mint.length,
+      script_data_hash: this.params.scriptDataHash,
+      collateral_inputs_count: this.params.collateralInputsWithPath.length,
+      required_signers_count: this.params.requiredSigners.length,
+      has_collateral_return: this.params.collateralReturnWithData != null,
+      total_collateral: this.params.totalCollateral,
+      reference_inputs_count: this.params.referenceInputs.length,
+      derivation_type: this.params.derivationType,
+      include_network_id: this.params.includeNetworkId,
+      chunkify: this.params.chunkify,
+      tag_cbor_sets: this.params.tagCborSets,
+      payment_req: this.params.payment_req
+    };
+    await typedCall('CardanoSignTxInit', 'CardanoTxItemAck', signTxInitMessage);
+    for (const {
+      input
+    } of this.params.inputsWithPath) {
+      await typedCall('CardanoTxInput', 'CardanoTxItemAck', input);
+    }
+    for (const outputWithData of this.params.outputsWithData) {
+      await sendOutput(typedCall, outputWithData);
+    }
+    for (const {
+      certificate,
+      poolOwners,
+      poolRelays
+    } of this.params.certificatesWithPoolOwnersAndRelays) {
+      await typedCall('CardanoTxCertificate', 'CardanoTxItemAck', certificate);
+      for (const poolOwner of poolOwners) {
+        await typedCall('CardanoPoolOwner', 'CardanoTxItemAck', poolOwner);
+      }
+      for (const poolRelay of poolRelays) {
+        await typedCall('CardanoPoolRelayParameters', 'CardanoTxItemAck', poolRelay);
+      }
+    }
+    for (const withdrawal of this.params.withdrawals) {
+      await typedCall('CardanoTxWithdrawal', 'CardanoTxItemAck', withdrawal);
+    }
+    let auxiliaryDataSupplement;
+    if (this.params.auxiliaryData) {
+      const {
+        cvote_registration_parameters
+      } = this.params.auxiliaryData;
+      if (cvote_registration_parameters) {
+        this.params.auxiliaryData = modifyAuxiliaryDataForBackwardsCompatibility(this.params.auxiliaryData);
+      }
+      const {
+        message
+      } = await typedCall('CardanoTxAuxiliaryData', 'CardanoTxAuxiliaryDataSupplement', this.params.auxiliaryData);
+      const auxiliaryDataType = PROTO.CardanoTxAuxiliaryDataSupplementType[message.type];
+      if (auxiliaryDataType !== PROTO.CardanoTxAuxiliaryDataSupplementType.NONE) {
+        auxiliaryDataSupplement = {
+          type: auxiliaryDataType,
+          auxiliaryDataHash: message.auxiliary_data_hash,
+          cVoteRegistrationSignature: message.cvote_registration_signature,
+          catalystSignature: message.cvote_registration_signature,
+          governanceSignature: message.cvote_registration_signature
+        };
+      }
+      await typedCall('CardanoTxHostAck', 'CardanoTxItemAck');
+    }
+    if (this.params.mint.length > 0) {
+      await typedCall('CardanoTxMint', 'CardanoTxItemAck', {
+        asset_groups_count: this.params.mint.length
+      });
+      for (const assetGroup of this.params.mint) {
+        await typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+          policy_id: assetGroup.policyId,
+          tokens_count: assetGroup.tokens.length
+        });
+        for (const token of assetGroup.tokens) {
+          await typedCall('CardanoToken', 'CardanoTxItemAck', token);
+        }
+      }
+    }
+    for (const {
+      collateralInput
+    } of this.params.collateralInputsWithPath) {
+      await typedCall('CardanoTxCollateralInput', 'CardanoTxItemAck', collateralInput);
+    }
+    for (const requiredSigner of this.params.requiredSigners) {
+      await typedCall('CardanoTxRequiredSigner', 'CardanoTxItemAck', requiredSigner);
+    }
+    if (this.params.collateralReturnWithData) {
+      await sendOutput(typedCall, this.params.collateralReturnWithData);
+    }
+    for (const referenceInput of this.params.referenceInputs) {
+      await typedCall('CardanoTxReferenceInput', 'CardanoTxItemAck', referenceInput);
+    }
+    const witnesses = [];
+    for (const path of this.params.witnessPaths) {
+      const {
+        message
+      } = await typedCall('CardanoTxWitnessRequest', 'CardanoTxWitnessResponse', {
+        path
+      });
+      witnesses.push({
+        type: PROTO.CardanoTxWitnessType[message.type],
+        pubKey: message.pub_key,
+        signature: message.signature,
+        chainCode: message.chain_code
+      });
+    }
+    const {
+      message: txBodyHashMessage
+    } = await typedCall('CardanoTxHostAck', 'CardanoTxBodyHash');
+    await typedCall('CardanoTxHostAck', 'CardanoSignTxFinished');
+    return {
+      hash: txBodyHashMessage.tx_hash,
+      witnesses,
+      auxiliaryDataSupplement
+    };
+  }
+  async run() {
+    this._ensureFirmwareSupportsParams();
+    const result = await this._sign_tx();
+    if (!this.params.unsignedTx) return result;
+    const {
+      unsignedTx,
+      testnet
+    } = this.params;
+    const {
+      hash,
+      witnesses
+    } = result;
+    if (hash !== unsignedTx.hash) {
+      throw ERRORS.TypedError('Runtime', "Constructed transaction doesn't match the hash returned by the device.");
+    }
+    const serializedTx = trezorUtils.signTransaction(unsignedTx.body, witnesses, {
+      testnet
+    });
+    return {
+      ...result,
+      serializedTx
+    };
+  }
+}

package/libESM/api/cardano/api/index.d.mts

@@ -0,0 +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';

package/libESM/api/cardano/api/index.mjs

@@ -0,0 +1,6 @@
+export { default as cardanoGetAddress } from "./cardanoGetAddress.mjs";
+export { default as cardanoGetNativeScriptHash } from "./cardanoGetNativeScriptHash.mjs";
+export { default as cardanoGetPublicKey } from "./cardanoGetPublicKey.mjs";
+export { default as cardanoSignTransaction } from "./cardanoSignTransaction.mjs";
+export { default as cardanoComposeTransaction } from "./cardanoComposeTransaction.mjs";
+export { default as cardanoSignMessage } from "./cardanoSignMessage.mjs";