@trezor/connect 9.4.7 → 9.4.8-beta.2

package/lib/types/api/cardanoComposeTransaction.js

@@ -1,3 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CardanoComposeTransactionParamsSchema = exports.AccountAddress = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+const exports_1 = require("../../exports");
+const params_1 = require("../params");
+const cardano_1 = require("./cardano");
+exports.AccountAddress = schema_utils_1.Type.Object({
+    address: schema_utils_1.Type.String(),
+    path: schema_utils_1.Type.String(),
+    transfers: schema_utils_1.Type.Number(),
+    balance: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    sent: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    received: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+}, {
+    $id: 'AccountAddress',
+});
+exports.CardanoComposeTransactionParamsSchema = schema_utils_1.Type.Object({
+    account: schema_utils_1.Type.Object({
+        descriptor: schema_utils_1.Type.String(),
+        utxo: schema_utils_1.Type.Array(schema_utils_1.Type.Object({
+            txid: schema_utils_1.Type.String(),
+            vout: schema_utils_1.Type.Number(),
+            amount: schema_utils_1.Type.String(),
+            blockHeight: schema_utils_1.Type.Number(),
+            address: schema_utils_1.Type.String(),
+            path: schema_utils_1.Type.String(),
+            confirmations: schema_utils_1.Type.Number(),
+            coinbase: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+            cardanoSpecific: schema_utils_1.Type.Optional(schema_utils_1.Type.Object({
+                unit: schema_utils_1.Type.String(),
+            })),
+        }, { $id: 'AccountUtxo' })),
+    }),
+    feeLevels: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.Object({
+        feePerUnit: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    }))),
+    outputs: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.Intersect([
+        schema_utils_1.Type.Object({
+            isChange: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+            assets: schema_utils_1.Type.Array(schema_utils_1.Type.Object({
+                unit: schema_utils_1.Type.String(),
+                quantity: schema_utils_1.Type.String(),
+            })),
+        }, { $id: 'BaseOutput' }),
+        schema_utils_1.Type.Union([
+            schema_utils_1.Type.Object({
+                address: schema_utils_1.Type.String(),
+                amount: schema_utils_1.Type.String(),
+                setMax: schema_utils_1.Type.Optional(schema_utils_1.Type.Literal(false)),
+            }, { $id: 'ExternalOutput' }),
+            schema_utils_1.Type.Object({
+                address: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+                amount: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+                setMax: schema_utils_1.Type.Boolean(),
+            }, { $id: 'ExternalOutputIncomplete' }),
+        ]),
+    ], { $id: 'UserOutput' }))),
+    certificates: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(cardano_1.CardanoCertificate)),
+    withdrawals: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.Object({
+        stakeAddress: schema_utils_1.Type.String(),
+        amount: schema_utils_1.Type.String(),
+    }, { $id: 'Withdrawal' }))),
+    changeAddress: schema_utils_1.Type.Object({
+        address: schema_utils_1.Type.String(),
+        path: schema_utils_1.Type.String(),
+    }),
+    addressParameters: schema_utils_1.Type.Object({
+        addressType: exports_1.PROTO.EnumCardanoAddressType,
+        path: params_1.DerivationPath,
+        stakingPath: schema_utils_1.Type.Optional(params_1.DerivationPath),
+        stakingKeyHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+        certificatePointer: schema_utils_1.Type.Optional(cardano_1.CardanoCertificatePointer),
+    }, { $id: 'CardanoAddressParameters' }),
+    testnet: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+});
+const _params = {};
+const _paramsOld = {};
+[_params, _paramsOld];
 //# sourceMappingURL=cardanoComposeTransaction.js.map

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

@@ -1,4 +1,4 @@
-import type { Params, BundledParams, Response } from '../params';
+import type { BundledParams, Params, Response } from '../params';
 import type { CardanoAddress, CardanoGetAddress } from './cardano';
 export declare function cardanoGetAddress(params: Params<CardanoGetAddress>): Response<CardanoAddress>;
 export declare function cardanoGetAddress(params: BundledParams<CardanoGetAddress>): Response<CardanoAddress[]>;

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

@@ -1,4 +1,4 @@
-import type { Params, BundledParams, Response } from '../params';
+import type { BundledParams, Params, Response } from '../params';
 import type { CardanoGetPublicKey, CardanoPublicKey } from './cardano';
 export declare function cardanoGetPublicKey(params: Params<CardanoGetPublicKey>): Response<CardanoPublicKey>;
 export declare function cardanoGetPublicKey(params: BundledParams<CardanoGetPublicKey>): Response<CardanoPublicKey[]>;

package/lib/types/api/changeLanguage.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 ChangeLanguage = Static<typeof ChangeLanguage>;
 export declare const ChangeLanguage: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TObject<{
     binary: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;

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

@@ -1,5 +1,5 @@
 import { Static } from '@trezor/schema-utils';
-import { Params, BundledParams, Response } from '../params';
+import { BundledParams, Params, Response } from '../params';
 export type CipherKeyValue = Static<typeof CipherKeyValue>;
 export declare const CipherKeyValue: 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/composeTransaction.d.ts

@@ -1,4 +1,4 @@
-import type { AccountAddresses, Utxo as AccountUtxo, Address as AccountAddress } from '@trezor/blockchain-link';
+import type { Address as AccountAddress, AccountAddresses, Utxo as AccountUtxo } from '@trezor/blockchain-link';
 import type { ComposeInput as ComposeInputBase, ComposeOutput as ComposeOutputBase, ComposeResultError as ComposeResultErrorBase, ComposeResultFinal as ComposeResultFinalBase, ComposeResultNonFinal as ComposeResultNonFinalBase, TransactionInputOutputSortingStrategy } from '@trezor/utxo-lib';
 import type { PROTO } from '../../constants';
 import type { Params, Response } from '../params';

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

@@ -1,4 +1,4 @@
-import type { Params, GetPublicKey, BundledParams, Response } from '../params';
+import type { BundledParams, GetPublicKey, Params, Response } from '../params';
 import { EosPublicKey } from './eos';
 export declare function eosGetPublicKey(params: Params<GetPublicKey>): Response<EosPublicKey>;
 export declare function eosGetPublicKey(params: BundledParams<GetPublicKey>): Response<EosPublicKey[]>;

package/lib/types/api/ethereumGetAddress.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 ethereumGetAddress(params: Params<GetAddress>): Response<Address>;
 export declare function ethereumGetAddress(params: BundledParams<GetAddress>): Response<Address[]>;
 //# sourceMappingURL=ethereumGetAddress.d.ts.map

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

@@ -1,4 +1,4 @@
-import type { GetPublicKey, Params, BundledParams, Response } from '../params';
+import type { BundledParams, GetPublicKey, Params, Response } from '../params';
 import type { HDNodeResponse } from './getPublicKey';
 export declare function ethereumGetPublicKey(params: Params<GetPublicKey>): Response<HDNodeResponse>;
 export declare function ethereumGetPublicKey(params: BundledParams<GetPublicKey>): Response<HDNodeResponse[]>;

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

@@ -1,6 +1,6 @@
 import type { PROTO } from '../../constants';
 import type { Params, Response } from '../params';
-import type { EthereumSignTypedDataTypes, EthereumSignTypedData, EthereumSignTypedHash } from './ethereum';
+import type { EthereumSignTypedData, EthereumSignTypedDataTypes, EthereumSignTypedHash } from './ethereum';
 export declare function ethereumSignTypedData<T extends EthereumSignTypedDataTypes>(params: Params<EthereumSignTypedData<T>>): Response<PROTO.EthereumTypedDataSignature>;
 export declare function ethereumSignTypedData<T extends EthereumSignTypedDataTypes>(params: Params<EthereumSignTypedHash<T>>): Response<PROTO.EthereumTypedDataSignature>;
 //# sourceMappingURL=ethereumSignTypedData.d.ts.map

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

@@ -1,4 +1,5 @@
 import { Static } from '@trezor/schema-utils';
+import type { VersionArray } from '../firmware';
 import type { Params, Response } from '../params';
 export type FirmwareUpdate = Static<typeof FirmwareUpdate>;
 export declare const FirmwareUpdate: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TObject<{
@@ -9,11 +10,19 @@ export declare const FirmwareUpdate: import("@trezor/schema-utils").TUnion<[impo
 }>, import("@trezor/schema-utils").TObject<{
     binary: import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer;
 }>]>;
-export type FirmwareUpdateResponse = {
+type FirmwareUpdateDetails = {
+    versionCheck: boolean;
+    bootloaderVersion: VersionArray;
+    installedVersion: VersionArray;
+    binaryVersion: VersionArray;
+    releaseVersion?: VersionArray;
+};
+export type FirmwareUpdateResponse = FirmwareUpdateDetails & ({
     check: 'mismatch' | 'valid' | 'omitted';
 } | {
     check: 'other-error';
     checkError: string;
-};
+});
 export declare function firmwareUpdate(params: Params<FirmwareUpdate>): Response<FirmwareUpdateResponse>;
+export {};
 //# sourceMappingURL=firmwareUpdate.d.ts.map

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

@@ -1,6 +1,6 @@
 import { Static } from '@trezor/schema-utils';
 import { PROTO } from '../../constants';
-import { Params, BundledParams, Response } from '../params';
+import { BundledParams, Params, Response } from '../params';
 export type GetAccountDescriptorParams = Static<typeof GetAccountDescriptorParams>;
 export declare const GetAccountDescriptorParams: 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/getAccountInfo.d.ts

@@ -1,7 +1,7 @@
 import type { BlockchainLinkParams } from '@trezor/blockchain-link';
 import type { PROTO } from '../../constants';
-import type { Params, BundledParams, Response } from '../params';
 import type { AccountInfo, DiscoveryAccountType } from '../account';
+import type { BundledParams, Params, Response } from '../params';
 export interface GetAccountInfo extends Omit<BlockchainLinkParams<'getAccountInfo'>, 'descriptor'> {
     coin: string;
     identity?: string;

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

@@ -1,6 +1,6 @@
 import { Static } from '@trezor/schema-utils';
 import { PROTO } from '../../constants';
-import { Address as AddressShared, Params, BundledParams, Response } from '../params';
+import { Address as AddressShared, BundledParams, Params, Response } from '../params';
 export type GetAddress = Static<typeof GetAddress>;
 export declare const GetAddress: 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>]>;
@@ -33,6 +33,7 @@ export declare const GetAddress: import("@trezor/schema-utils").TObject<{
             public_key: import("@trezor/schema-utils").TString;
         }>>>;
         address_n: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>>;
+        pubkeys_order: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TEnum<typeof PROTO.MultisigPubkeysOrder>>;
     }>>;
     crossChain: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
     unlockPath: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{

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

@@ -1,5 +1,5 @@
-import type { CommonParams, Response } from '../params';
 import type { CoinInfo } from '../coinInfo';
+import type { CommonParams, Response } from '../params';
 export declare function getCoinInfo(params: CommonParams & {
     coin: string;
 }): Response<CoinInfo>;

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

@@ -1,5 +1,5 @@
-import type { CommonParams, Response } from '../params';
 import type { DeviceState, StaticSessionId } from '../device';
+import type { CommonParams, Response } from '../params';
 export interface DeviceStateResponse {
     state: StaticSessionId;
     _state: DeviceState;

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

@@ -1,4 +1,4 @@
-import type { CommonParams, Response } from '../params';
 import type { Features } from '../device';
+import type { CommonParams, Response } from '../params';
 export declare function getFeatures(params?: CommonParams): Response<Features>;
 //# sourceMappingURL=getFeatures.d.ts.map

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

@@ -1,6 +1,6 @@
 import { Static } from '@trezor/schema-utils';
 import { PROTO } from '../../constants';
-import { Params, BundledParams, Response } from '../params';
+import { BundledParams, Params, Response } from '../params';
 export type GetOwnershipId = Static<typeof GetOwnershipId>;
 export declare const GetOwnershipId: 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>]>;
@@ -28,6 +28,7 @@ export declare const GetOwnershipId: import("@trezor/schema-utils").TObject<{
             public_key: import("@trezor/schema-utils").TString;
         }>>>;
         address_n: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>>;
+        pubkeys_order: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TEnum<typeof PROTO.MultisigPubkeysOrder>>;
     }>>;
     scriptType: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"SPENDADDRESS">, import("@trezor/schema-utils").TLiteral<"SPENDMULTISIG">, import("@trezor/schema-utils").TLiteral<"SPENDWITNESS">, import("@trezor/schema-utils").TLiteral<"SPENDP2SHWITNESS">, import("@trezor/schema-utils").TLiteral<"SPENDTAPROOT">]>>;
 }>;

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

@@ -1,6 +1,6 @@
 import { Static } from '@trezor/schema-utils';
 import { PROTO } from '../../constants';
-import { Params, BundledParams, Response } from '../params';
+import { BundledParams, Params, Response } from '../params';
 export type GetOwnershipProof = Static<typeof GetOwnershipProof>;
 export declare const GetOwnershipProof: 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>]>;
@@ -28,6 +28,7 @@ export declare const GetOwnershipProof: import("@trezor/schema-utils").TObject<{
             public_key: import("@trezor/schema-utils").TString;
         }>>>;
         address_n: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>>;
+        pubkeys_order: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TEnum<typeof PROTO.MultisigPubkeysOrder>>;
     }>>;
     scriptType: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"SPENDADDRESS">, import("@trezor/schema-utils").TLiteral<"SPENDMULTISIG">, import("@trezor/schema-utils").TLiteral<"SPENDWITNESS">, import("@trezor/schema-utils").TLiteral<"SPENDP2SHWITNESS">, import("@trezor/schema-utils").TLiteral<"SPENDTAPROOT">]>>;
     userConfirmation: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;

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

@@ -1,5 +1,5 @@
 import { Static } from '@trezor/schema-utils';
-import { Params, BundledParams, Response } from '../params';
+import { BundledParams, Params, Response } from '../params';
 export type GetPublicKey = Static<typeof GetPublicKey>;
 export declare const GetPublicKey: import("@trezor/schema-utils").TIntersect<[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/index.d.ts

@@ -8,11 +8,11 @@ import { binanceGetPublicKey } from './binanceGetPublicKey';
 import { binanceSignTransaction } from './binanceSignTransaction';
 import { blockchainDisconnect } from './blockchainDisconnect';
 import { blockchainEstimateFee } from './blockchainEstimateFee';
+import { blockchainEvmRpcCall } from './blockchainEvmRpcCall';
 import { blockchainGetAccountBalanceHistory } from './blockchainGetAccountBalanceHistory';
 import { blockchainGetCurrentFiatRates } from './blockchainGetCurrentFiatRates';
-import { blockchainGetInfo } from './blockchainGetInfo';
-import { blockchainEvmRpcCall } from './blockchainEvmRpcCall';
 import { blockchainGetFiatRatesForTimestamps } from './blockchainGetFiatRatesForTimestamps';
+import { blockchainGetInfo } from './blockchainGetInfo';
 import { blockchainGetTransactions } from './blockchainGetTransactions';
 import { blockchainSetCustomBackend } from './blockchainSetCustomBackend';
 import { blockchainSubscribe } from './blockchainSubscribe';
@@ -53,6 +53,7 @@ import { getOwnershipProof } from './getOwnershipProof';
 import { getPublicKey } from './getPublicKey';
 import { getSettings } from './getSettings';
 import { init } from './init';
+import { loadDevice } from './loadDevice';
 import { manifest } from './manifest';
 import { nemGetAddress } from './nemGetAddress';
 import { nemSignTransaction } from './nemSignTransaction';
@@ -63,15 +64,16 @@ import { recoveryDevice } from './recoveryDevice';
 import { removeAllListeners } from './removeAllListeners';
 import { requestLogin } from './requestLogin';
 import { resetDevice } from './resetDevice';
-import { loadDevice } from './loadDevice';
 import { rippleGetAddress } from './rippleGetAddress';
 import { rippleSignTransaction } from './rippleSignTransaction';
 import { setBrightness } from './setBrightness';
 import { setBusy } from './setBusy';
 import { setProxy } from './setProxy';
+import { setTransports } from './setTransports';
 import { showDeviceTutorial } from './showDeviceTutorial';
 import { signMessage } from './signMessage';
 import { signTransaction } from './signTransaction';
+import { solanaComposeTransaction } from './solanaComposeTransaction';
 import { solanaGetAddress } from './solanaGetAddress';
 import { solanaGetPublicKey } from './solanaGetPublicKey';
 import { solanaSignTransaction } from './solanaSignTransaction';
@@ -157,8 +159,10 @@ export interface TrezorConnect {
     setBrightness: typeof setBrightness;
     setBusy: typeof setBusy;
     setProxy: typeof setProxy;
+    setTransports: typeof setTransports;
     signMessage: typeof signMessage;
     signTransaction: typeof signTransaction;
+    solanaComposeTransaction: typeof solanaComposeTransaction;
     solanaGetPublicKey: typeof solanaGetPublicKey;
     solanaGetAddress: typeof solanaGetAddress;
     solanaSignTransaction: typeof solanaSignTransaction;

package/lib/types/api/nem/index.d.ts

@@ -1,5 +1,5 @@
 import { Static } from '@trezor/schema-utils';
-import { PROTO, NEM } from '../../../constants';
+import { NEM, PROTO } from '../../../constants';
 export type MosaicID = Static<typeof MosaicID>;
 export declare const MosaicID: import("@trezor/schema-utils").TObject<{
     namespaceId: import("@trezor/schema-utils").TString;

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

@@ -1,5 +1,5 @@
 import { Static } from '@trezor/schema-utils';
-import { Address, Params, BundledParams, Response } from '../params';
+import { Address, BundledParams, Params, Response } from '../params';
 export type NEMGetAddress = Static<typeof NEMGetAddress>;
 export declare const NEMGetAddress: 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/on.d.ts

@@ -1,7 +1,7 @@
 import type { BlockchainEvent, BlockchainEventListenerFn } from '../../events/blockchain';
 import type { DeviceEvent, DeviceEventListenerFn } from '../../events/device';
 import type { TransportEvent, TransportEventListenerFn } from '../../events/transport';
-import type { UiEvent, UiEventListenerFn, ProgressEventListenerFn } from '../../events/ui-request';
+import type { ProgressEventListenerFn, UiEvent, UiEventListenerFn } from '../../events/ui-request';
 import type { UnionToIntersection } from '../utils';
 type DetailedEvent<Event> = Event extends {
     type: string;

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

@@ -8,10 +8,10 @@ export declare const RecoveryDevice: import("@trezor/schema-utils").TObject<{
     pin_protection: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
     passphrase_protection: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
     type: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/keyof-enum").TKeyOfEnum<typeof PROTO.Enum_RecoveryType>>;
+    u2f_counter: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
     word_count: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TNumber, import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<12>, import("@trezor/schema-utils").TLiteral<18>, import("@trezor/schema-utils").TLiteral<24>]>]>>;
     enforce_wordlist: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
     input_method: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TEnum<typeof PROTO.RecoveryDeviceInputMethod>>;
-    u2f_counter: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
 }>;
 export declare function recoveryDevice(params: Params<RecoveryDevice>): Response<PROTO.Success>;
 //# sourceMappingURL=recoveryDevice.d.ts.map

package/lib/types/api/rippleGetAddress.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 rippleGetAddress(params: Params<GetAddress>): Response<Address>;
 export declare function rippleGetAddress(params: BundledParams<GetAddress>): Response<Address[]>;
 //# sourceMappingURL=rippleGetAddress.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { ConnectSettings } from '../settings';
+export type SetTransports = Pick<ConnectSettings, 'transports'>;
+export declare function setTransports(params: SetTransports): void;
+//# sourceMappingURL=setTransports.d.ts.map

package/lib/types/api/setTransports.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=setTransports.js.map

package/lib/types/api/solana/index.d.ts

@@ -35,9 +35,50 @@ export declare const SolanaSignTransaction: import("@trezor/schema-utils").TObje
             tokenAccount: import("@trezor/schema-utils").TString;
         }>>>;
     }>>;
+    serialize: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
 }>;
 export type SolanaSignedTransaction = Static<typeof SolanaSignedTransaction>;
 export declare const SolanaSignedTransaction: import("@trezor/schema-utils").TObject<{
     signature: import("@trezor/schema-utils").TString;
+    serializedTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+}>;
+export type SolanaProgramName = Static<typeof SolanaProgramName>;
+export declare const SolanaProgramName: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"spl-token">, import("@trezor/schema-utils").TLiteral<"spl-token-2022">]>;
+export type SolanaComposeTransaction = Static<typeof SolanaComposeTransaction>;
+export declare const SolanaComposeTransaction: import("@trezor/schema-utils").TObject<{
+    fromAddress: import("@trezor/schema-utils").TString;
+    toAddress: import("@trezor/schema-utils").TString;
+    amount: import("@trezor/schema-utils").TString;
+    blockHash: import("@trezor/schema-utils").TString;
+    lastValidBlockHeight: import("@trezor/schema-utils").TNumber;
+    priorityFees: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+        computeUnitPrice: import("@trezor/schema-utils").TString;
+        computeUnitLimit: import("@trezor/schema-utils").TString;
+    }>>;
+    token: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+        mint: import("@trezor/schema-utils").TString;
+        program: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"spl-token">, import("@trezor/schema-utils").TLiteral<"spl-token-2022">]>;
+        decimals: import("@trezor/schema-utils").TNumber;
+        accounts: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+            publicKey: import("@trezor/schema-utils").TString;
+            balance: import("@trezor/schema-utils").TString;
+        }>>;
+    }>>;
+    coin: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    identity: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+}>;
+export type SolanaComposedTransaction = Static<typeof SolanaComposedTransaction>;
+export declare const SolanaComposedTransaction: import("@trezor/schema-utils").TObject<{
+    serializedTx: import("@trezor/schema-utils").TString;
+    additionalInfo: import("@trezor/schema-utils").TObject<{
+        isCreatingAccount: import("@trezor/schema-utils").TBoolean;
+        newTokenAccountProgramName: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"spl-token">, import("@trezor/schema-utils").TLiteral<"spl-token-2022">]>>;
+        tokenAccountInfo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            baseAddress: import("@trezor/schema-utils").TString;
+            tokenProgram: import("@trezor/schema-utils").TString;
+            tokenMint: import("@trezor/schema-utils").TString;
+            tokenAccount: import("@trezor/schema-utils").TString;
+        }>>;
+    }>;
 }>;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/api/solana/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaSignedTransaction = exports.SolanaSignTransaction = exports.SolanaTxAdditionalInfo = exports.SolanaTxTokenAccountInfo = exports.SolanaPublicKey = void 0;
+exports.SolanaComposedTransaction = exports.SolanaComposeTransaction = exports.SolanaProgramName = exports.SolanaSignedTransaction = exports.SolanaSignTransaction = exports.SolanaTxAdditionalInfo = exports.SolanaTxTokenAccountInfo = exports.SolanaPublicKey = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
 const params_1 = require("../../params");
 exports.SolanaPublicKey = schema_utils_1.Type.Intersect([
@@ -22,8 +22,38 @@ exports.SolanaSignTransaction = schema_utils_1.Type.Object({
     path: schema_utils_1.Type.Union([schema_utils_1.Type.String(), schema_utils_1.Type.Array(schema_utils_1.Type.Number())]),
     serializedTx: schema_utils_1.Type.String(),
     additionalInfo: schema_utils_1.Type.Optional(exports.SolanaTxAdditionalInfo),
+    serialize: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
 });
 exports.SolanaSignedTransaction = schema_utils_1.Type.Object({
     signature: schema_utils_1.Type.String(),
+    serializedTx: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+});
+exports.SolanaProgramName = schema_utils_1.Type.Union([
+    schema_utils_1.Type.Literal('spl-token'),
+    schema_utils_1.Type.Literal('spl-token-2022'),
+]);
+exports.SolanaComposeTransaction = schema_utils_1.Type.Object({
+    fromAddress: schema_utils_1.Type.String(),
+    toAddress: schema_utils_1.Type.String(),
+    amount: schema_utils_1.Type.String(),
+    blockHash: schema_utils_1.Type.String(),
+    lastValidBlockHeight: schema_utils_1.Type.Number(),
+    priorityFees: schema_utils_1.Type.Optional(schema_utils_1.Type.Object({ computeUnitPrice: schema_utils_1.Type.String(), computeUnitLimit: schema_utils_1.Type.String() })),
+    token: schema_utils_1.Type.Optional(schema_utils_1.Type.Object({
+        mint: schema_utils_1.Type.String(),
+        program: exports.SolanaProgramName,
+        decimals: schema_utils_1.Type.Number(),
+        accounts: schema_utils_1.Type.Array(schema_utils_1.Type.Object({ publicKey: schema_utils_1.Type.String(), balance: schema_utils_1.Type.String() })),
+    })),
+    coin: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    identity: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+});
+exports.SolanaComposedTransaction = schema_utils_1.Type.Object({
+    serializedTx: schema_utils_1.Type.String(),
+    additionalInfo: schema_utils_1.Type.Object({
+        isCreatingAccount: schema_utils_1.Type.Boolean(),
+        newTokenAccountProgramName: schema_utils_1.Type.Optional(exports.SolanaProgramName),
+        tokenAccountInfo: schema_utils_1.Type.Optional(exports.SolanaTxTokenAccountInfo),
+    }),
 });
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,4 @@
+import type { Params, Response } from '../params';
+import type { SolanaComposeTransaction, SolanaComposedTransaction } from './solana';
+export declare function solanaComposeTransaction(params: Params<SolanaComposeTransaction>): Response<SolanaComposedTransaction>;
+//# sourceMappingURL=solanaComposeTransaction.d.ts.map

package/lib/types/api/solanaComposeTransaction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=solanaComposeTransaction.js.map

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

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

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

@@ -1,4 +1,4 @@
-import type { GetPublicKey, Params, BundledParams, Response } from '../params';
+import type { BundledParams, GetPublicKey, Params, Response } from '../params';
 import type { SolanaPublicKey } from './solana';
 export declare function solanaGetPublicKey(params: Params<GetPublicKey>): Response<SolanaPublicKey>;
 export declare function solanaGetPublicKey(params: BundledParams<GetPublicKey>): Response<SolanaPublicKey[]>;

package/lib/types/api/stellarGetAddress.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 stellarGetAddress(params: Params<GetAddress>): Response<Address>;
 export declare function stellarGetAddress(params: BundledParams<GetAddress>): Response<Address[]>;
 //# sourceMappingURL=stellarGetAddress.d.ts.map

package/lib/types/api/tezosGetAddress.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 tezosGetAddress(params: Params<GetAddress>): Response<Address>;
 export declare function tezosGetAddress(params: BundledParams<GetAddress>): Response<Address[]>;
 //# sourceMappingURL=tezosGetAddress.d.ts.map

package/lib/types/api/tezosGetPublicKey.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 tezosGetPublicKey(params: Params<GetPublicKey>): Response<PublicKey>;
 export declare function tezosGetPublicKey(params: BundledParams<GetPublicKey>): Response<PublicKey[]>;
 //# sourceMappingURL=tezosGetPublicKey.d.ts.map

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

@@ -1,6 +1,6 @@
 import { Static } from '@trezor/schema-utils';
-import { Params, Response } from '../params';
 import type { PROTO } from '../../constants';
+import { Params, Response } from '../params';
 export type UnlockPathParams = Static<typeof UnlockPathParams>;
 export declare const UnlockPathParams: 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>]>;