@trezor/connect 9.1.4 → 9.1.6

package/lib/events/iframe.js

@@ -8,6 +8,7 @@ exports.IFRAME = {
     INIT: 'iframe-init',
     ERROR: 'iframe-error',
     CALL: 'iframe-call',
+    LOG: 'iframe-log',
 };
 const createIFrameMessage = (type, payload) => ({
     event: ui_request_1.UI_EVENT,

package/lib/events/popup.d.ts

@@ -5,6 +5,7 @@ import type { MessageFactoryFn } from '../types/utils';
 export declare const POPUP: {
     readonly BOOTSTRAP: "popup-bootstrap";
     readonly LOADED: "popup-loaded";
+    readonly CORE_LOADED: "popup-core-loaded";
     readonly INIT: "popup-init";
     readonly ERROR: "popup-error";
     readonly EXTENSION_USB_PERMISSIONS: "open-usb-permissions";
@@ -13,6 +14,8 @@ export declare const POPUP: {
     readonly CANCEL_POPUP_REQUEST: "ui-cancel-popup-request";
     readonly CLOSE_WINDOW: "window.close";
     readonly ANALYTICS_RESPONSE: "popup-analytics-response";
+    readonly CONTENT_SCRIPT_LOADED: "popup-content-script-loaded";
+    readonly METHOD_INFO: "popup-method-info";
 };
 export interface PopupInit {
     type: typeof POPUP.INIT;
@@ -20,13 +23,13 @@ export interface PopupInit {
         settings: ConnectSettings;
         useBroadcastChannel: boolean;
         systemInfo: SystemInfo;
+        useCore?: boolean;
     };
 }
 export interface PopupHandshake {
     type: typeof POPUP.HANDSHAKE;
     payload: {
         settings: ConnectSettings;
-        method?: string;
         transport?: TransportInfo;
     };
 }
@@ -48,10 +51,23 @@ export interface PopupAnalyticsResponse {
         enabled: boolean;
     };
 }
+export interface PopupMethodInfo {
+    type: typeof POPUP.METHOD_INFO;
+    payload: {
+        info: string;
+        method: string;
+    };
+}
+export interface PopupContentScriptLoaded {
+    type: typeof POPUP.CONTENT_SCRIPT_LOADED;
+    payload: {
+        id: string;
+    };
+}
 export type PopupEvent = {
-    type: typeof POPUP.LOADED | typeof POPUP.CANCEL_POPUP_REQUEST;
+    type: typeof POPUP.LOADED | typeof POPUP.CORE_LOADED | typeof POPUP.CANCEL_POPUP_REQUEST;
     payload?: typeof undefined;
-} | PopupInit | PopupHandshake | PopupError | PopupClosedMessage | PopupAnalyticsResponse;
+} | PopupInit | PopupHandshake | PopupError | PopupClosedMessage | PopupAnalyticsResponse | PopupContentScriptLoaded | PopupMethodInfo;
 export type PopupEventMessage = PopupEvent & {
     event: typeof UI_EVENT;
 };

package/lib/events/popup.js

@@ -5,6 +5,7 @@ const ui_request_1 = require("./ui-request");
 exports.POPUP = {
     BOOTSTRAP: 'popup-bootstrap',
     LOADED: 'popup-loaded',
+    CORE_LOADED: 'popup-core-loaded',
     INIT: 'popup-init',
     ERROR: 'popup-error',
     EXTENSION_USB_PERMISSIONS: 'open-usb-permissions',
@@ -13,6 +14,8 @@ exports.POPUP = {
     CANCEL_POPUP_REQUEST: 'ui-cancel-popup-request',
     CLOSE_WINDOW: 'window.close',
     ANALYTICS_RESPONSE: 'popup-analytics-response',
+    CONTENT_SCRIPT_LOADED: 'popup-content-script-loaded',
+    METHOD_INFO: 'popup-method-info',
 };
 const createPopupMessage = (type, payload) => ({
     event: ui_request_1.UI_EVENT,

package/lib/factory.js

@@ -42,6 +42,7 @@ const factory = ({ eventEmitter, manifest, init, call, requestLogin, uiResponse,
         cardanoGetNativeScriptHash: params => call({ ...params, method: 'cardanoGetNativeScriptHash' }),
         cardanoGetPublicKey: params => call({ ...params, method: 'cardanoGetPublicKey' }),
         cardanoSignTransaction: params => call({ ...params, method: 'cardanoSignTransaction' }),
+        cardanoComposeTransaction: params => call({ ...params, method: 'cardanoComposeTransaction' }),
         cipherKeyValue: params => call({ ...params, method: 'cipherKeyValue' }),
         composeTransaction: params => call({ ...params, method: 'composeTransaction' }),
         ethereumGetAddress: params => call({
@@ -54,6 +55,7 @@ const factory = ({ eventEmitter, manifest, init, call, requestLogin, uiResponse,
         ethereumSignTransaction: params => call({ ...params, method: 'ethereumSignTransaction' }),
         ethereumSignTypedData: params => call({ ...params, method: 'ethereumSignTypedData' }),
         ethereumVerifyMessage: params => call({ ...params, method: 'ethereumVerifyMessage' }),
+        getAccountDescriptor: params => call({ ...params, method: 'getAccountDescriptor' }),
         getAccountInfo: params => call({ ...params, method: 'getAccountInfo' }),
         getAddress: params => call({
             ...params,
@@ -81,6 +83,9 @@ 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' }),
+        solanaGetPublicKey: params => call({ ...params, method: 'solanaGetPublicKey' }),
+        solanaGetAddress: params => call({ ...params, method: 'solanaGetAddress' }),
+        solanaSignTransaction: params => call({ ...params, method: 'solanaSignTransaction' }),
         stellarGetAddress: params => call({
             ...params,
             method: 'stellarGetAddress',
@@ -110,6 +115,7 @@ const factory = ({ eventEmitter, manifest, init, call, requestLogin, uiResponse,
         checkFirmwareAuthenticity: params => call({ ...params, method: 'checkFirmwareAuthenticity' }),
         applyFlags: params => call({ ...params, method: 'applyFlags' }),
         applySettings: params => call({ ...params, method: 'applySettings' }),
+        authenticateDevice: params => call({ ...params, method: 'authenticateDevice' }),
         authorizeCoinjoin: params => call({ ...params, method: 'authorizeCoinjoin' }),
         cancelCoinjoinAuthorization: params => call({ ...params, method: 'cancelCoinjoinAuthorization' }),
         showDeviceTutorial: params => call({ ...params, method: 'showDeviceTutorial' }),

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

@@ -0,0 +1,21 @@
+import type { DeviceAuthenticityConfig } from '../../data/deviceAuthenticityConfig';
+import type { Params, Response } from '../params';
+export interface AuthenticateDeviceParams {
+    config?: DeviceAuthenticityConfig;
+    allowDebugKeys?: boolean;
+}
+export type AuthenticateDeviceResult = {
+    valid: true;
+    caPubKey: string;
+    debugKey?: boolean;
+    configExpired?: typeof undefined;
+    error?: typeof undefined;
+} | {
+    valid: false;
+    caPubKey: string;
+    debugKey?: boolean;
+    configExpired?: boolean;
+    error: 'ROOT_PUBKEY_NOT_FOUND' | 'CA_PUBKEY_NOT_FOUND' | 'INVALID_DEVICE_MODEL' | 'INVALID_DEVICE_CERTIFICATE' | 'INVALID_DEVICE_SIGNATURE';
+};
+export declare function authenticateDevice(params: Params<AuthenticateDeviceParams>): Response<AuthenticateDeviceResult>;
+//# sourceMappingURL=authenticateDevice.d.ts.map

package/lib/types/api/authenticateDevice.js

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

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

@@ -0,0 +1,44 @@
+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';
+export type PrecomposedTransactionFinalCardano = Omit<PrecomposeResultFinal, 'inputs' | 'outputs' | 'outputsPermutation'> & {
+    deposit?: string;
+    ttl?: number;
+    inputs: CardanoInput[];
+    outputs: CardanoOutput[];
+    unsignedTx: {
+        body: string;
+        hash: string;
+    };
+};
+export type PrecomposedTransactionNonFinalCardano = Omit<PrecomposeResultNonFinal, 'inputs'> & {
+    deposit?: string;
+};
+export type PrecomposedTransactionErrorCardano = PrecomposeResultError | {
+    type: 'error';
+    error: 'UTXO_BALANCE_INSUFFICIENT' | 'UTXO_VALUE_TOO_SMALL';
+};
+export type PrecomposedTransactionCardano = PrecomposedTransactionFinalCardano | PrecomposedTransactionNonFinalCardano | PrecomposedTransactionErrorCardano;
+export type CardanoComposeTransactionParams = {
+    account: {
+        descriptor: string;
+        addresses: AccountAddresses;
+        utxo: AccountUtxo[];
+    };
+    feeLevels?: {
+        feePerUnit?: string;
+    }[];
+    outputs?: types.UserOutput[];
+    certificates?: CardanoCertificate[];
+    withdrawals?: types.Withdrawal[];
+    changeAddress: {
+        address: string;
+        path: string;
+    };
+    addressParameters: Parameters<(typeof trezorUtils)['transformToTrezorOutputs']>[1];
+    testnet?: boolean;
+};
+export declare function cardanoComposeTransaction(params: Params<CardanoComposeTransactionParams>): Response<PrecomposedTransactionCardano[]>;
+//# sourceMappingURL=cardanoComposeTransaction.d.ts.map

package/lib/types/api/cardanoComposeTransaction.js

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

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

@@ -1,4 +1,13 @@
 import type { Params, Response } from '../params';
 import type { CardanoSignTransaction, CardanoSignedTxData } from './cardano';
 export declare function cardanoSignTransaction(params: Params<CardanoSignTransaction>): Response<CardanoSignedTxData>;
+export declare function cardanoSignTransaction(params: Params<CardanoSignTransaction & {
+    unsignedTx: {
+        body: string;
+        hash: string;
+    };
+    testnet: boolean;
+}>): Response<CardanoSignedTxData & {
+    serializedTx: string;
+}>;
 //# sourceMappingURL=cardanoSignTransaction.d.ts.map

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

@@ -1,34 +1,15 @@
+import type { AccountAddresses, Utxo as AccountUtxo, Address as AccountAddress } from '@trezor/blockchain-link';
+import type { ComposeInput as ComposeInputBase, ComposeOutput as ComposeOutputBase, ComposeResultError as ComposeResultErrorBase, ComposeResultFinal as ComposeResultFinalBase, ComposeResultNonFinal as ComposeResultNonFinalBase } from '@trezor/utxo-lib';
 import type { PROTO } from '../../constants';
-import type { AccountAddresses, Utxo as AccountUtxo } from '@trezor/blockchain-link';
 import type { Params, Response } from '../params';
-export interface RegularOutput {
-    type?: 'external';
-    address: string;
-    amount: string;
-    script_type?: 'PAYTOADDRESS';
-}
-export interface InternalOutput {
-    type?: 'internal';
-    address_n: number[];
-    amount: string;
-    script_type?: string;
-}
-export interface SendMaxOutput {
-    type: 'send-max';
-    address: string;
-}
-export interface OpReturnOutput {
-    type: 'opreturn';
-    dataHex: string;
-}
-export interface NoAddressOutput {
-    type: 'noaddress';
-    amount: string;
-}
-export interface NoAddressSendMaxOutput {
-    type: 'send-max-noaddress';
-}
-export type ComposeOutput = RegularOutput | InternalOutput | SendMaxOutput | OpReturnOutput | NoAddressOutput | NoAddressSendMaxOutput;
+export type ComposeOutputPayment = Omit<Extract<ComposeOutputBase, {
+    type: 'payment';
+}>, 'type'> & {
+    type?: 'payment';
+};
+export type ComposeOutput = Exclude<ComposeOutputBase, {
+    type: 'payment';
+}> | ComposeOutputPayment;
 export interface ComposeParams {
     outputs: ComposeOutput[];
     coin: string;
@@ -45,15 +26,14 @@ export type SignedTransaction = {
     serializedTx: string;
     txid?: string;
 };
+export type ComposeUtxo = AccountUtxo & Partial<ComposeInputBase>;
 export interface PrecomposeParams {
     outputs: ComposeOutput[];
     coin: string;
     account: {
         path: string;
         addresses: AccountAddresses;
-        utxo: (AccountUtxo & {
-            required?: boolean;
-        })[];
+        utxo: ComposeUtxo[];
     };
     feeLevels: {
         feePerUnit: string;
@@ -64,29 +44,23 @@ export interface PrecomposeParams {
     sequence?: number;
     skipPermutation?: boolean;
 }
-export type PrecomposedTransaction = {
+export type ComposedInputs = AccountUtxo & ComposeInputBase;
+export type ComposeResultError = ComposeResultErrorBase | {
     type: 'error';
-    error: string;
-} | {
-    type: 'nonfinal';
-    max?: string;
-    totalSpent: string;
-    fee: string;
-    feePerByte: string;
-    bytes: number;
-} | {
-    type: 'final';
-    max?: string;
-    totalSpent: string;
-    fee: string;
-    feePerByte: string;
-    bytes: number;
-    transaction: {
-        inputs: PROTO.TxInputType[];
-        outputs: PROTO.TxOutputType[];
-        outputsPermutation: number[];
-    };
+    error: 'ADDRESSES-NOT-SET';
+};
+export type ComposeResultFinal = ComposeResultFinalBase<ComposedInputs, ComposeOutputBase, AccountAddress>;
+export type ComposeResultNonFinal = ComposeResultNonFinalBase<ComposedInputs>;
+export type ComposeResult = ComposeResultError | ComposeResultNonFinal | ComposeResultFinal;
+export type PrecomposeResultError = ComposeResultError;
+export type PrecomposeResultNonFinal = Omit<ComposeResultNonFinal, 'inputs'> & {
+    inputs: PROTO.TxInputType[];
+};
+export type PrecomposeResultFinal = Omit<ComposeResultFinal, 'inputs' | 'outputs'> & {
+    inputs: PROTO.TxInputType[];
+    outputs: PROTO.TxOutputType[];
 };
+export type PrecomposedResult = PrecomposeResultError | PrecomposeResultNonFinal | PrecomposeResultFinal;
 export declare function composeTransaction(params: Params<ComposeParams>): Response<SignedTransaction>;
-export declare function composeTransaction(params: Params<PrecomposeParams>): Response<PrecomposedTransaction[]>;
+export declare function composeTransaction(params: Params<PrecomposeParams>): Response<PrecomposedResult[]>;
 //# sourceMappingURL=composeTransaction.d.ts.map

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

@@ -40,6 +40,7 @@ export interface EthereumSignedTx {
     v: string;
     r: string;
     s: string;
+    serializedTx: string;
 }
 interface EthereumSignTypedDataTypeProperty {
     name: string;

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

@@ -0,0 +1,16 @@
+import type { PROTO } from '../../constants';
+import type { Params, BundledParams, Response, DerivationPath } from '../params';
+export interface GetAccountDescriptorParams {
+    path: DerivationPath;
+    coin: string;
+    derivationType?: PROTO.CardanoDerivationType;
+    suppressBackupWarning?: boolean;
+}
+export interface GetAccountDescriptorResponse {
+    descriptor: string;
+    path: string;
+    legacyXpub?: string;
+}
+export declare function getAccountDescriptor(params: Params<GetAccountDescriptorParams>): Response<GetAccountDescriptorResponse>;
+export declare function getAccountDescriptor(params: BundledParams<GetAccountDescriptorParams>): Response<(GetAccountDescriptorResponse | null)[]>;
+//# sourceMappingURL=getAccountDescriptor.d.ts.map

package/lib/types/api/getAccountDescriptor.js

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

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

@@ -1,5 +1,6 @@
 import { applyFlags } from './applyFlags';
 import { applySettings } from './applySettings';
+import { authenticateDevice } from './authenticateDevice';
 import { authorizeCoinjoin } from './authorizeCoinjoin';
 import { backupDevice } from './backupDevice';
 import { binanceGetAddress } from './binanceGetAddress';
@@ -21,6 +22,7 @@ import { cardanoGetAddress } from './cardanoGetAddress';
 import { cardanoGetNativeScriptHash } from './cardanoGetNativeScriptHash';
 import { cardanoGetPublicKey } from './cardanoGetPublicKey';
 import { cardanoSignTransaction } from './cardanoSignTransaction';
+import { cardanoComposeTransaction } from './cardanoComposeTransaction';
 import { changePin } from './changePin';
 import { cipherKeyValue } from './cipherKeyValue';
 import { composeTransaction } from './composeTransaction';
@@ -35,6 +37,7 @@ import { ethereumSignTransaction } from './ethereumSignTransaction';
 import { ethereumSignTypedData } from './ethereumSignTypedData';
 import { ethereumVerifyMessage } from './ethereumVerifyMessage';
 import { firmwareUpdate } from './firmwareUpdate';
+import { getAccountDescriptor } from './getAccountDescriptor';
 import { getAccountInfo } from './getAccountInfo';
 import { getAddress } from './getAddress';
 import { getCoinInfo } from './getCoinInfo';
@@ -65,6 +68,9 @@ import { setBusy } from './setBusy';
 import { setProxy } from './setProxy';
 import { signMessage } from './signMessage';
 import { signTransaction } from './signTransaction';
+import { solanaGetPublicKey } from './solanaGetPublicKey';
+import { solanaGetAddress } from './solanaGetAddress';
+import { solanaSignTransaction } from './solanaSignTransaction';
 import { stellarGetAddress } from './stellarGetAddress';
 import { stellarSignTransaction } from './stellarSignTransaction';
 import { tezosGetAddress } from './tezosGetAddress';
@@ -80,6 +86,7 @@ import { showDeviceTutorial } from './showDeviceTutorial';
 export interface TrezorConnect {
     applyFlags: typeof applyFlags;
     applySettings: typeof applySettings;
+    authenticateDevice: typeof authenticateDevice;
     authorizeCoinjoin: typeof authorizeCoinjoin;
     cancelCoinjoinAuthorization: typeof cancelCoinjoinAuthorization;
     showDeviceTutorial: typeof showDeviceTutorial;
@@ -103,6 +110,7 @@ export interface TrezorConnect {
     cardanoGetNativeScriptHash: typeof cardanoGetNativeScriptHash;
     cardanoGetPublicKey: typeof cardanoGetPublicKey;
     cardanoSignTransaction: typeof cardanoSignTransaction;
+    cardanoComposeTransaction: typeof cardanoComposeTransaction;
     changePin: typeof changePin;
     cipherKeyValue: typeof cipherKeyValue;
     composeTransaction: typeof composeTransaction;
@@ -118,6 +126,7 @@ export interface TrezorConnect {
     ethereumSignTypedData: typeof ethereumSignTypedData;
     ethereumVerifyMessage: typeof ethereumVerifyMessage;
     firmwareUpdate: typeof firmwareUpdate;
+    getAccountDescriptor: typeof getAccountDescriptor;
     getAccountInfo: typeof getAccountInfo;
     getAddress: typeof getAddress;
     getCoinInfo: typeof getCoinInfo;
@@ -147,6 +156,9 @@ export interface TrezorConnect {
     setProxy: typeof setProxy;
     signMessage: typeof signMessage;
     signTransaction: typeof signTransaction;
+    solanaGetPublicKey: typeof solanaGetPublicKey;
+    solanaGetAddress: typeof solanaGetAddress;
+    solanaSignTransaction: typeof solanaSignTransaction;
     stellarGetAddress: typeof stellarGetAddress;
     stellarSignTransaction: typeof stellarSignTransaction;
     tezosGetAddress: typeof tezosGetAddress;

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

@@ -0,0 +1,12 @@
+import type { PublicKey } from '../../params';
+export interface SolanaPublicKey extends PublicKey {
+    publicKey: string;
+}
+export interface SolanaSignTransaction {
+    path: string | number[];
+    serializedTx: string;
+}
+export interface SolanaSignedTransaction {
+    signature: string;
+}
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,4 @@
+import type { Address, GetAddress, Params, BundledParams, 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/solanaGetAddress.js

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

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

@@ -0,0 +1,5 @@
+import type { GetPublicKey, Params, BundledParams, 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[]>;
+//# sourceMappingURL=solanaGetPublicKey.d.ts.map

package/lib/types/api/solanaGetPublicKey.js

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

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

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

package/lib/types/api/solanaSignTransaction.js

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

package/lib/types/coinInfo.d.ts

@@ -1,20 +1,11 @@
+import { Network } from '@trezor/utxo-lib';
 import { FeeLevel } from './fees';
+export type { Network } from '@trezor/utxo-lib';
 export interface CoinSupport {
     connect: boolean;
-    trezor1: string;
-    trezor2: string;
-}
-export interface Network {
-    messagePrefix: string;
-    bech32: string;
-    bip32: {
-        public: number;
-        private: number;
-    };
-    pubKeyHash: number;
-    scriptHash: number;
-    wif: number;
-    forkId?: number;
+    T1B1: string;
+    T2T1: string;
+    T2B1: string;
 }
 export interface BlockchainLink {
     type: string;
@@ -63,5 +54,4 @@ export interface MiscNetworkInfo extends Common {
     network?: typeof undefined;
 }
 export type CoinInfo = BitcoinNetworkInfo | EthereumNetworkInfo | MiscNetworkInfo;
-export {};
 //# sourceMappingURL=coinInfo.d.ts.map

package/lib/types/device.js

@@ -5,7 +5,7 @@ var FirmwareType;
 (function (FirmwareType) {
     FirmwareType["BitcoinOnly"] = "bitcoin-only";
     FirmwareType["Regular"] = "regular";
-})(FirmwareType = exports.FirmwareType || (exports.FirmwareType = {}));
+})(FirmwareType || (exports.FirmwareType = FirmwareType = {}));
 var messages_1 = require("@trezor/protobuf/lib/messages");
 Object.defineProperty(exports, "DeviceModelInternal", { enumerable: true, get: function () { return messages_1.DeviceModelInternal; } });
 //# sourceMappingURL=device.js.map

package/lib/types/firmware.d.ts

@@ -1,9 +1,13 @@
 export interface FirmwareRange {
-    '1': {
+    T1B1: {
         min: string;
         max: string;
     };
-    '2': {
+    T2T1: {
+        min: string;
+        max: string;
+    };
+    T2B1: {
         min: string;
         max: string;
     };

package/lib/types/index.d.ts

@@ -12,9 +12,12 @@ export * from './api/bitcoin';
 export * from './api/eos';
 export * from './api/ripple';
 export * from './api/ethereum';
+export * from './api/solana';
 export * from './api/stellar';
 export * from './api/tezos';
-export type { ComposeOutput, PrecomposedTransaction } from './api/composeTransaction';
+export type { ComposeOutput, PrecomposeResultError, PrecomposeResultNonFinal, PrecomposeResultFinal, PrecomposedResult, } from './api/composeTransaction';
+export type { PrecomposedTransactionCardano, PrecomposedTransactionErrorCardano, PrecomposedTransactionFinalCardano, PrecomposedTransactionNonFinalCardano, } from './api/cardanoComposeTransaction';
 export type { RecoveryDevice } from './api/recoveryDevice';
+export type { AuthenticateDeviceResult } from './api/authenticateDevice';
 export type { TokenInfo, TokenTransfer, InternalTransfer, FiatRates, Target as TransactionTarget, AccountBalanceHistory as BlockchainAccountBalanceHistory, } from '@trezor/blockchain-link';
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -15,6 +15,7 @@ tslib_1.__exportStar(require("./api/bitcoin"), exports);
 tslib_1.__exportStar(require("./api/eos"), exports);
 tslib_1.__exportStar(require("./api/ripple"), exports);
 tslib_1.__exportStar(require("./api/ethereum"), exports);
+tslib_1.__exportStar(require("./api/solana"), exports);
 tslib_1.__exportStar(require("./api/stellar"), exports);
 tslib_1.__exportStar(require("./api/tezos"), exports);
 //# sourceMappingURL=index.js.map

package/lib/types/settings.d.ts

@@ -31,5 +31,6 @@ export interface ConnectSettings {
     env: 'node' | 'web' | 'webextension' | 'electron' | 'react-native';
     timestamp: number;
     proxy?: Proxy;
+    sharedLogger?: boolean;
 }
 //# sourceMappingURL=settings.d.ts.map

package/lib/utils/assetUtils.js

@@ -10,10 +10,12 @@ const getAssetByUrl = (url) => {
             return require('@trezor/connect-common/files/coins-eth.json');
         case './data/bridge/releases.json':
             return require('@trezor/connect-common/files/bridge/releases.json');
-        case './data/firmware/1/releases.json':
-            return require('@trezor/connect-common/files/firmware/1/releases.json');
-        case './data/firmware/2/releases.json':
-            return require('@trezor/connect-common/files/firmware/2/releases.json');
+        case './data/firmware/t1b1/releases.json':
+            return require('@trezor/connect-common/files/firmware/t1b1/releases.json');
+        case './data/firmware/t2t1/releases.json':
+            return require('@trezor/connect-common/files/firmware/t2t1/releases.json');
+        case './data/firmware/t2b1/releases.json':
+            return require('@trezor/connect-common/files/firmware/t2b1/releases.json');
         case './data/messages/messages.json':
             return require('@trezor/protobuf/messages.json');
         default:

package/lib/utils/debug.d.ts

@@ -1,24 +1,29 @@
-type LogMessage = {
+export type LogMessage = {
     level: string;
     prefix: string;
     message: any[];
     timestamp: number;
 };
-declare class Log {
+export type LogWriter = {
+    add: (message: LogMessage) => void;
+};
+export declare class Log {
     prefix: string;
     enabled: boolean;
     css: string;
     messages: LogMessage[];
-    constructor(prefix: string, enabled: boolean);
+    logWriter: LogWriter | undefined;
+    constructor(prefix: string, enabled: boolean, logWriter?: LogWriter);
     addMessage(level: string, prefix: string, ...args: any[]): void;
+    setWriter(logWriter: any): void;
     log(...args: any[]): void;
     error(...args: any[]): void;
     warn(...args: any[]): void;
     debug(...args: any[]): void;
 }
-export declare const initLog: (prefix: string, enabled?: boolean) => Log;
+export declare const initLog: (prefix: string, enabled?: boolean, logWriter?: LogWriter) => Log;
+export declare const setLogWriter: (logWriterFactory: () => LogWriter | undefined) => void;
 export declare const enableLog: (enabled?: boolean) => void;
 export declare const enableLogByPrefix: (prefix: string, enabled: boolean) => void;
 export declare const getLog: () => LogMessage[];
-export {};
 //# sourceMappingURL=debug.d.ts.map