@trezor/connect 9.0.0-beta.3 → 9.0.0-beta.6

package/README.md

@@ -1,4 +1,4 @@
-# @trezor/connect API version 9.0.0-beta.3
+# @trezor/connect API version 9.0.0-beta.6
 
 [![Build Status](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml/badge.svg)](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml)
 [![NPM](https://img.shields.io/npm/v/@trezor/connect.svg)](https://www.npmjs.org/package/@trezor/connect)
@@ -44,6 +44,16 @@ With regards to this repo - All updates should go to current version branch, the
 
 For deployment process of trezor-connect v8 refer to [trezor/connect repository](https://github.com/trezor/connect/blob/develop/docs/deployment/index.md)
 
+## Docs
+
+Interactive API explorer is available on https://connect.trezor.io/9/#/
+
+Documentation is available [docs/packages/connect](../../docs/packages/connect/index.md)
+
+## Examples
+
+A collection of examples on how to implement @trezor/connect in various environments is available in [packages/connect-examples](../connect-examples/README.md)
+
 ## Tests
 
 For integration testing against trezord and emulator refer to [this document](https://github.com/trezor/trezor-suite/blob/develop/packages/integration-tests/projects/connect/README.md).

package/lib/api/binance/binanceSignTx.d.ts

@@ -1,5 +1,5 @@
 import { PROTO } from '../../constants';
-import type { BinanceSDKTransaction, BinancePreparedTransaction } from '../../types/api/binanceSignTransaction';
+import type { BinanceSDKTransaction, BinancePreparedTransaction } from '../../types/api/binance';
 import type { TypedCall } from '../../device/DeviceCommands';
 export declare const validate: (tx: BinanceSDKTransaction) => BinancePreparedTransaction;
 export declare const signTx: (typedCall: TypedCall, address_n: number[], tx: BinancePreparedTransaction) => Promise<PROTO.BinanceSignedTx>;

package/lib/api/binanceSignTransaction.d.ts

@@ -1,5 +1,5 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { BinancePreparedTransaction } from '../types/api/binanceSignTransaction';
+import type { BinancePreparedTransaction } from '../types/api/binance';
 declare type Params = {
     path: number[];
     transaction: BinancePreparedTransaction;

package/lib/api/bitcoin/enhanceSignTx.d.ts

@@ -1,4 +1,4 @@
 import type { BitcoinNetworkInfo } from '../../types';
-import type { TransactionOptions } from '../../types/api/signTransaction';
+import type { TransactionOptions } from '../../types/api/bitcoin';
 export declare const enhanceSignTx: (options: TransactionOptions, coinInfo: BitcoinNetworkInfo) => TransactionOptions;
 //# sourceMappingURL=enhanceSignTx.d.ts.map

package/lib/api/bitcoin/refTx.d.ts

@@ -1,6 +1,6 @@
 import type { TypedRawTransaction } from '@trezor/blockchain-link';
 import type { CoinInfo, AccountAddresses } from '../../types';
-import type { RefTransaction, TransactionOptions } from '../../types/api/signTransaction';
+import type { RefTransaction, TransactionOptions } from '../../types/api/bitcoin';
 import type { PROTO } from '../../constants';
 export declare const requireReferencedTransactions: (inputs: PROTO.TxInputType[], options?: TransactionOptions, coinInfo?: CoinInfo | undefined) => boolean;
 export declare const getReferencedTransactions: (inputs: PROTO.TxInputType[]) => string[];

package/lib/api/bitcoin/signtx.d.ts

@@ -1,7 +1,7 @@
 import { PROTO } from '../../constants';
 import type { BitcoinNetworkInfo } from '../../types';
 import type { TypedCall } from '../../device/DeviceCommands';
-import type { RefTransaction, TransactionOptions, SignedTransaction } from '../../types/api/signTransaction';
+import type { RefTransaction, TransactionOptions, SignedTransaction } from '../../types/api/bitcoin';
 export interface SignTxHelperProps {
     typedCall: TypedCall;
     txRequest: PROTO.TxRequest;

package/lib/api/bitcoin/signtxLegacy.d.ts

@@ -1,4 +1,4 @@
-import type { SignedTransaction } from '../../types/api/signTransaction';
+import type { SignedTransaction } from '../../types/api/bitcoin';
 import type { SignTxHelperParams } from './signtx';
 export declare const signTxLegacy: ({ typedCall, inputs, outputs, refTxs, options, coinInfo, }: SignTxHelperParams) => Promise<SignedTransaction>;
 //# sourceMappingURL=signtxLegacy.d.ts.map

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

@@ -1,6 +1,6 @@
 import { PROTO } from '../../constants';
 import type { Device } from '../../device/Device';
-import type { CardanoAddressParameters } from '../../types/api/cardanoGetAddress';
+import type { CardanoAddressParameters } from '../../types/api/cardano';
 export declare const validateAddressParameters: (addressParameters: CardanoAddressParameters) => void;
 export declare const modifyAddressParametersForBackwardsCompatibility: (device: Device, address_parameters: PROTO.CardanoAddressParametersType) => PROTO.CardanoAddressParametersType;
 export declare const addressParametersToProto: (addressParameters: CardanoAddressParameters) => PROTO.CardanoAddressParametersType;

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

@@ -1,6 +1,6 @@
 import type { Device } from '../../device/Device';
 import type { PROTO } from '../../constants';
-import type { CardanoAuxiliaryData } from '../../types/api/cardanoSignTransaction';
+import type { CardanoAuxiliaryData } from '../../types/api/cardano';
 export declare const transformAuxiliaryData: (auxiliaryData: CardanoAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;
 export declare const modifyAuxiliaryDataForBackwardsCompatibility: (device: Device, auxiliary_data: PROTO.CardanoTxAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;
 //# sourceMappingURL=cardanoAuxiliaryData.d.ts.map

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

@@ -1,5 +1,5 @@
 import { PROTO } from '../../constants';
-import type { CardanoCertificate } from '../../types/api/cardanoSignTransaction';
+import type { CardanoCertificate } from '../../types/api/cardano';
 export declare type CertificateWithPoolOwnersAndRelays = {
     certificate: PROTO.CardanoTxCertificate;
     poolOwners: PROTO.CardanoPoolOwner[];

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

@@ -10,4 +10,5 @@ export declare type CollateralInputWithPath = {
 };
 export declare const transformInput: (input: any) => InputWithPath;
 export declare const transformCollateralInput: (collateralInput: any) => CollateralInputWithPath;
+export declare const transformReferenceInput: (referenceInput: any) => PROTO.CardanoTxReferenceInput;
 //# sourceMappingURL=cardanoInputs.d.ts.map

package/lib/api/cardano/cardanoInputs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCollateralInput = exports.transformInput = void 0;
+exports.transformReferenceInput = exports.transformCollateralInput = exports.transformInput = void 0;
 const paramsValidator_1 = require("../common/paramsValidator");
 const pathUtils_1 = require("../../utils/pathUtils");
 const transformInput = (input) => {
@@ -31,4 +31,15 @@ const transformCollateralInput = (collateralInput) => {
     };
 };
 exports.transformCollateralInput = transformCollateralInput;
+const transformReferenceInput = (referenceInput) => {
+    (0, paramsValidator_1.validateParams)(referenceInput, [
+        { name: 'prev_hash', type: 'string', required: true },
+        { name: 'prev_index', type: 'number', required: true },
+    ]);
+    return {
+        prev_hash: referenceInput.prev_hash,
+        prev_index: referenceInput.prev_index,
+    };
+};
+exports.transformReferenceInput = transformReferenceInput;
 //# sourceMappingURL=cardanoInputs.js.map

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

@@ -1,8 +1,11 @@
 import type { AssetGroupWithTokens } from './cardanoTokenBundle';
-import type { PROTO } from '../../constants';
-export declare type OutputWithTokens = {
+import { PROTO } from '../../constants';
+export declare type OutputWithData = {
     output: PROTO.CardanoTxOutput;
     tokenBundle?: AssetGroupWithTokens[];
+    inlineDatum?: string;
+    referenceScript?: string;
 };
-export declare const transformOutput: (output: any) => OutputWithTokens;
+export declare const transformOutput: (output: any) => OutputWithData;
+export declare const sendOutput: (typedCall: any, outputWithData: OutputWithData) => Promise<void>;
 //# sourceMappingURL=cardanoOutputs.d.ts.map

package/lib/api/cardano/cardanoOutputs.js

@@ -1,22 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformOutput = void 0;
+exports.sendOutput = exports.transformOutput = void 0;
 const paramsValidator_1 = require("../common/paramsValidator");
 const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
 const cardanoTokenBundle_1 = require("./cardanoTokenBundle");
+const cardanoUtils_1 = require("./cardanoUtils");
 const transformOutput = (output) => {
     (0, paramsValidator_1.validateParams)(output, [
         { name: 'address', type: 'string' },
         { name: 'amount', type: 'uint', required: true },
         { name: 'tokenBundle', type: 'array', allowEmpty: true },
         { name: 'datumHash', type: 'string' },
+        { name: 'format', type: 'number' },
+        { name: 'inlineDatum', type: 'string' },
+        { name: 'referenceScript', type: 'string' },
     ]);
     const result = {
         output: {
             amount: output.amount,
             asset_groups_count: 0,
             datum_hash: output.datumHash,
+            format: output.format,
+            inline_datum_size: output.inlineDatum
+                ? (0, cardanoUtils_1.hexStringByteLength)(output.inlineDatum)
+                : undefined,
+            reference_script_size: output.referenceScript
+                ? (0, cardanoUtils_1.hexStringByteLength)(output.referenceScript)
+                : undefined,
         },
+        inlineDatum: output.inlineDatum,
+        referenceScript: output.referenceScript,
     };
     if (output.addressParameters) {
         (0, cardanoAddressParameters_1.validateAddressParameters)(output.addressParameters);
@@ -35,4 +48,27 @@ const transformOutput = (output) => {
     return result;
 };
 exports.transformOutput = transformOutput;
+const sendOutput = async (typedCall, outputWithData) => {
+    const MAX_CHUNK_SIZE = 1024 * 2;
+    const { output, tokenBundle, inlineDatum, referenceScript } = outputWithData;
+    await typedCall('CardanoTxOutput', 'CardanoTxItemAck', output);
+    if (tokenBundle) {
+        for (const assetGroup of tokenBundle) {
+            await typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+                policy_id: assetGroup.policyId,
+                tokens_count: assetGroup.tokens.length,
+            });
+            for (const token of assetGroup.tokens) {
+                await typedCall('CardanoToken', 'CardanoTxItemAck', token);
+            }
+        }
+    }
+    if (inlineDatum) {
+        await (0, cardanoUtils_1.sendChunkedHexString)(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
+    }
+    if (referenceScript) {
+        await (0, cardanoUtils_1.sendChunkedHexString)(typedCall, referenceScript, MAX_CHUNK_SIZE, 'CardanoTxReferenceScriptChunk');
+    }
+};
+exports.sendOutput = sendOutput;
 //# sourceMappingURL=cardanoOutputs.js.map

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

@@ -1,5 +1,5 @@
 import type { PROTO } from '../../constants';
-import type { CardanoAssetGroup } from '../../types/api/cardanoSignTransaction';
+import type { CardanoAssetGroup } from '../../types/api/cardano';
 export declare type AssetGroupWithTokens = {
     policyId: string;
     tokens: PROTO.CardanoToken[];

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

@@ -0,0 +1,3 @@
+export declare const hexStringByteLength: (s: string) => number;
+export declare const sendChunkedHexString: (typedCall: any, data: string, chunkSize: number, messageType: string) => Promise<void>;
+//# sourceMappingURL=cardanoUtils.d.ts.map

package/lib/api/cardano/cardanoUtils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendChunkedHexString = exports.hexStringByteLength = void 0;
+const hexStringByteLength = (s) => s.length / 2;
+exports.hexStringByteLength = hexStringByteLength;
+const sendChunkedHexString = async (typedCall, data, chunkSize, messageType) => {
+    let processedSize = 0;
+    while (processedSize < data.length) {
+        const chunk = data.slice(processedSize, processedSize + chunkSize);
+        await typedCall(messageType, 'CardanoTxItemAck', {
+            data: chunk,
+        });
+        processedSize += chunkSize;
+    }
+};
+exports.sendChunkedHexString = sendChunkedHexString;
+//# sourceMappingURL=cardanoUtils.js.map

package/lib/api/cardano/cardanoWitnesses.js

@@ -34,11 +34,11 @@ const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays,
             if (path)
                 _insert(path);
         });
-        requiredSigners.forEach(({ key_path }) => {
-            if (key_path)
-                _insert(key_path);
-        });
     }
+    requiredSigners.forEach(({ key_path }) => {
+        if (key_path)
+            _insert(key_path);
+    });
     additionalWitnessRequests.forEach(path => {
         _insert(path);
     });

package/lib/api/cardanoGetAddress.d.ts

@@ -17,7 +17,7 @@ export default class CardanoGetAddress extends AbstractMethod<'cardanoGetAddress
     noBackupConfirmation(): Promise<boolean>;
     _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, }: Params): Promise<PROTO.CardanoAddress>;
     _ensureFirmwareSupportsBatch(batch: Params): void;
-    run(): Promise<import("../types/api/cardanoGetAddress").CardanoAddress | import("../types/api/cardanoGetAddress").CardanoAddress[]>;
+    run(): Promise<import("..").CardanoAddress | import("..").CardanoAddress[]>;
 }
 export {};
 //# sourceMappingURL=cardanoGetAddress.d.ts.map

package/lib/api/cardanoGetNativeScriptHash.d.ts

@@ -1,6 +1,6 @@
 import { PROTO } from '../constants';
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { CardanoNativeScript } from '../types/api/cardanoGetNativeScriptHash';
+import type { CardanoNativeScript } from '../types/api/cardano';
 export default class CardanoGetNativeScriptHash extends AbstractMethod<'cardanoGetNativeScriptHash', PROTO.CardanoGetNativeScriptHash> {
     init(): void;
     validateScript(script: CardanoNativeScript): void;

package/lib/api/cardanoGetPublicKey.d.ts

@@ -5,6 +5,6 @@ export default class CardanoGetPublicKey extends AbstractMethod<'cardanoGetPubli
     confirmed?: boolean;
     init(): void;
     confirmation(): Promise<boolean>;
-    run(): Promise<import("../types/api/cardanoGetPublicKey").CardanoPublicKey | import("../types/api/cardanoGetPublicKey").CardanoPublicKey[]>;
+    run(): Promise<import("..").CardanoPublicKey | import("..").CardanoPublicKey[]>;
 }
 //# sourceMappingURL=cardanoGetPublicKey.d.ts.map

package/lib/api/cardanoSignTransaction.d.ts

@@ -1,9 +1,9 @@
 import { AbstractMethod } from '../core/AbstractMethod';
 import type { CertificateWithPoolOwnersAndRelays } from './cardano/cardanoCertificate';
-import type { Path, InputWithPath, CollateralInputWithPath } from './cardano/cardanoInputs';
-import type { OutputWithTokens } from './cardano/cardanoOutputs';
+import { Path, InputWithPath, CollateralInputWithPath } from './cardano/cardanoInputs';
+import type { OutputWithData } from './cardano/cardanoOutputs';
 import { PROTO } from '../constants';
-import type { CardanoSignedTxData } from '../types/api/cardanoSignTransaction';
+import type { CardanoSignedTxData } from '../types/api/cardano';
 import type { AssetGroupWithTokens } from './cardano/cardanoTokenBundle';
 declare const CardanoSignTransactionFeatures: Readonly<{
     TransactionStreaming: string[];
@@ -14,11 +14,12 @@ declare const CardanoSignTransactionFeatures: Readonly<{
     ScriptDataHash: string[];
     Plutus: string[];
     KeyHashStakeCredential: string[];
+    Babbage: string[];
 }>;
 export declare type CardanoSignTransactionParams = {
     signingMode: PROTO.CardanoTxSigningMode;
     inputsWithPath: InputWithPath[];
-    outputsWithTokens: OutputWithTokens[];
+    outputsWithData: OutputWithData[];
     fee: PROTO.UintType;
     ttl?: PROTO.UintType;
     certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[];
@@ -29,6 +30,9 @@ export declare type CardanoSignTransactionParams = {
     scriptDataHash?: string;
     collateralInputsWithPath: CollateralInputWithPath[];
     requiredSigners: PROTO.CardanoTxRequiredSigner[];
+    collateralReturnWithData?: OutputWithData;
+    totalCollateral?: PROTO.UintType;
+    referenceInputs: PROTO.CardanoTxReferenceInput[];
     protocolMagic: number;
     networkId: number;
     witnessPaths: Path[];

package/lib/api/cardanoSignTransaction.js

@@ -20,6 +20,7 @@ const CardanoSignTransactionFeatures = Object.freeze({
     ScriptDataHash: ['0', '2.4.4'],
     Plutus: ['0', '2.4.4'],
     KeyHashStakeCredential: ['0', '2.4.4'],
+    Babbage: ['0', '2.5.2'],
 });
 class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
@@ -46,6 +47,8 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             { name: 'scriptDataHash', type: 'string' },
             { name: 'collateralInputs', type: 'array', allowEmpty: true },
             { name: 'requiredSigners', type: 'array', allowEmpty: true },
+            { name: 'totalCollateral', type: 'uint' },
+            { name: 'referenceInputs', type: 'array', allowEmpty: true },
             { name: 'protocolMagic', type: 'number', required: true },
             { name: 'networkId', type: 'number', required: true },
             { name: 'additionalWitnessRequests', type: 'array', allowEmpty: true },
@@ -53,7 +56,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             { name: 'includeNetworkId', type: 'boolean' },
         ]);
         const inputsWithPath = payload.inputs.map(cardanoInputs_1.transformInput);
-        const outputsWithTokens = payload.outputs.map(cardanoOutputs_1.transformOutput);
+        const outputsWithData = payload.outputs.map(cardanoOutputs_1.transformOutput);
         let certificatesWithPoolOwnersAndRelays = [];
         if (payload.certificates) {
             certificatesWithPoolOwnersAndRelays = payload.certificates.map(cardanoCertificate_1.transformCertificate);
@@ -102,10 +105,17 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
                 };
             });
         }
+        const collateralReturnWithData = payload.collateralReturn
+            ? (0, cardanoOutputs_1.transformOutput)(payload.collateralReturn)
+            : undefined;
+        let referenceInputs = [];
+        if (payload.referenceInputs) {
+            referenceInputs = payload.referenceInputs.map(cardanoInputs_1.transformReferenceInput);
+        }
         this.params = {
             signingMode: payload.signingMode,
             inputsWithPath,
-            outputsWithTokens,
+            outputsWithData,
             fee: payload.fee,
             ttl: payload.ttl,
             certificatesWithPoolOwnersAndRelays,
@@ -116,6 +126,9 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             scriptDataHash: payload.scriptDataHash,
             collateralInputsWithPath,
             requiredSigners,
+            collateralReturnWithData,
+            totalCollateral: payload.totalCollateral,
+            referenceInputs,
             protocolMagic: payload.protocolMagic,
             networkId: payload.networkId,
             witnessPaths: (0, cardanoWitnesses_1.gatherWitnessPaths)(inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, payload.signingMode),
@@ -142,7 +155,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
                 this._ensureFeatureIsSupported('KeyHashStakeCredential');
             }
         });
-        params.outputsWithTokens.forEach(({ output }) => {
+        params.outputsWithData.forEach(({ output }) => {
             if (output.datum_hash) {
                 this._ensureFeatureIsSupported('OutputDatumHash');
             }
@@ -168,6 +181,18 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         if (params.signingMode === constants_1.PROTO.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
             this._ensureFeatureIsSupported('Plutus');
         }
+        params.outputsWithData.forEach(({ output, inlineDatum, referenceScript }) => {
+            if (output.format === constants_1.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE ||
+                inlineDatum ||
+                referenceScript) {
+                this._ensureFeatureIsSupported('Babbage');
+            }
+        });
+        if (params.collateralReturnWithData ||
+            params.totalCollateral != null ||
+            params.referenceInputs.length > 0) {
+            this._ensureFeatureIsSupported('Babbage');
+        }
     }
     async _sign_tx() {
         const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
@@ -177,7 +202,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             protocol_magic: this.params.protocolMagic,
             network_id: this.params.networkId,
             inputs_count: this.params.inputsWithPath.length,
-            outputs_count: this.params.outputsWithTokens.length,
+            outputs_count: this.params.outputsWithData.length,
             fee: this.params.fee,
             ttl: this.params.ttl,
             certificates_count: this.params.certificatesWithPoolOwnersAndRelays.length,
@@ -189,6 +214,9 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             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,
         };
@@ -196,19 +224,8 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         for (const { input } of this.params.inputsWithPath) {
             await typedCall('CardanoTxInput', 'CardanoTxItemAck', input);
         }
-        for (const { output, tokenBundle } of this.params.outputsWithTokens) {
-            await typedCall('CardanoTxOutput', 'CardanoTxItemAck', output);
-            if (tokenBundle) {
-                for (const assetGroup of tokenBundle) {
-                    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 outputWithData of this.params.outputsWithData) {
+            await (0, cardanoOutputs_1.sendOutput)(typedCall, outputWithData);
         }
         for (const { certificate, poolOwners, poolRelays } of this.params
             .certificatesWithPoolOwnersAndRelays) {
@@ -260,6 +277,12 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         for (const requiredSigner of this.params.requiredSigners) {
             await typedCall('CardanoTxRequiredSigner', 'CardanoTxItemAck', requiredSigner);
         }
+        if (this.params.collateralReturnWithData) {
+            await (0, cardanoOutputs_1.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 });

package/lib/api/composeTransaction.d.ts

@@ -26,7 +26,7 @@ export default class ComposeTransaction extends AbstractMethod<'composeTransacti
     }>;
     selectFee(account: DiscoveryAccount, utxo: AccountUtxo[]): Promise<SignedTransaction | "change-account">;
     _selectFeeUiResponse(composer: TransactionComposer): Promise<SignedTransaction | 'change-account'>;
-    _sign(tx: ComposeResult): Promise<import("../types/api/signTransaction").SignedTransaction>;
+    _sign(tx: ComposeResult): Promise<import("../types").SignedTransaction>;
     dispose(): void;
 }
 export {};

package/lib/api/eos/eosSignTx.d.ts

@@ -1,5 +1,5 @@
 import { PROTO } from '../../constants';
-import type { EosSDKTransaction } from '../../types/api/eosSignTransaction';
+import type { EosSDKTransaction } from '../../types/api/eos';
 import type { TypedCall } from '../../device/DeviceCommands';
 export declare const validate: (tx: EosSDKTransaction) => {
     chain_id: string;

package/lib/api/eosGetPublicKey.d.ts

@@ -5,6 +5,6 @@ export default class EosGetPublicKey extends AbstractMethod<'eosGetPublicKey', P
     confirmed?: boolean;
     init(): void;
     confirmation(): Promise<boolean>;
-    run(): Promise<import("../types/api/eosGetPublicKey").EosPublicKey | import("../types/api/eosGetPublicKey").EosPublicKey[]>;
+    run(): Promise<import("..").EosPublicKey | import("..").EosPublicKey[]>;
 }
 //# sourceMappingURL=eosGetPublicKey.d.ts.map

package/lib/api/ethereum/ethereumSignTx.d.ts

@@ -1,5 +1,5 @@
 import type { TypedCall } from '../../device/DeviceCommands';
-import type { EthereumAccessList } from '../../types/api/ethereumSignTransaction';
+import type { EthereumAccessList } from '../../types/api/ethereum';
 export declare const ethereumSignTx: (typedCall: TypedCall, address_n: number[], to: string, value: string, gas_limit: string, gas_price: string, nonce: string, chain_id: number, data?: string | undefined, tx_type?: number | undefined) => Promise<{
     v: string;
     r: string;

package/lib/api/ethereum/ethereumSignTypedData.d.ts

@@ -1,5 +1,5 @@
 import { PROTO } from '../../constants';
-import type { EthereumSignTypedDataTypes } from '../../types/api/ethereumSignTypedData';
+import type { EthereumSignTypedDataTypes } from '../../types/api/ethereum';
 export declare function parseArrayType(arrayTypeName: string): {
     entryTypeName: string;
     arraySize: number | null;

package/lib/api/ethereumSignTransaction.d.ts

@@ -1,5 +1,5 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { EthereumTransaction, EthereumTransactionEIP1559 } from '../types/api/ethereumSignTransaction';
+import type { EthereumTransaction, EthereumTransactionEIP1559 } from '../types/api/ethereum';
 declare type Params = {
     path: number[];
     tx: ({

package/lib/api/ethereumSignTypedData.d.ts

@@ -1,5 +1,5 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { EthereumSignTypedDataTypes, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from '../types/api/ethereumSignTypedData';
+import type { EthereumSignTypedDataTypes, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from '../types/api/ethereum';
 declare type Params = (Omit<EthereumSignTypedDataParams<EthereumSignTypedDataTypes>, 'path'> | Omit<EthereumSignTypedHashParams<EthereumSignTypedDataTypes>, 'path'>) & {
     address_n: number[];
 };

package/lib/api/firmware/calculateFirmwareHash.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare const calculateFirmwareHash: (major_version: number, fw: ArrayBuffer, key?: Buffer | undefined) => {
+    hash: string;
+    challenge: string;
+};
+//# sourceMappingURL=calculateFirmwareHash.d.ts.map

package/lib/api/firmware/calculateFirmwareHash.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFirmwareHash = void 0;
+const blakejs_1 = require("blakejs");
+const SIZE_T1 = (7 * 128 + 64) * 1024;
+const SIZE_TT = 13 * 128 * 1024;
+const calculateFirmwareHash = (major_version, fw, key) => {
+    const size = major_version === 1 ? SIZE_T1 : SIZE_TT;
+    const padding = size - fw.byteLength;
+    if (padding < 0) {
+        throw new Error('Firmware too big');
+    }
+    const data = new Uint8Array(new ArrayBuffer(size));
+    data.set(new Uint8Array(fw));
+    if (padding > 0) {
+        const zeroBytes = Buffer.alloc(padding);
+        zeroBytes.fill(Buffer.from('ff', 'hex'));
+        data.set(zeroBytes, fw.byteLength);
+    }
+    return {
+        hash: key && key.length > 0 ? (0, blakejs_1.blake2sHex)(data, key) : (0, blakejs_1.blake2sHex)(data),
+        challenge: key ? key.toString('hex') : '',
+    };
+};
+exports.calculateFirmwareHash = calculateFirmwareHash;
+//# sourceMappingURL=calculateFirmwareHash.js.map

package/lib/api/firmware/getBinary.d.ts

@@ -6,9 +6,9 @@ interface GetBinaryProps extends GetInfoProps {
     intermediary?: boolean;
 }
 export declare const getBinary: ({ features, releases, baseUrl, version, btcOnly, intermediary, }: GetBinaryProps) => Promise<{
-    binary: ArrayBuffer;
+    binary: any;
 } | {
-    binary: ArrayBuffer;
+    binary: any;
     changelog: import("../..").FirmwareRelease[] | null;
     release: import("../..").FirmwareRelease;
     isLatest: boolean;

package/lib/api/firmware/getBinary.js

@@ -5,14 +5,13 @@ const utils_1 = require("@trezor/utils");
 const assets_1 = require("../../utils/assets");
 const firmwareUtils_1 = require("../../utils/firmwareUtils");
 const firmwareInfo_1 = require("../../data/firmwareInfo");
-const modifyFirmware_1 = require("./modifyFirmware");
 const getBinary = async ({ features, releases, baseUrl, version, btcOnly, intermediary = false, }) => {
     if (!(0, firmwareUtils_1.isStrictFeatures)(features)) {
         throw new Error('Features of unexpected shape provided');
     }
     if (intermediary && features.major_version !== 2) {
         const fw = await (0, assets_1.httpRequest)(`${baseUrl}/firmware/1/trezor-inter-1.10.0.bin`, 'binary');
-        return { binary: (0, modifyFirmware_1.modifyFirmware)({ fw, features }) };
+        return { binary: fw };
     }
     const infoByBootloader = (0, firmwareInfo_1.getInfo)({ features, releases });
     const releaseByFirmware = releases.find(r => version &&
@@ -30,7 +29,7 @@ const getBinary = async ({ features, releases, baseUrl, version, btcOnly, interm
     const fw = await (0, assets_1.httpRequest)(`${baseUrl}/${btcOnly ? releaseByFirmware.url_bitcoinonly : releaseByFirmware.url}`, 'binary');
     return {
         ...infoByBootloader,
-        binary: (0, modifyFirmware_1.modifyFirmware)({ fw, features }),
+        binary: fw,
     };
 };
 exports.getBinary = getBinary;

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

@@ -0,0 +1,5 @@
+export { getBinary } from './getBinary';
+export { shouldStripFwHeaders, stripFwHeaders } from './modifyFirmware';
+export { uploadFirmware } from './uploadFirmware';
+export { calculateFirmwareHash } from './calculateFirmwareHash';
+//# sourceMappingURL=index.d.ts.map

package/lib/api/firmware/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFirmwareHash = exports.uploadFirmware = exports.stripFwHeaders = exports.shouldStripFwHeaders = exports.getBinary = void 0;
+var getBinary_1 = require("./getBinary");
+Object.defineProperty(exports, "getBinary", { enumerable: true, get: function () { return getBinary_1.getBinary; } });
+var modifyFirmware_1 = require("./modifyFirmware");
+Object.defineProperty(exports, "shouldStripFwHeaders", { enumerable: true, get: function () { return modifyFirmware_1.shouldStripFwHeaders; } });
+Object.defineProperty(exports, "stripFwHeaders", { enumerable: true, get: function () { return modifyFirmware_1.stripFwHeaders; } });
+var uploadFirmware_1 = require("./uploadFirmware");
+Object.defineProperty(exports, "uploadFirmware", { enumerable: true, get: function () { return uploadFirmware_1.uploadFirmware; } });
+var calculateFirmwareHash_1 = require("./calculateFirmwareHash");
+Object.defineProperty(exports, "calculateFirmwareHash", { enumerable: true, get: function () { return calculateFirmwareHash_1.calculateFirmwareHash; } });
+//# sourceMappingURL=index.js.map