@trezor/connect 9.4.7 → 9.4.8-beta.1

package/lib/events/core.d.ts

@@ -3,13 +3,13 @@ import type { IFrameCallMessage, MethodResponseMessage } from './call';
 import type { DeviceEventMessage } from './device';
 import type { IFrameEventMessage, IFrameInit, IFrameLogRequest } from './iframe';
 import type { PopupAnalyticsResponse, PopupClosedMessage, PopupEventMessage } from './popup';
-import type { TransportEventMessage, TransportDisableWebUSB, TransportRequestWebUSBDevice, TransportGetInfo } from './transport';
+import type { TransportDisableWebUSB, TransportEventMessage, TransportGetInfo, TransportRequestWebUSBDevice, TransportSetTransports } from './transport';
 import type { UiEventMessage } from './ui-request';
 import type { UiResponseEvent } from './ui-response';
-import type { Unsuccessful } from '../types/params';
 import { ErrorCode, TrezorError } from '../constants/errors';
+import type { Unsuccessful } from '../types/params';
 export declare const CORE_EVENT = "CORE_EVENT";
-export type CoreRequestMessage = PopupClosedMessage | PopupAnalyticsResponse | TransportDisableWebUSB | TransportRequestWebUSBDevice | TransportGetInfo | UiResponseEvent | IFrameInit | IFrameCallMessage | IFrameLogRequest;
+export type CoreRequestMessage = PopupClosedMessage | PopupAnalyticsResponse | TransportDisableWebUSB | TransportSetTransports | TransportRequestWebUSBDevice | TransportGetInfo | UiResponseEvent | IFrameInit | IFrameCallMessage | IFrameLogRequest;
 export type CoreEventMessage = {
     success?: boolean;
     channel?: {

package/lib/events/device.d.ts

@@ -1,5 +1,6 @@
 import type { PROTO } from '../constants';
 import type { Device } from '../types/device';
+import type { VersionArray } from '../types/firmware';
 import type { MessageFactoryFn } from '../types/utils';
 export declare const DEVICE_EVENT = "DEVICE_EVENT";
 export declare const DEVICE: {
@@ -7,6 +8,7 @@ export declare const DEVICE: {
     readonly CONNECT_UNACQUIRED: "device-connect_unacquired";
     readonly DISCONNECT: "device-disconnect";
     readonly CHANGED: "device-changed";
+    readonly FIRMWARE_VERSION_CHANGED: "device-firmware_version_changed";
     readonly BUTTON: "button";
     readonly PIN: "pin";
     readonly PASSPHRASE: "passphrase";
@@ -22,10 +24,18 @@ export interface DeviceButtonRequest {
         device: Device;
     };
 }
+export interface DeviceVersionChanged {
+    type: typeof DEVICE.FIRMWARE_VERSION_CHANGED;
+    payload: {
+        device: Device;
+        oldVersion: VersionArray;
+        newVersion: VersionArray;
+    };
+}
 export type DeviceEvent = {
     type: typeof DEVICE.CONNECT | typeof DEVICE.CONNECT_UNACQUIRED | typeof DEVICE.CHANGED | typeof DEVICE.DISCONNECT;
     payload: Device;
-} | DeviceButtonRequest;
+} | DeviceButtonRequest | DeviceVersionChanged;
 export type DeviceEventMessage = DeviceEvent & {
     event: typeof DEVICE_EVENT;
 };

package/lib/events/device.js

@@ -7,6 +7,7 @@ exports.DEVICE = {
     CONNECT_UNACQUIRED: 'device-connect_unacquired',
     DISCONNECT: 'device-disconnect',
     CHANGED: 'device-changed',
+    FIRMWARE_VERSION_CHANGED: 'device-firmware_version_changed',
     BUTTON: 'button',
     PIN: 'pin',
     PASSPHRASE: 'passphrase',

package/lib/events/popup.d.ts

@@ -1,5 +1,5 @@
-import { UI_EVENT } from './ui-request';
 import type { TransportInfo } from './transport';
+import { UI_EVENT } from './ui-request';
 import type { ConnectSettings, SystemInfo } from '../types';
 import type { MessageFactoryFn } from '../types/utils';
 export declare const POPUP: {
@@ -30,7 +30,7 @@ export interface PopupHandshake {
     type: typeof POPUP.HANDSHAKE;
     payload: {
         settings: ConnectSettings;
-        transport?: TransportInfo;
+        transports?: TransportInfo[];
     };
 }
 export interface PopupError {

package/lib/events/transport.d.ts

@@ -1,11 +1,11 @@
 import type { Transport } from '@trezor/transport';
 import { TRANSPORT } from '@trezor/transport/lib/constants';
+import { ConnectSettings } from '../exports';
 import type { MessageFactoryFn } from '../types/utils';
 export { TRANSPORT } from '@trezor/transport/lib/constants';
 export declare const TRANSPORT_EVENT = "TRANSPORT_EVENT";
 export interface BridgeInfo {
     version: number[];
-    directory: string;
     packages: {
         name: string;
         platform: string[];
@@ -16,7 +16,6 @@ export interface BridgeInfo {
     changelog: string;
 }
 export interface UdevInfo {
-    directory: string;
     packages: {
         name: string;
         platform: string[];
@@ -26,24 +25,31 @@ export interface UdevInfo {
     }[];
 }
 export interface TransportInfo {
+    apiType: Transport['apiType'];
     type: Transport['name'];
     version: string;
     outdated: boolean;
+}
+export interface TransportError {
+    apiType?: Transport['apiType'];
+    error: string;
+    code?: string;
+}
+export interface InstallerInfo {
     bridge?: BridgeInfo;
     udev?: UdevInfo;
 }
 export type TransportEvent = {
     type: typeof TRANSPORT.START;
-    payload: TransportInfo;
+    payload: TransportInfo & InstallerInfo;
 } | {
     type: typeof TRANSPORT.ERROR;
-    payload: {
-        error: string;
-        code?: string;
-        bridge?: BridgeInfo;
-        udev?: UdevInfo;
-    };
+    payload: TransportError & InstallerInfo;
 };
+export interface TransportSetTransports {
+    type: typeof TRANSPORT.SET_TRANSPORTS;
+    payload: Pick<ConnectSettings, 'transports'>;
+}
 export interface TransportDisableWebUSB {
     type: typeof TRANSPORT.DISABLE_WEBUSB;
     payload?: undefined;

package/lib/events/transport.js

@@ -2,13 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTransportMessage = exports.TRANSPORT_EVENT = exports.TRANSPORT = void 0;
 const errors_1 = require("../constants/errors");
+const transportInfo_1 = require("../data/transportInfo");
+const udevInfo_1 = require("../data/udevInfo");
 var constants_1 = require("@trezor/transport/lib/constants");
 Object.defineProperty(exports, "TRANSPORT", { enumerable: true, get: function () { return constants_1.TRANSPORT; } });
 exports.TRANSPORT_EVENT = 'TRANSPORT_EVENT';
 const createTransportMessage = (type, payload) => ({
     event: exports.TRANSPORT_EVENT,
     type,
-    payload: 'error' in payload ? (0, errors_1.serializeError)(payload) : payload,
+    payload: 'error' in payload
+        ? (0, errors_1.serializeError)(payload)
+        :
+            {
+                ...payload,
+                udev: (0, udevInfo_1.suggestUdevInstaller)(),
+                bridge: (0, transportInfo_1.suggestBridgeInstaller)(),
+            },
 });
 exports.createTransportMessage = createTransportMessage;
 //# sourceMappingURL=transport.js.map

package/lib/events/ui-promise.d.ts

@@ -1,7 +1,7 @@
 import type { Deferred } from '@trezor/utils';
 import type { DEVICE } from './device';
-import type { Device } from '../device/Device';
 import type { UiResponseEvent } from './ui-response';
+import type { Device } from '../device/Device';
 export type UiPromiseResponse = UiResponseEvent | {
     type: typeof DEVICE.DISCONNECT;
     payload?: undefined;

package/lib/events/ui-request.d.ts

@@ -1,10 +1,10 @@
 import type { EventTypeDeviceSelected } from '@trezor/connect-analytics';
 import type { PROTO } from '../constants';
-import type { Device, CoinInfo, BitcoinNetworkInfo, SelectFeeLevel } from '../types';
-import type { DiscoveryAccountType, DiscoveryAccount } from '../types/account';
-import type { MessageFactoryFn } from '../types/utils';
+import type { BitcoinNetworkInfo, CoinInfo, Device, SelectFeeLevel } from '../types';
 import type { DeviceButtonRequest } from './device';
 import { MethodPermission } from '../core/AbstractMethod';
+import type { DiscoveryAccount, DiscoveryAccountType } from '../types/account';
+import type { MessageFactoryFn } from '../types/utils';
 export declare const UI_EVENT = "UI_EVENT";
 export declare const UI_REQUEST: {
     readonly TRANSPORT: "ui-no_transport";

package/lib/factory.d.ts

@@ -1,18 +1,19 @@
 import type { EventEmitter } from 'events';
-import type { TrezorConnect } from './types';
 import type { CallMethod } from './events/call';
+import type { TrezorConnect } from './types';
 import type { InitType } from './types/api/init';
 export interface ConnectFactoryDependencies<SettingsType extends Record<string, any>> {
     init: InitType<SettingsType>;
     call: CallMethod;
     eventEmitter: EventEmitter;
     manifest: TrezorConnect['manifest'];
+    setTransports: TrezorConnect['setTransports'];
     requestLogin: TrezorConnect['requestLogin'];
     uiResponse: TrezorConnect['uiResponse'];
     cancel: TrezorConnect['cancel'];
     dispose: TrezorConnect['dispose'];
 }
-export declare const factory: <SettingsType extends Record<string, any>, ExtraMethodsType extends Record<string, any>>({ eventEmitter, manifest, init, call, requestLogin, uiResponse, cancel, dispose, }: ConnectFactoryDependencies<SettingsType>, extraMethods?: ExtraMethodsType) => Omit<TrezorConnect, "init"> & {
+export declare const factory: <SettingsType extends Record<string, any>, ExtraMethodsType extends Record<string, any>>({ eventEmitter, manifest, init, call, setTransports, requestLogin, uiResponse, cancel, dispose, }: ConnectFactoryDependencies<SettingsType>, extraMethods?: ExtraMethodsType) => Omit<TrezorConnect, "init"> & {
     init: InitType<SettingsType>;
 } & ExtraMethodsType;
 //# sourceMappingURL=factory.d.ts.map

package/lib/factory.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.factory = void 0;
 const events_1 = require("./events");
-const factory = ({ eventEmitter, manifest, init, call, requestLogin, uiResponse, cancel, dispose, }, extraMethods = {}) => ({
+const factory = ({ eventEmitter, manifest, init, call, setTransports, requestLogin, uiResponse, cancel, dispose, }, extraMethods = {}) => ({
     manifest,
     init,
+    setTransports,
     on: (type, fn) => {
         eventEmitter.on(type, fn);
     },
@@ -83,6 +84,7 @@ const factory = ({ eventEmitter, manifest, init, call, requestLogin, uiResponse,
     rippleSignTransaction: params => call({ ...params, method: 'rippleSignTransaction' }),
     signMessage: params => call({ ...params, method: 'signMessage' }),
     signTransaction: params => call({ ...params, method: 'signTransaction' }),
+    solanaComposeTransaction: params => call({ ...params, method: 'solanaComposeTransaction' }),
     solanaGetPublicKey: params => call({ ...params, method: 'solanaGetPublicKey' }),
     solanaGetAddress: params => call({ ...params, method: 'solanaGetAddress' }),
     solanaSignTransaction: params => call({ ...params, method: 'solanaSignTransaction' }),

package/lib/impl/core-in-module.d.ts

@@ -1,7 +1,8 @@
 import EventEmitter from 'events';
-import { UiResponseEvent, CoreEventMessage, CallMethodPayload, CoreRequestMessage } from '../events';
-import type { ConnectSettings, ConnectSettingsPublic, DeviceIdentity, Manifest } from '../types';
+import { CallMethodPayload, CoreEventMessage, CoreRequestMessage, UiResponseEvent } from '../events';
 import { ConnectFactoryDependencies } from '../factory';
+import type { ConnectSettings, ConnectSettingsPublic, DeviceIdentity, Manifest } from '../types';
+import type { SetTransports } from '../types/api/setTransports';
 export declare class CoreInModule implements ConnectFactoryDependencies<ConnectSettingsPublic> {
     eventEmitter: EventEmitter<[never]>;
     _settings: ConnectSettings;
@@ -18,6 +19,7 @@ export declare class CoreInModule implements ConnectFactoryDependencies<ConnectS
     handleCoreMessage(message: CoreRequestMessage): void;
     private onCoreEvent;
     init(settings?: Partial<ConnectSettings>): Promise<void>;
+    setTransports({ transports }: SetTransports): void;
     private initSettings;
     initCore(): any;
     call(params: CallMethodPayload): Promise<import("../types").Unsuccessful | {

package/lib/impl/core-in-module.js

@@ -5,10 +5,10 @@ const tslib_1 = require("tslib");
 const events_1 = tslib_1.__importDefault(require("events"));
 const utils_1 = require("@trezor/utils");
 const ERRORS = tslib_1.__importStar(require("../constants/errors"));
+const connectSettings_1 = require("../data/connectSettings");
 const events_2 = require("../events");
 const factory_1 = require("../factory");
 const debug_1 = require("../utils/debug");
-const connectSettings_1 = require("../data/connectSettings");
 class CoreInModule {
     constructor(onCoreHook) {
         this.eventEmitter = new events_1.default();
@@ -144,6 +144,13 @@ class CoreInModule {
         }
         this._log.enabled = !!this._settings.debug;
     }
+    setTransports({ transports }) {
+        this._settings = (0, connectSettings_1.parseConnectSettings)({ ...this._settings, transports });
+        this.handleCoreMessage({
+            type: events_2.TRANSPORT.SET_TRANSPORTS,
+            payload: { transports },
+        });
+    }
     initCore() {
         this.initSettings({ lazyLoad: false });
         return this._coreManager.getOrInit(this._settings, this.boundOnCoreEvent);
@@ -214,6 +221,7 @@ exports.TrezorConnect = (0, factory_1.factory)({
     manifest: impl.manifest.bind(impl),
     init: impl.init.bind(impl),
     call: impl.call.bind(impl),
+    setTransports: impl.setTransports.bind(impl),
     requestLogin: impl.requestLogin.bind(impl),
     uiResponse: impl.uiResponse.bind(impl),
     cancel: impl.cancel.bind(impl),

package/lib/impl/dynamic.d.ts

@@ -1,8 +1,9 @@
 import EventEmitter from 'events';
-import { ConnectFactoryDependencies } from '../factory';
-import type { Manifest } from '../types/settings';
 import { CallMethodPayload } from '../events';
+import { ConnectFactoryDependencies } from '../factory';
 import { InitFullSettings } from '../types/api/init';
+import type { SetTransports } from '../types/api/setTransports';
+import type { Manifest } from '../types/settings';
 type TrezorConnectDynamicParams<ImplType, SettingsType extends Record<string, any>, ImplInterface extends ConnectFactoryDependencies<SettingsType>> = {
     implementations: {
         type: ImplType;
@@ -23,6 +24,7 @@ export declare class TrezorConnectDynamic<ImplType, SettingsType extends Record<
     switchTarget(target: ImplType): Promise<void>;
     manifest(manifest: Manifest): void;
     init(settings: InitFullSettings<SettingsType>): Promise<void>;
+    setTransports({ transports }: SetTransports): void;
     call(params: CallMethodPayload): Promise<any>;
     requestLogin(params: any): import("..").Response<import("../types/api/requestLogin").Login>;
     uiResponse(params: any): void;

package/lib/impl/dynamic.js

@@ -26,10 +26,7 @@ class TrezorConnectDynamic {
         await this.getTarget().init(this.lastSettings);
     }
     manifest(manifest) {
-        this.lastSettings = {
-            ...this.lastSettings,
-            manifest,
-        };
+        this.lastSettings = { ...this.lastSettings, manifest };
         this.getTarget().manifest(manifest);
     }
     async init(settings) {
@@ -48,6 +45,10 @@ class TrezorConnectDynamic {
             throw error;
         }
     }
+    setTransports({ transports }) {
+        this.lastSettings = { ...this.lastSettings, transports };
+        this.getTarget().setTransports({ transports });
+    }
     async call(params) {
         const response = await this.getTarget().call(params);
         if (!response.success) {

package/lib/index-browser.js

@@ -15,6 +15,7 @@ const TrezorConnect = (0, factory_1.factory)({
     },
     manifest: fallback,
     init: fallback,
+    setTransports: fallback,
     call: fallback,
     requestLogin: fallback,
     uiResponse: fallback,

package/lib/index.js

@@ -4,12 +4,12 @@ exports.eventEmitter = void 0;
 const tslib_1 = require("tslib");
 const events_1 = tslib_1.__importDefault(require("events"));
 const utils_1 = require("@trezor/utils");
+const constants_1 = require("./constants");
 const core_1 = require("./core");
-const factory_1 = require("./factory");
 const connectSettings_1 = require("./data/connectSettings");
-const debug_1 = require("./utils/debug");
 const events_2 = require("./events");
-const constants_1 = require("./constants");
+const factory_1 = require("./factory");
+const debug_1 = require("./utils/debug");
 exports.eventEmitter = new events_1.default();
 const _log = (0, debug_1.initLog)('@trezor/connect');
 let _settings = (0, connectSettings_1.parseConnectSettings)();
@@ -111,6 +111,13 @@ const call = async (params) => {
         return (0, events_2.createErrorMessage)(error);
     }
 };
+const setTransports = (payload) => {
+    const core = coreManager.get();
+    if (!core) {
+        throw constants_1.ERRORS.TypedError('Init_NotInitialized');
+    }
+    core.handleMessage({ type: events_2.TRANSPORT.SET_TRANSPORTS, payload });
+};
 const uiResponse = (response) => {
     const core = coreManager.get();
     if (!core) {
@@ -167,6 +174,7 @@ const TrezorConnect = (0, factory_1.factory)({
     manifest,
     init,
     call,
+    setTransports,
     requestLogin,
     uiResponse,
     cancel,

package/lib/types/account.d.ts

@@ -1,4 +1,4 @@
-import type { AccountInfo as AccountInfoBase, AccountAddresses, Utxo as AccountUtxo } from '@trezor/blockchain-link';
+import type { AccountAddresses, AccountInfo as AccountInfoBase, Utxo as AccountUtxo } from '@trezor/blockchain-link';
 export type { AccountAddresses, Utxo as AccountUtxo, Address as AccountAddress, Transaction as AccountTransaction, } from '@trezor/blockchain-link';
 export type DiscoveryAccountType = 'p2pkh' | 'p2sh' | 'p2tr' | 'p2wpkh';
 export interface AccountInfo extends AccountInfoBase {

package/lib/types/api/authenticateDevice.d.ts

@@ -42,6 +42,7 @@ export declare const AuthenticateDeviceParams: import("@trezor/schema-utils").TO
     }>, import("@trezor/schema-utils").TObject<{
         T1B1: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
         T2T1: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
+        UNKNOWN: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
     }>]>, import("@trezor/schema-utils").TObject<{
         version: import("@trezor/schema-utils").TNumber;
         timestamp: import("@trezor/schema-utils").TString;

package/lib/types/api/authorizeCoinjoin.d.ts

@@ -1,6 +1,6 @@
 import { Static } from '@trezor/schema-utils';
-import type { Params, Response } from '../params';
 import { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
 export type AuthorizeCoinjoin = Static<typeof AuthorizeCoinjoin>;
 export declare const AuthorizeCoinjoin: import("@trezor/schema-utils").TObject<{
     path: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>;

package/lib/types/api/authorizeCoinjoin.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthorizeCoinjoin = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
-const params_1 = require("../params");
 const constants_1 = require("../../constants");
+const params_1 = require("../params");
 exports.AuthorizeCoinjoin = schema_utils_1.Type.Object({
     path: params_1.DerivationPath,
     coordinator: schema_utils_1.Type.String(),

package/lib/types/api/binanceGetAddress.d.ts

@@ -1,4 +1,4 @@
-import type { GetAddress, Address, Params, BundledParams, Response } from '../params';
+import type { Address, BundledParams, GetAddress, Params, Response } from '../params';
 export declare function binanceGetAddress(params: Params<GetAddress>): Response<Address>;
 export declare function binanceGetAddress(params: BundledParams<GetAddress>): Response<Address[]>;
 //# sourceMappingURL=binanceGetAddress.d.ts.map

package/lib/types/api/binanceGetPublicKey.d.ts

@@ -1,4 +1,4 @@
-import type { GetPublicKey, PublicKey, Params, BundledParams, Response } from '../params';
+import type { BundledParams, GetPublicKey, Params, PublicKey, Response } from '../params';
 export declare function binanceGetPublicKey(params: Params<GetPublicKey>): Response<PublicKey>;
 export declare function binanceGetPublicKey(params: BundledParams<GetPublicKey>): Response<PublicKey[]>;
 //# sourceMappingURL=binanceGetPublicKey.d.ts.map

package/lib/types/api/blockchainEstimateFee.d.ts

@@ -1,5 +1,5 @@
 import type { BlockchainLinkParams, BlockchainLinkResponse } from '@trezor/blockchain-link';
-import type { FeeLevel, FeeInfo } from '../fees';
+import type { FeeInfo, FeeLevel } from '../fees';
 import type { CommonParamsWithCoin, Response } from '../params';
 export interface BlockchainEstimateFee {
     request?: BlockchainLinkParams<'estimateFee'> & {

package/lib/types/api/blockchainSetCustomBackend.d.ts

@@ -1,5 +1,5 @@
-import type { CommonParams, Response } from '../params';
 import type { BlockchainLink } from '../coinInfo';
+import type { CommonParams, Response } from '../params';
 export type BlockchainSetCustomBackend = CommonParams & {
     coin: string;
     blockchainLink?: BlockchainLink;

package/lib/types/api/blockchainSubscribe.d.ts

@@ -1,4 +1,4 @@
-import type { SubscriptionAccountInfo, BlockchainLinkResponse } from '@trezor/blockchain-link';
+import type { BlockchainLinkResponse, SubscriptionAccountInfo } from '@trezor/blockchain-link';
 import type { CommonParamsWithCoin, Response } from '../params';
 export type BlockchainSubscribe = CommonParamsWithCoin & {
     blocks?: boolean;

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

@@ -1,8 +1,11 @@
-import type { types, trezorUtils } from '@fivebinaries/coin-selection';
-import type { AccountAddresses, AccountUtxo } from '../../exports';
-import type { Params, Response } from '../params';
-import type { CardanoCertificate, CardanoInput, CardanoOutput } from './cardano';
-import type { PrecomposeResultFinal, PrecomposeResultNonFinal, PrecomposeResultError } from './composeTransaction';
+import type { trezorUtils, types } from '@fivebinaries/coin-selection';
+import { Static } from '@trezor/schema-utils';
+import { PROTO } from '../../exports';
+import type { AccountUtxo } from '../../exports';
+import { type Params, type Response } from '../params';
+import { CardanoCertificate } from './cardano';
+import type { CardanoInput, CardanoOutput } from './cardano';
+import type { PrecomposeResultError, PrecomposeResultFinal, PrecomposeResultNonFinal } from './composeTransaction';
 export type PrecomposedTransactionFinalCardano = Omit<PrecomposeResultFinal, 'inputs' | 'outputs' | 'outputsPermutation'> & {
     deposit?: string;
     ttl?: number;
@@ -21,10 +24,17 @@ export type PrecomposedTransactionErrorCardano = PrecomposeResultError | {
     error: 'UTXO_BALANCE_INSUFFICIENT' | 'UTXO_VALUE_TOO_SMALL';
 };
 export type PrecomposedTransactionCardano = PrecomposedTransactionFinalCardano | PrecomposedTransactionNonFinalCardano | PrecomposedTransactionErrorCardano;
+export declare const AccountAddress: import("@trezor/schema-utils").TObject<{
+    address: import("@trezor/schema-utils").TString;
+    path: import("@trezor/schema-utils").TString;
+    transfers: import("@trezor/schema-utils").TNumber;
+    balance: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    sent: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    received: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+}>;
 export type CardanoComposeTransactionParams = {
     account: {
         descriptor: string;
-        addresses: AccountAddresses;
         utxo: AccountUtxo[];
     };
     feeLevels?: {
@@ -40,5 +50,101 @@ export type CardanoComposeTransactionParams = {
     addressParameters: Parameters<(typeof trezorUtils)['transformToTrezorOutputs']>[1];
     testnet?: boolean;
 };
+export type CardanoComposeTransactionParamsSchema = Static<typeof CardanoComposeTransactionParamsSchema>;
+export declare const CardanoComposeTransactionParamsSchema: import("@trezor/schema-utils").TObject<{
+    account: import("@trezor/schema-utils").TObject<{
+        descriptor: import("@trezor/schema-utils").TString;
+        utxo: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+            txid: import("@trezor/schema-utils").TString;
+            vout: import("@trezor/schema-utils").TNumber;
+            amount: import("@trezor/schema-utils").TString;
+            blockHeight: import("@trezor/schema-utils").TNumber;
+            address: import("@trezor/schema-utils").TString;
+            path: import("@trezor/schema-utils").TString;
+            confirmations: import("@trezor/schema-utils").TNumber;
+            coinbase: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+            cardanoSpecific: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                unit: import("@trezor/schema-utils").TString;
+            }>>;
+        }>>;
+    }>;
+    feeLevels: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+        feePerUnit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    }>>>;
+    outputs: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+        isChange: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+        assets: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+            unit: import("@trezor/schema-utils").TString;
+            quantity: import("@trezor/schema-utils").TString;
+        }>>;
+    }>, import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TObject<{
+        address: import("@trezor/schema-utils").TString;
+        amount: import("@trezor/schema-utils").TString;
+        setMax: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TLiteral<false>>;
+    }>, import("@trezor/schema-utils").TObject<{
+        address: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        setMax: import("@trezor/schema-utils").TBoolean;
+    }>]>]>>>;
+    certificates: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+        type: import("@trezor/schema-utils").TEnum<typeof PROTO.CardanoCertificateType>;
+        path: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>>;
+        pool: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        poolParameters: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            poolId: import("@trezor/schema-utils").TString;
+            vrfKeyHash: import("@trezor/schema-utils").TString;
+            pledge: import("@trezor/schema-utils").TString;
+            cost: import("@trezor/schema-utils").TString;
+            margin: import("@trezor/schema-utils").TObject<{
+                numerator: import("@trezor/schema-utils").TString;
+                denominator: import("@trezor/schema-utils").TString;
+            }>;
+            rewardAccount: import("@trezor/schema-utils").TString;
+            owners: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+                stakingKeyPath: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>>;
+                stakingKeyHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            }>>;
+            relays: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+                type: import("@trezor/schema-utils").TEnum<typeof PROTO.CardanoPoolRelayType>;
+                ipv4Address: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+                ipv6Address: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+                port: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+                hostName: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            }>>;
+            metadata: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                url: import("@trezor/schema-utils").TString;
+                hash: import("@trezor/schema-utils").TString;
+            }>>;
+        }>>;
+        scriptHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        keyHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        deposit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        dRep: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            type: import("@trezor/schema-utils").TEnum<typeof PROTO.CardanoDRepType>;
+            keyHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            scriptHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        }>>;
+    }>>>;
+    withdrawals: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+        stakeAddress: import("@trezor/schema-utils").TString;
+        amount: import("@trezor/schema-utils").TString;
+    }>>>;
+    changeAddress: import("@trezor/schema-utils").TObject<{
+        address: import("@trezor/schema-utils").TString;
+        path: import("@trezor/schema-utils").TString;
+    }>;
+    addressParameters: import("@trezor/schema-utils").TObject<{
+        addressType: import("@trezor/schema-utils").TEnum<typeof PROTO.CardanoAddressType>;
+        path: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>;
+        stakingPath: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>>;
+        stakingKeyHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        certificatePointer: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            blockIndex: import("@trezor/schema-utils").TNumber;
+            txIndex: import("@trezor/schema-utils").TNumber;
+            certificateIndex: import("@trezor/schema-utils").TNumber;
+        }>>;
+    }>;
+    testnet: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+}>;
 export declare function cardanoComposeTransaction(params: Params<CardanoComposeTransactionParams>): Response<PrecomposedTransactionCardano[]>;
 //# sourceMappingURL=cardanoComposeTransaction.d.ts.map