@trezor/connect 9.1.4 → 9.1.6

package/CHANGELOG.md

@@ -1,3 +1,53 @@
+# 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)
+-   feat(connect): add authenticateDevice method (45b99c0813, af907a296d, 249ddc358a)
+-   feat(connect): btg, dash, dgb, nmc, vrc no support for T2B1 (0819ff6fc1)
+-   feat(suite): support t2b1 firmware installation (9ef2bf627a)
+-   fix(connect): get firmware status and release after ensuring internal model (dca3333c2d)
+-   fix(connect-popup): webusb in popup if iframe is on same origin as host (e571971586)
+-   feat(connect-web): trust-issues query string param (b1b6e3f287)
+-   feat(connect-plugin-stellar): Update stellar-sdk and stellar-base (ee7e67db04)
+-   chore(connect): t1 emulator with pin (33c6ca58bf)
+-   fix(connect-popup): allow decimal custom fee entry (bf20f23f05, 8a8d93b5e8)
+-   feat(connect-explorer): add rebootToBootloader method (9996676358)
+-   fix(connect): wrong version format in discovery (19b13d1d4c)
+-   feat(connect-popup): logger in sharedworker collecting from all environments (732bc7d, 2521c7c, 6501dfa4fd)
+-   chore(connect): do not lowercase device color (7229b88c20)
+
 # 9.1.4
 
 -   feat(connect-popup): add metamask extension id to known third party (f137b3e4d6)

package/README.md

@@ -1,6 +1,6 @@
 # @trezor/connect
 
-API version 9.1.4
+API version 9.1.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)

package/lib/api/authenticateDevice.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { AuthenticateDeviceParams } from '../types/api/authenticateDevice';
+export default class AuthenticateDevice extends AbstractMethod<'authenticateDevice', AuthenticateDeviceParams> {
+    init(): void;
+    run(): Promise<import("../types/api/authenticateDevice").AuthenticateDeviceResult>;
+}
+//# sourceMappingURL=authenticateDevice.d.ts.map

package/lib/api/authenticateDevice.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const events_1 = require("../events");
+const paramsValidator_1 = require("./common/paramsValidator");
+const deviceAuthenticityConfig_1 = require("../data/deviceAuthenticityConfig");
+const verifyAuthenticityProof_1 = require("./firmware/verifyAuthenticityProof");
+class AuthenticateDevice extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useEmptyPassphrase = true;
+        this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
+        this.requiredPermissions = ['management'];
+        this.useDeviceState = false;
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'config', type: 'object' },
+            { name: 'allowDebugKeys', type: 'boolean' },
+        ]);
+        if (payload.config) {
+            (0, paramsValidator_1.validateParams)(payload.config, [{ name: 'timestamp', type: 'string', required: true }]);
+            (0, paramsValidator_1.validateParams)(payload.config.T2B1, [
+                { name: 'rootPubKeys', type: 'array', required: true },
+                { name: 'caPubKeys', type: 'array', required: true },
+            ]);
+        }
+        this.params = {
+            config: payload.config,
+            allowDebugKeys: payload.allowDebugKeys,
+        };
+    }
+    async run() {
+        const challenge = (0, verifyAuthenticityProof_1.getRandomChallenge)();
+        const { message } = await this.device
+            .getCommands()
+            .typedCall('AuthenticateDevice', 'AuthenticityProof', {
+            challenge: challenge.toString('hex'),
+        });
+        const config = this.params.config || deviceAuthenticityConfig_1.deviceAuthenticityConfig;
+        const valid = await (0, verifyAuthenticityProof_1.verifyAuthenticityProof)({
+            ...message,
+            challenge,
+            config,
+            allowDebugKeys: this.params.allowDebugKeys,
+            deviceModel: this.device.features.internal_model,
+        });
+        return valid;
+    }
+}
+exports.default = AuthenticateDevice;
+//# sourceMappingURL=authenticateDevice.js.map

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;
 };
@@ -17,7 +17,7 @@ export default class BinanceGetAddress extends AbstractMethod<'binanceGetAddress
     confirmation(): Promise<boolean>;
     noBackupConfirmation(): Promise<boolean>;
     _call({ address_n, show_display }: Params): Promise<PROTO.BinanceAddress>;
-    run(): Promise<import("..").Address | import("..").Address[]>;
+    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);

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,5 +1,5 @@
-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;

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'];

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/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;
 };
@@ -18,7 +18,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("..").CardanoAddress | import("..").CardanoAddress[]>;
+    run(): Promise<import("../../..").CardanoAddress | import("../../..").CardanoAddress[]>;
 }
 export {};
 //# sourceMappingURL=cardanoGetAddress.d.ts.map

package/lib/api/{cardanoGetAddress.js → cardano/api/cardanoGetAddress.js}

@@ -1,12 +1,12 @@
 "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 cardanoAddressParameters_1 = require("./cardano/cardanoAddressParameters");
-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 cardanoAddressParameters_1 = require("../cardanoAddressParameters");
+const constants_1 = require("../../../constants");
+const events_1 = require("../../../events");
 class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
     constructor() {
         super(...arguments);

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

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

package/lib/api/{cardanoGetNativeScriptHash.js → cardano/api/cardanoGetNativeScriptHash.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-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 AbstractMethod_1 = require("../../../core/AbstractMethod");
+const paramsValidator_1 = require("../../common/paramsValidator");
+const coinInfo_1 = require("../../../data/coinInfo");
+const pathUtils_1 = require("../../../utils/pathUtils");
 class CardanoGetNativeScriptHash extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];

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

@@ -1,5 +1,5 @@
-import { PROTO } from '../constants';
-import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../../../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
 interface Params extends PROTO.CardanoGetPublicKey {
     suppressBackupWarning?: boolean;
 }
@@ -10,7 +10,7 @@ export default class CardanoGetPublicKey extends AbstractMethod<'cardanoGetPubli
     get info(): string;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(allowSuppression?: boolean): Promise<boolean>;
-    run(): Promise<import("..").CardanoPublicKey | import("..").CardanoPublicKey[]>;
+    run(): Promise<import("../../..").CardanoPublicKey | import("../../..").CardanoPublicKey[]>;
 }
 export {};
 //# sourceMappingURL=cardanoGetPublicKey.d.ts.map