@trezor/connect 9.1.5 → 9.1.7

package/CHANGELOG.md

@@ -1,3 +1,69 @@
+# 9.1.7
+
+-   fix(connect): correct UiRequestConfirmation type in solanaGetPublicKey (a93ea1890)
+-   chore(connect): stricter UiRequestConfirmation types (f35bd28bf)
+-   feat(connect-common): add more backend urls for solana (29f042470)
+-   chore: Throttler throttling instead of debouncing in `@trezor/blockchain-link` (#10288) (f7ff0cf9f)
+-   feat(transport): accept encoding protocols as parameter of send, receive and call methods (b64af958e)
+-   fix(connect-explorer): fs, path, fallbacks in webpack (4f5a15e32)
+-   chore(connect-common): update fw binaries to 2.6.4 (398509788)
+-   docs(connect): update index page (8cb5262f6)
+-   feat(connect-explorer): update SVG in Header component (e8d9beace)
+-   feat(connect-explorer): update favicon image (a8d660dd2)
+-   feat(connect-explorer): add Solana (799bf63f5)
+-   chore(connect): update downgraded @ethereumjs libs (9ac430c42)
+-   chore(connect): add option for chunkify solana `getAddress` method (98d234f31)
+-   fix(connect-explorer-webextension): add commitHash to webpack (6b6b77d9d)
+-   feat(suite): add Solana support (f2a89b34f)
+-   chore: add Holesky (175707861,8776bb79c)
+-   feat(connect-explorer): version docs (6ea9ef1f2)
+-   fix(connect-popup): when connect-src not same as host popup display unknown origin (1bc6f2da1)
+-   feat(connect-explorer, connect): add `chunkify` paramater to getAddress and signTx methods (7e01923f0,2926b2bdb)
+-   fix(connect-popup): handle METHOD_INFO (e6d11072b)
+-   fix(connect): support unknown (custom) internal_models (0915d8893)
+-   fix(cardano): fee estimate for set-max output (c50a8f2c7)
+-   chore(connect): use `tslib` as dependency in all public libs (606ecc63b)
+-   chore: update `jest` and related dependency (b8a321c83)
+-   chore(connect-examples): cleanup unused lines in script (b509d24d5)
+-   chore(connect-webextension): postMessage useQueue param (4e626e758)
+-   chore(repo): update tsx (53de3e3a8)
+-   chore(connect): remove Solana beta console logs (3ea8343ee)
+-   chore(docs): add link to internal description of device authenticity config update (ee9ad470a)
+-   chore(connect): add new CA pubkeys and update timestamp (b64c3f411)
+
+# 9.1.6
+
+-   chore(connect): remove web3-utils (2f683f6)
+-   feat(connect): serialize in ethereumSignTransaction (8f62896)
+-   feat(connect): add serializeEthereumTx util (a9b21a3)
+-   refactor(connect): improve ethereumSignTransaction (788910b)
+-   feat(connect-popup): shared worker logger load dynamically only when required (424383e, f5400f8)
+-   feat(connect): update solana backend urls, fee info, workers, account descriptor and fw integration (876f609, a3ae0ae, e1058ea, cadffc6, 3d9c703)
+-   feat(connect-popup): add new method that allow set to use core (d944e50)
+-   feat(core): new events for core in popup (242a169)
+-   chore(connect-iframe): suppress subtle crypto warning (1f0e722)
+-   feat(connect-iframe): standalone core build (c344c3d)
+-   feat(deps): update deps without breaking changes (7e0584c)
+-   fix(connect-web, connect-popup): remove trust-issues handle from query param (79036e8, b8640d8, 87b4b84)
+-   feat(connect-explorer): settings page to restart connect (33e41f6)
+-   feat(connect): update protobuf messages in custom Transports (if not set) (1eb5156)
+-   fix(connect): device.run race condition (7d0545c, 7978eab)
+-   feat(connect-common): add T2T1 & T2B1 firmware binaries 2.6.3 bootloader 2.1.4 (9cca8b1)
+-   fix(mobile): Fix modularized connect in React Native (57fcb9d, ba42388, 1ef62e7)
+-   chore(deps): bump @fivebinaries/coin-selection (5e16f60)
+-   chore(connect): ethereum api dynamic load (b22d228)
+-   chore(connect): cardano api dynamic load (3ef0e77)
+-   chore(connect): stellar api dynamic import (473ea94)
+-   chore(connect): nem api dynamic import (52e2f99)
+-   chore(connect): eos api dynamic import (cf5b3ad)
+-   chore(connect): binance api dynamic import (3ccf149)
+-   chore(connect): tezos api dynamic import (273a9fe)
+-   chore(connect): ripple api dynamic import (9b17e38)
+-   chore(connect): prepare for dynamic method import (d4868eb)
+-   chore(connect): blockchain link workers dynamic import (74fd083)
+-   chore(connect): implement @trezor/utxo-lib 2.0.0 (06a9f7a)
+-   feat(connect): add getAccountDescriptor method (0b005ec)
+
 # 9.1.5
 
 -   feat(suite): T2B1 replace Model R name by official Trezor Safe 3 name (7460372ed1)

package/README.md

@@ -1,6 +1,6 @@
 # @trezor/connect
 
-API version 9.1.5
+API version 9.1.7
 
 [![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)

package/lib/api/{binanceGetAddress.d.ts → binance/api/binanceGetAddress.d.ts}

@@ -1,5 +1,5 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import { PROTO } from '../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import { PROTO } from '../../../constants';
 type Params = PROTO.BinanceGetAddress & {
     address?: string;
 };
@@ -16,8 +16,8 @@ export default class BinanceGetAddress extends AbstractMethod<'binanceGetAddress
     } | undefined;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(): Promise<boolean>;
-    _call({ address_n, show_display }: Params): Promise<PROTO.BinanceAddress>;
-    run(): Promise<import("..").Address | import("..").Address[]>;
+    _call({ address_n, show_display, chunkify }: Params): Promise<PROTO.BinanceAddress>;
+    run(): Promise<import("../../..").Address | import("../../..").Address[]>;
 }
 export {};
 //# sourceMappingURL=binanceGetAddress.d.ts.map

package/lib/api/{binanceGetAddress.js → binance/api/binanceGetAddress.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const coinInfo_1 = require("../data/coinInfo");
-const pathUtils_1 = require("../utils/pathUtils");
-const constants_1 = require("../constants");
-const events_1 = require("../events");
+const AbstractMethod_1 = require("../../../core/AbstractMethod");
+const paramsValidator_1 = require("../../common/paramsValidator");
+const coinInfo_1 = require("../../../data/coinInfo");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const constants_1 = require("../../../constants");
+const events_1 = require("../../../events");
 class BinanceGetAddress extends AbstractMethod_1.AbstractMethod {
     constructor() {
         super(...arguments);
@@ -27,12 +27,14 @@ class BinanceGetAddress extends AbstractMethod_1.AbstractMethod {
                 { name: 'path', required: true },
                 { name: 'address', type: 'string' },
                 { name: 'showOnTrezor', type: 'boolean' },
+                { name: 'chunkify', type: 'boolean' },
             ]);
             const path = (0, pathUtils_1.validatePath)(batch.path, 3);
             return {
                 address_n: path,
                 address: batch.address,
                 show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+                chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false,
             };
         });
         const useEventListener = payload.useEventListener &&
@@ -79,11 +81,12 @@ class BinanceGetAddress extends AbstractMethod_1.AbstractMethod {
         const uiResp = await uiPromise.promise;
         return uiResp.payload;
     }
-    async _call({ address_n, show_display }) {
+    async _call({ address_n, show_display, chunkify }) {
         const cmd = this.device.getCommands();
         const response = await cmd.typedCall('BinanceGetAddress', 'BinanceAddress', {
             address_n,
             show_display,
+            chunkify,
         });
         return response.message;
     }

package/lib/api/{binanceGetPublicKey.d.ts → binance/api/binanceGetPublicKey.d.ts}

@@ -1,11 +1,11 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import type { PROTO } from '../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import type { PROTO } from '../../../constants';
 export default class BinanceGetPublicKey extends AbstractMethod<'binanceGetPublicKey', PROTO.BinanceGetPublicKey[]> {
     hasBundle?: boolean;
     confirmed?: boolean;
     init(): void;
     get info(): string;
     confirmation(): Promise<boolean>;
-    run(): Promise<import("..").PublicKey | import("..").PublicKey[]>;
+    run(): Promise<import("../../..").PublicKey | import("../../..").PublicKey[]>;
 }
 //# sourceMappingURL=binanceGetPublicKey.d.ts.map

package/lib/api/{binanceGetPublicKey.js → binance/api/binanceGetPublicKey.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const coinInfo_1 = require("../data/coinInfo");
-const pathUtils_1 = require("../utils/pathUtils");
-const events_1 = require("../events");
+const AbstractMethod_1 = require("../../../core/AbstractMethod");
+const paramsValidator_1 = require("../../common/paramsValidator");
+const coinInfo_1 = require("../../../data/coinInfo");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const events_1 = require("../../../events");
 class BinanceGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];

package/lib/api/{binanceSignTransaction.d.ts → binance/api/binanceSignTransaction.d.ts}

@@ -1,8 +1,9 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import type { BinancePreparedTransaction } from '../types/api/binance';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import type { BinancePreparedTransaction } from '../../../types/api/binance';
 type Params = {
     path: number[];
     transaction: BinancePreparedTransaction;
+    chunkify?: boolean;
 };
 export default class BinanceSignTransaction extends AbstractMethod<'binanceSignTransaction', Params> {
     init(): void;

package/lib/api/{binanceSignTransaction.js → binance/api/binanceSignTransaction.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const coinInfo_1 = require("../data/coinInfo");
-const pathUtils_1 = require("../utils/pathUtils");
-const helper = tslib_1.__importStar(require("./binance/binanceSignTx"));
+const AbstractMethod_1 = require("../../../core/AbstractMethod");
+const paramsValidator_1 = require("../../common/paramsValidator");
+const coinInfo_1 = require("../../../data/coinInfo");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const helper = tslib_1.__importStar(require("../binanceSignTx"));
 class BinanceSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
@@ -14,19 +14,21 @@ class BinanceSignTransaction extends AbstractMethod_1.AbstractMethod {
         (0, paramsValidator_1.validateParams)(payload, [
             { name: 'path', type: 'string', required: true },
             { name: 'transaction', required: true },
+            { name: 'chunkify', type: 'boolean' },
         ]);
         const path = (0, pathUtils_1.validatePath)(payload.path, 3);
         const transaction = helper.validate(payload.transaction);
         this.params = {
             path,
             transaction,
+            chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false,
         };
     }
     get info() {
         return 'Sign Binance transaction';
     }
     run() {
-        return helper.signTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.transaction);
+        return helper.signTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.transaction, this.params.chunkify);
     }
 }
 exports.default = BinanceSignTransaction;

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

@@ -0,0 +1,4 @@
+export { default as binanceGetAddress } from './binanceGetAddress';
+export { default as binanceGetPublicKey } from './binanceGetPublicKey';
+export { default as binanceSignTransaction } from './binanceSignTransaction';
+//# sourceMappingURL=index.d.ts.map

package/lib/api/binance/api/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binanceSignTransaction = exports.binanceGetPublicKey = exports.binanceGetAddress = void 0;
+var binanceGetAddress_1 = require("./binanceGetAddress");
+Object.defineProperty(exports, "binanceGetAddress", { enumerable: true, get: function () { return __importDefault(binanceGetAddress_1).default; } });
+var binanceGetPublicKey_1 = require("./binanceGetPublicKey");
+Object.defineProperty(exports, "binanceGetPublicKey", { enumerable: true, get: function () { return __importDefault(binanceGetPublicKey_1).default; } });
+var binanceSignTransaction_1 = require("./binanceSignTransaction");
+Object.defineProperty(exports, "binanceSignTransaction", { enumerable: true, get: function () { return __importDefault(binanceSignTransaction_1).default; } });
+//# sourceMappingURL=index.js.map

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

@@ -2,5 +2,5 @@ import { PROTO } from '../../constants';
 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>;
+export declare const signTx: (typedCall: TypedCall, address_n: number[], tx: BinancePreparedTransaction, chunkify?: boolean) => Promise<PROTO.BinanceSignedTx>;
 //# sourceMappingURL=binanceSignTx.d.ts.map

package/lib/api/binance/binanceSignTx.js

@@ -73,7 +73,7 @@ const validate = (tx) => {
     return preparedTx;
 };
 exports.validate = validate;
-const signTx = async (typedCall, address_n, tx) => {
+const signTx = async (typedCall, address_n, tx, chunkify) => {
     const { account_number, chain_id, memo, sequence, source, messages } = tx;
     const msg_count = messages.length;
     await typedCall('BinanceSignTx', 'BinanceTxRequest', {
@@ -84,6 +84,7 @@ const signTx = async (typedCall, address_n, tx) => {
         memo,
         sequence,
         source,
+        chunkify,
     });
     return processTxRequest(typedCall, messages, 0);
 };

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

@@ -1,11 +1,11 @@
-import { ComposeInput, ComposeOutput, ComposeResult } from '@trezor/utxo-lib';
+import { ComposeOutput } from '@trezor/utxo-lib';
 import { FeeLevels } from './Fees';
 import { Blockchain } from '../../backend/BlockchainLink';
 import type { BitcoinNetworkInfo, DiscoveryAccount, SelectFeeLevel } from '../../types';
-import type { PrecomposeParams } from '../../types/api/composeTransaction';
+import type { ComposeUtxo, ComposedInputs, ComposeResult } from '../../types/api/composeTransaction';
 type Options = {
     account: DiscoveryAccount;
-    utxo: PrecomposeParams['account']['utxo'];
+    utxos: ComposeUtxo[];
     outputs: ComposeOutput[];
     coinInfo: BitcoinNetworkInfo;
     baseFee?: number;
@@ -13,7 +13,7 @@ type Options = {
 };
 export declare class TransactionComposer {
     account: DiscoveryAccount;
-    utxos: ComposeInput[];
+    utxos: ComposedInputs[];
     outputs: ComposeOutput[];
     coinInfo: BitcoinNetworkInfo;
     blockHeight: number;

package/lib/api/bitcoin/TransactionComposer.js

@@ -5,7 +5,6 @@ const tslib_1 = require("tslib");
 const bignumber_js_1 = tslib_1.__importDefault(require("bignumber.js"));
 const utxo_lib_1 = require("@trezor/utxo-lib");
 const Fees_1 = require("./Fees");
-const pathUtils_1 = require("../../utils/pathUtils");
 class TransactionComposer {
     constructor(options) {
         this.blockHeight = 0;
@@ -24,22 +23,13 @@ class TransactionComposer {
                 .concat(addresses.unused)
                 .concat(addresses.change)
                 .map(a => a.address);
-        this.utxos = options.utxo.flatMap(u => {
-            if (!u.required && new bignumber_js_1.default(u.amount).lt(this.coinInfo.dustLimit))
+        this.utxos = options.utxos.flatMap(u => {
+            if (!u.required && new bignumber_js_1.default(u.amount).lte(this.coinInfo.dustLimit))
                 return [];
-            const addressPath = (0, pathUtils_1.getHDPath)(u.path);
-            const [chain, index] = addressPath.slice(addressPath.length - 2);
             return {
-                index: u.vout,
-                transactionHash: u.txid,
-                value: u.amount,
-                addressPath: [chain, index],
-                height: u.blockHeight,
-                tsize: 0,
-                vsize: 0,
+                ...u,
                 coinbase: typeof u.coinbase === 'boolean' ? u.coinbase : false,
                 own: allAddresses.indexOf(u.address) >= 0,
-                required: u.required,
             };
         });
     }
@@ -120,19 +110,15 @@ class TransactionComposer {
             return { type: 'error', error: 'ADDRESSES-NOT-SET' };
         const changeAddress = addresses.change.find(a => !a.transfers) ||
             addresses.change[addresses.change.length - 1];
-        const changeId = (0, pathUtils_1.getHDPath)(changeAddress.path).slice(-1)[0];
         return (0, utxo_lib_1.composeTx)({
             txType: account.type,
             utxos: this.utxos,
             outputs: this.outputs,
-            height: this.blockHeight,
             feeRate,
             longTermFeeRate: this.feeLevels.longTermFeeRate,
             skipPermutation: this.skipPermutation,
-            basePath: account.address_n,
             network: coinInfo.network,
-            changeId,
-            changeAddress: changeAddress.address,
+            changeAddress,
             dustThreshold: coinInfo.dustLimit,
             baseFee,
         });

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

@@ -1,8 +1,8 @@
-import type { ComposedTxInput } from '@trezor/utxo-lib';
 import type { TypedRawTransaction } from '@trezor/blockchain-link';
 import type { BitcoinNetworkInfo, ProtoWithDerivationPath } from '../../types';
+import type { ComposeUtxo } from '../../types/api/composeTransaction';
 import type { PROTO } from '../../constants';
 export declare const validateTrezorInputs: (inputs: ProtoWithDerivationPath<PROTO.TxInputType>[], coinInfo: BitcoinNetworkInfo) => PROTO.TxInputType[];
 export declare const enhanceTrezorInputs: (inputs: PROTO.TxInputType[], rawTxs: TypedRawTransaction[]) => void;
-export declare const inputToTrezor: (input: ComposedTxInput, sequence: number) => PROTO.TxInputType;
+export declare const inputToTrezor: (input: ComposeUtxo, sequence?: number) => PROTO.TxInputType;
 //# sourceMappingURL=inputs.d.ts.map

package/lib/api/bitcoin/inputs.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inputToTrezor = exports.enhanceTrezorInputs = exports.validateTrezorInputs = void 0;
-const utils_1 = require("@trezor/utils");
 const pathUtils_1 = require("../../utils/pathUtils");
 const hdnodeUtils_1 = require("../../utils/hdnodeUtils");
 const paramsValidator_1 = require("../common/paramsValidator");
@@ -46,12 +45,12 @@ const enhanceTrezorInputs = (inputs, rawTxs) => {
     });
 };
 exports.enhanceTrezorInputs = enhanceTrezorInputs;
-const inputToTrezor = (input, sequence) => {
-    const address_n = input.path;
+const inputToTrezor = (input, sequence = 0xffffffff) => {
+    const address_n = (0, pathUtils_1.getHDPath)(input.path);
     return {
         address_n,
-        prev_index: input.index,
-        prev_hash: utils_1.bufferUtils.reverseBuffer(input.hash).toString('hex'),
+        prev_index: input.vout,
+        prev_hash: input.txid,
         script_type: (0, pathUtils_1.getScriptType)(address_n),
         amount: input.amount,
         sequence,

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

@@ -1,8 +1,8 @@
-import type { ComposeOutput as UtxoLibOutput, ComposedTxOutput } from '@trezor/utxo-lib';
+import { ComposeOutput as ComposeOutputBase } from '@trezor/utxo-lib';
 import { PROTO } from '../../constants';
 import type { BitcoinNetworkInfo, ProtoWithDerivationPath } from '../../types';
-import type { ComposeOutput } from '../../types/api/composeTransaction';
+import type { ComposeOutput, ComposeResultFinal } from '../../types/api/composeTransaction';
 export declare const validateTrezorOutputs: (outputs: ProtoWithDerivationPath<PROTO.TxOutputType>[], coinInfo: BitcoinNetworkInfo) => PROTO.TxOutputType[];
-export declare const validateHDOutput: (output: ComposeOutput, coinInfo: BitcoinNetworkInfo) => UtxoLibOutput;
-export declare const outputToTrezor: (output: ComposedTxOutput, _coinInfo: BitcoinNetworkInfo) => PROTO.TxOutputType;
+export declare const validateHDOutput: (output: ComposeOutput, coinInfo: BitcoinNetworkInfo) => ComposeOutputBase;
+export declare const outputToTrezor: (output: ComposeResultFinal['outputs'][number]) => PROTO.TxOutputType;
 //# sourceMappingURL=outputs.d.ts.map

package/lib/api/bitcoin/outputs.js

@@ -45,7 +45,7 @@ const validateHDOutput = (output, coinInfo) => {
             (0, paramsValidator_1.validateParams)(output, [{ name: 'dataHex', type: 'string' }]);
             return {
                 type: 'opreturn',
-                dataHex: output.dataHex || '',
+                dataHex: output.dataHex,
             };
         case 'send-max':
             (0, paramsValidator_1.validateParams)(output, [{ name: 'address', type: 'string', required: true }]);
@@ -54,10 +54,10 @@ const validateHDOutput = (output, coinInfo) => {
                 type: 'send-max',
                 address: output.address,
             };
-        case 'noaddress':
+        case 'payment-noaddress':
             (0, paramsValidator_1.validateParams)(output, [{ name: 'amount', type: 'uint', required: true }]);
             return {
-                type: 'noaddress',
+                type: 'payment-noaddress',
                 amount: output.amount,
             };
         case 'send-max-noaddress':
@@ -71,41 +71,32 @@ const validateHDOutput = (output, coinInfo) => {
             ]);
             validateAddress(output.address);
             return {
-                type: 'complete',
+                type: 'payment',
                 address: output.address,
                 amount: output.amount,
             };
     }
 };
 exports.validateHDOutput = validateHDOutput;
-const outputToTrezor = (output, _coinInfo) => {
-    if (output.opReturnData) {
-        if (output.value) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'opReturn output should not contains value');
-        }
+const outputToTrezor = (output) => {
+    if (output.type === 'opreturn') {
         return {
             amount: '0',
-            op_return_data: output.opReturnData.toString('hex'),
+            op_return_data: output.dataHex,
             script_type: 'PAYTOOPRETURN',
         };
     }
-    if (!output.address && !output.path) {
-        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Both address and path of an output cannot be null.');
-    }
-    if (output.path) {
+    if (output.type === 'change') {
+        const address_n = (0, pathUtils_1.getHDPath)(output.path);
         return {
-            address_n: output.path,
-            amount: output.value,
-            script_type: (0, pathUtils_1.getOutputScriptType)(output.path),
+            address_n,
+            amount: output.amount,
+            script_type: (0, pathUtils_1.getOutputScriptType)(address_n),
         };
     }
-    const { address, value } = output;
-    if (typeof address !== 'string') {
-        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Wrong output address type, should be string');
-    }
     return {
-        address,
-        amount: value,
+        address: output.address,
+        amount: output.amount,
         script_type: 'PAYTOADDRESS',
     };
 };

package/lib/api/blockchainEstimateFee.d.ts

@@ -1,4 +1,4 @@
-import { Payload, AbstractMethod } from '../core/AbstractMethod';
+import { Payload, MethodReturnType, AbstractMethod } from '../core/AbstractMethod';
 import type { CoinInfo } from '../types';
 type Params = {
     coinInfo: CoinInfo;
@@ -6,7 +6,7 @@ type Params = {
 };
 export default class BlockchainEstimateFee extends AbstractMethod<'blockchainEstimateFee', Params> {
     init(): void;
-    run(): Promise<import("../types/api/blockchainEstimateFee").BlockchainEstimatedFee | import("../types/api/blockchainEstimateFee").BlockchainEstimatedFeeLevel>;
+    run(): Promise<MethodReturnType<"blockchainEstimateFee">>;
 }
 export {};
 //# sourceMappingURL=blockchainEstimateFee.d.ts.map

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

@@ -0,0 +1,8 @@
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import type { CardanoComposeTransactionParams, PrecomposedTransactionCardano } from '../../../types/api/cardanoComposeTransaction';
+export default class CardanoComposeTransaction extends AbstractMethod<'cardanoComposeTransaction', CardanoComposeTransactionParams> {
+    init(): void;
+    get info(): string;
+    run(): Promise<PrecomposedTransactionCardano[]>;
+}
+//# sourceMappingURL=cardanoComposeTransaction.d.ts.map

package/lib/api/cardano/api/cardanoComposeTransaction.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const coin_selection_1 = require("@fivebinaries/coin-selection");
+const AbstractMethod_1 = require("../../../core/AbstractMethod");
+const paramsValidator_1 = require("../../common/paramsValidator");
+const cardanoUtils_1 = require("../cardanoUtils");
+class CardanoComposeTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'account', type: 'object', required: true },
+            { name: 'feeLevels', type: 'array' },
+            { name: 'outputs', type: 'array' },
+            { name: 'certificates', type: 'array', allowEmpty: true },
+            { name: 'withdrawals', type: 'array', allowEmpty: true },
+            { name: 'changeAddress', type: 'object', required: true },
+            { name: 'addressParameters', type: 'object', required: true },
+            { name: 'testnet', type: 'boolean' },
+        ]);
+        this.useDevice = false;
+        this.useDeviceState = false;
+        this.useUi = false;
+        this.params = payload;
+    }
+    get info() {
+        return 'Compose Cardano transaction';
+    }
+    run() {
+        const { feeLevels = [{}], account, outputs = [], certificates = [], withdrawals = [], changeAddress, addressParameters, testnet, } = this.params;
+        const result = feeLevels.map(({ feePerUnit }) => {
+            try {
+                const txPlan = (0, cardanoUtils_1.composeTxPlan)(account.descriptor, account.utxo, outputs, certificates, withdrawals, changeAddress.address, !!testnet, { feeParams: feePerUnit ? { a: feePerUnit } : undefined });
+                return {
+                    fee: txPlan.fee,
+                    feePerByte: feePerUnit !== null && feePerUnit !== void 0 ? feePerUnit : '0',
+                    deposit: txPlan.deposit,
+                    totalSpent: txPlan.totalSpent,
+                    max: txPlan.max,
+                    ...(txPlan.type === 'nonfinal'
+                        ? {
+                            type: txPlan.type,
+                            bytes: 0,
+                        }
+                        : {
+                            type: txPlan.type,
+                            bytes: txPlan.tx.size,
+                            ttl: txPlan.ttl,
+                            inputs: coin_selection_1.trezorUtils.transformToTrezorInputs(txPlan.inputs, account.utxo),
+                            outputs: coin_selection_1.trezorUtils.transformToTrezorOutputs(txPlan.outputs, addressParameters),
+                            unsignedTx: txPlan.tx,
+                        }),
+                };
+            }
+            catch (error) {
+                if (error instanceof coin_selection_1.CoinSelectionError &&
+                    error.code === 'UTXO_BALANCE_INSUFFICIENT') {
+                    return { type: 'error', error: 'UTXO_BALANCE_INSUFFICIENT' };
+                }
+                if (error instanceof coin_selection_1.CoinSelectionError && error.code === 'UTXO_VALUE_TOO_SMALL') {
+                    return { type: 'error', error: 'UTXO_VALUE_TOO_SMALL' };
+                }
+                return { type: 'error', error: error.message };
+            }
+        });
+        return Promise.resolve(result);
+    }
+}
+exports.default = CardanoComposeTransaction;
+//# sourceMappingURL=cardanoComposeTransaction.js.map

package/lib/api/{cardanoGetAddress.d.ts → cardano/api/cardanoGetAddress.d.ts}

@@ -1,5 +1,5 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import { PROTO } from '../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import { PROTO } from '../../../constants';
 type Params = PROTO.CardanoGetAddress & {
     address?: string;
 };
@@ -16,9 +16,9 @@ export default class CardanoGetAddress extends AbstractMethod<'cardanoGetAddress
     } | undefined;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(): Promise<boolean>;
-    _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, }: Params): Promise<PROTO.CardanoAddress>;
+    _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, chunkify, }: Params): Promise<PROTO.CardanoAddress>;
     _ensureFirmwareSupportsBatch(batch: Params): void;
-    run(): Promise<import("..").CardanoAddress | import("..").CardanoAddress[]>;
+    run(): Promise<import("../../..").CardanoAddress | import("../../..").CardanoAddress[]>;
 }
 export {};
 //# sourceMappingURL=cardanoGetAddress.d.ts.map