@trezor/connect 9.5.0 → 9.5.1-beta.1

package/lib/device/TransportList.d.ts

@@ -0,0 +1,9 @@
+import { BridgeTransport, NodeUsbTransport, Transport, UdpTransport } from '@trezor/transport';
+import type { AbstractTransportParams } from '@trezor/transport/lib/transports/abstract';
+import { ConnectSettingsTransport } from '../types';
+type Params = AbstractTransportParams & {
+    sessionsBackgroundUrl?: string | null;
+};
+export declare const createTransportList: (params: Params) => (existing: Transport[], transports?: ConnectSettingsTransport[]) => (Transport | NodeUsbTransport | BridgeTransport | UdpTransport)[];
+export {};
+//# sourceMappingURL=TransportList.d.ts.map

package/lib/device/TransportList.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransportList = void 0;
+const transport_1 = require("@trezor/transport");
+const constants_1 = require("../constants");
+const transportInfo_1 = require("../data/transportInfo");
+const tryGetTransport = (transports, name) => transports.find(t => t.name === name);
+const getOrCreateTransport = (transports, transportType, params) => {
+    if (typeof transportType === 'string') {
+        const existing = tryGetTransport(transports, transportType);
+        if (existing)
+            return existing;
+        switch (transportType) {
+            case 'WebUsbTransport':
+                return new transport_1.WebUsbTransport(params);
+            case 'NodeUsbTransport':
+                return new transport_1.NodeUsbTransport(params);
+            case 'BridgeTransport':
+                return new transport_1.BridgeTransport({
+                    latestVersion: (0, transportInfo_1.getBridgeInfo)().version.join('.'),
+                    ...params,
+                });
+            case 'UdpTransport':
+                return new transport_1.UdpTransport(params);
+        }
+    }
+    else if (typeof transportType === 'function' && 'prototype' in transportType) {
+        const transportInstance = new transportType(params);
+        if ((0, transport_1.isTransportInstance)(transportInstance)) {
+            return tryGetTransport(transports, transportInstance.name) ?? transportInstance;
+        }
+    }
+    else if ((0, transport_1.isTransportInstance)(transportType)) {
+        if (tryGetTransport(transports, transportType.name)) {
+            return transportType;
+        }
+        if (!transportType.getMessage()) {
+            transportType.updateMessages(params.messages);
+        }
+        return transportType;
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
+};
+const createTransports = (existing, transports = [], params) => {
+    const transportTypes = transports?.length ? transports : ['BridgeTransport'];
+    return transportTypes.map(type => getOrCreateTransport(existing, type, params));
+};
+const createTransportList = (params) => (existing, transports) => createTransports(existing, transports, params);
+exports.createTransportList = createTransportList;
+//# sourceMappingURL=TransportList.js.map

package/lib/device/TransportManager.d.ts

@@ -0,0 +1,34 @@
+import { TRANSPORT, Transport } from '@trezor/transport';
+import { TypedEmitter } from '@trezor/utils';
+type TransportManagerEvents = {
+    [TRANSPORT.START]: Transport;
+    [TRANSPORT.ERROR]: string;
+};
+type TransportManagerParams = {
+    startTransport: (transport: Transport, pendingTransportEvent: boolean, signal: AbortSignal) => Promise<void>;
+    stopTransport: (transport: Transport) => Promise<void>;
+};
+type InitParams = {
+    transports: Transport[];
+    transportReconnect?: boolean;
+    pendingTransportEvent?: boolean;
+};
+export declare class TransportManager extends TypedEmitter<TransportManagerEvents> {
+    private lock;
+    private transports;
+    private activeTransport?;
+    private transportReconnect;
+    private upgradeTimeout?;
+    private readonly startTransport;
+    private readonly stopTransport;
+    constructor({ startTransport, stopTransport }: TransportManagerParams);
+    pending(): Promise<void> | undefined;
+    get(): Transport | undefined;
+    init({ transports, transportReconnect, pendingTransportEvent }: InitParams): Promise<void>;
+    dispose(): Promise<void>;
+    private selectTransport;
+    private scheduleUpgradeCheck;
+    private createInitPromise;
+}
+export {};
+//# sourceMappingURL=TransportManager.d.ts.map

package/lib/device/TransportManager.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportManager = void 0;
+const transport_1 = require("@trezor/transport");
+const utils_1 = require("@trezor/utils");
+const createOverrideLock = () => {
+    let promise;
+    let sequence = 0;
+    let abort;
+    let message;
+    const override = async (abortMessage, action) => {
+        message = abortMessage;
+        const seq = ++sequence;
+        while (promise) {
+            abort?.abort(new Error(abortMessage));
+            await promise.catch(() => { });
+        }
+        if (seq !== sequence)
+            return Promise.reject(new Error(message));
+        abort = new AbortController();
+        promise = action(abort.signal).finally(() => {
+            abort = undefined;
+            promise = undefined;
+        });
+        return promise;
+    };
+    const getPending = () => promise;
+    return { override, getPending };
+};
+class TransportManager extends utils_1.TypedEmitter {
+    lock = createOverrideLock();
+    transports = [];
+    activeTransport;
+    transportReconnect = false;
+    upgradeTimeout;
+    startTransport;
+    stopTransport;
+    constructor({ startTransport, stopTransport }) {
+        super();
+        this.startTransport = startTransport;
+        this.stopTransport = stopTransport;
+    }
+    pending() {
+        return this.lock.getPending();
+    }
+    get() {
+        return this.activeTransport;
+    }
+    init({ transports, transportReconnect = false, pendingTransportEvent = false }) {
+        this.transports = transports;
+        this.transportReconnect = transportReconnect;
+        return this.lock.override('New init', signal => this.createInitPromise(pendingTransportEvent, signal));
+    }
+    dispose() {
+        this.removeAllListeners();
+        return this.lock.override('Disposing', async () => {
+            const { activeTransport } = this;
+            if (activeTransport) {
+                clearTimeout(this.upgradeTimeout);
+                delete this.activeTransport;
+                await this.stopTransport(activeTransport);
+            }
+        });
+    }
+    async selectTransport([transport, ...rest], signal) {
+        if (signal.aborted)
+            throw new Error(signal.reason);
+        if (transport === this.activeTransport)
+            return transport;
+        const result = await transport.init({ signal });
+        if (result.success)
+            return transport;
+        else if (rest.length)
+            return this.selectTransport(rest, signal);
+        else
+            throw new Error(result.error);
+    }
+    scheduleUpgradeCheck(pendingTransportEvent) {
+        clearTimeout(this.upgradeTimeout);
+        this.upgradeTimeout = setTimeout(async () => {
+            if (!this.activeTransport || this.activeTransport === this.transports[0])
+                return;
+            for (const t of this.transports) {
+                if (t === this.activeTransport)
+                    break;
+                if (await t.ping()) {
+                    this.lock
+                        .override('Upgrading', signal => this.createInitPromise(pendingTransportEvent, signal))
+                        .catch(() => { });
+                    return;
+                }
+            }
+            this.scheduleUpgradeCheck(pendingTransportEvent);
+        }, 1000);
+    }
+    async createInitPromise(pendingTransportEvent, abortSignal) {
+        try {
+            const { transports, activeTransport } = this;
+            const transport = transports.length
+                ? await this.selectTransport(transports, abortSignal)
+                : undefined;
+            if (activeTransport !== transport) {
+                if (activeTransport) {
+                    clearTimeout(this.upgradeTimeout);
+                    delete this.activeTransport;
+                    await this.stopTransport(activeTransport);
+                }
+                if (transport) {
+                    await this.startTransport(transport, pendingTransportEvent, abortSignal);
+                    transport.on(transport_1.TRANSPORT.ERROR, error => {
+                        this.emit(transport_1.TRANSPORT.ERROR, error);
+                        clearTimeout(this.upgradeTimeout);
+                        this.lock
+                            .override('Transport error', async (signal) => {
+                            delete this.activeTransport;
+                            await this.stopTransport(transport);
+                            if (this.transportReconnect) {
+                                await (0, utils_1.resolveAfter)(1000, signal);
+                                await this.createInitPromise(pendingTransportEvent, signal);
+                            }
+                        })
+                            .catch(() => { });
+                    });
+                    this.activeTransport = transport;
+                    this.emit(transport_1.TRANSPORT.START, transport);
+                }
+                else {
+                    this.emit(transport_1.TRANSPORT.ERROR, 'Transport disabled');
+                }
+            }
+            if (transport && transport !== transports[0]) {
+                this.scheduleUpgradeCheck(pendingTransportEvent);
+            }
+        }
+        catch (error) {
+            this.emit(transport_1.TRANSPORT.ERROR, error?.message);
+            if (this.transportReconnect && !abortSignal.aborted) {
+                this.lock
+                    .override('Reconnecting', async (signal) => {
+                    await (0, utils_1.resolveAfter)(1000, signal);
+                    await this.createInitPromise(pendingTransportEvent, signal);
+                })
+                    .catch(() => { });
+            }
+        }
+    }
+}
+exports.TransportManager = TransportManager;
+//# sourceMappingURL=TransportManager.js.map

package/lib/device/checkFirmwareRevision.js

@@ -4,12 +4,14 @@ exports.checkFirmwareRevision = void 0;
 const versionUtils_1 = require("@trezor/utils/lib/versionUtils");
 const downloadReleasesMetadata_1 = require("../data/downloadReleasesMetadata");
 const calculateRevisionForDevice_1 = require("./calculateRevisionForDevice");
-const isNodeJSNetworkError = (e) => ['FetchError', 'AbortError'].includes(e.name);
-const isReactNativeNetworkError = (e) => e.name === 'TypeError' && e.message.includes('Network request failed');
-const isNetworkError = (e) => {
+const assets_browser_1 = require("../utils/assets-browser");
+const isNotFoundError = (e) => e instanceof assets_browser_1.HttpRequestError && e.response.status === 404;
+const isNodeJSOfflineError = (e) => ['FetchError', 'AbortError'].includes(e.name);
+const isReactNativeOfflineError = (e) => e.name === 'TypeError' && e.message.includes('Network request failed');
+const isOfflineError = (e) => {
     if (!(e instanceof Error))
         return false;
-    return isNodeJSNetworkError(e) || isReactNativeNetworkError(e);
+    return isNodeJSOfflineError(e) || isReactNativeOfflineError(e);
 };
 const getOnlineReleaseMetadata = async ({ firmwareVersion, internalModel, }) => {
     const onlineReleases = await (0, downloadReleasesMetadata_1.downloadReleasesMetadata)({ internal_model: internalModel });
@@ -49,7 +51,9 @@ const checkFirmwareRevision = async ({ firmwareVersion, internalModel, deviceRev
             return { success: true };
         }
         catch (e) {
-            return isNetworkError(e)
+            if (isNotFoundError(e))
+                return failFirmwareRevisionCheck('firmware-version-unknown');
+            return isOfflineError(e)
                 ? failFirmwareRevisionCheck('cannot-perform-check-offline')
                 : failFirmwareRevisionCheck('other-error');
         }

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

@@ -71,8 +71,7 @@ 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">]>>;
+        newAccountProgramName: 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;

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

@@ -51,8 +51,7 @@ exports.SolanaComposeTransaction = schema_utils_1.Type.Object({
 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),
+        newAccountProgramName: schema_utils_1.Type.Optional(exports.SolanaProgramName),
         tokenAccountInfo: schema_utils_1.Type.Optional(exports.SolanaTxTokenAccountInfo),
     }),
 });

package/lib/types/coinInfo.d.ts

@@ -68,6 +68,12 @@ export declare const BitcoinNetworkInfo: import("@trezor/schema-utils").TInterse
         blocks: import("@trezor/schema-utils").TNumber;
         feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
         feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        baseFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        effectiveGasPrice: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxPriorityFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+        minWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
     }>>;
 }>, import("@trezor/schema-utils").TObject<{
     type: import("@trezor/schema-utils").TLiteral<"bitcoin">;
@@ -129,6 +135,12 @@ export declare const EthereumNetworkInfo: import("@trezor/schema-utils").TInters
         blocks: import("@trezor/schema-utils").TNumber;
         feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
         feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        baseFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        effectiveGasPrice: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxPriorityFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+        minWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
     }>>;
 }>, import("@trezor/schema-utils").TObject<{
     type: import("@trezor/schema-utils").TLiteral<"ethereum">;
@@ -191,6 +203,12 @@ export declare const MiscNetworkInfo: import("@trezor/schema-utils").TIntersect<
         blocks: import("@trezor/schema-utils").TNumber;
         feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
         feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        baseFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        effectiveGasPrice: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxPriorityFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+        minWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
     }>>;
 }>, import("@trezor/schema-utils").TObject<{
     type: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"misc">, import("@trezor/schema-utils").TLiteral<"nem">]>;
@@ -227,6 +245,12 @@ export declare const CoinInfo: import("@trezor/schema-utils").TUnion<[import("@t
         blocks: import("@trezor/schema-utils").TNumber;
         feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
         feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        baseFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        effectiveGasPrice: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxPriorityFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+        minWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
     }>>;
 }>, import("@trezor/schema-utils").TObject<{
     type: import("@trezor/schema-utils").TLiteral<"bitcoin">;
@@ -286,6 +310,12 @@ export declare const CoinInfo: import("@trezor/schema-utils").TUnion<[import("@t
         blocks: import("@trezor/schema-utils").TNumber;
         feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
         feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        baseFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        effectiveGasPrice: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxPriorityFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+        minWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
     }>>;
 }>, import("@trezor/schema-utils").TObject<{
     type: import("@trezor/schema-utils").TLiteral<"ethereum">;
@@ -320,6 +350,12 @@ export declare const CoinInfo: import("@trezor/schema-utils").TUnion<[import("@t
         blocks: import("@trezor/schema-utils").TNumber;
         feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
         feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        baseFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        effectiveGasPrice: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxPriorityFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        maxWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+        minWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
     }>>;
 }>, import("@trezor/schema-utils").TObject<{
     type: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"misc">, import("@trezor/schema-utils").TLiteral<"nem">]>;

package/lib/types/device.d.ts

@@ -44,6 +44,9 @@ type BaseDevice = {
     path: DeviceUniquePath;
     name: string;
 };
+export type BluetoothDeviceProps = {
+    id: string;
+};
 export type KnownDevice = BaseDevice & {
     type: 'acquired';
     id: string | null;
@@ -66,6 +69,7 @@ export type KnownDevice = BaseDevice & {
     };
     transportSessionOwner?: undefined;
     transportDescriptorType?: typeof undefined;
+    bluetoothProps?: BluetoothDeviceProps;
 };
 export type UnknownDevice = BaseDevice & {
     type: 'unacquired';
@@ -85,6 +89,7 @@ export type UnknownDevice = BaseDevice & {
     availableTranslations?: typeof undefined;
     transportSessionOwner?: string;
     transportDescriptorType?: typeof undefined;
+    bluetoothProps?: BluetoothDeviceProps;
 };
 export type UnreadableDevice = BaseDevice & {
     type: 'unreadable';
@@ -104,6 +109,7 @@ export type UnreadableDevice = BaseDevice & {
     availableTranslations?: typeof undefined;
     transportSessionOwner?: undefined;
     transportDescriptorType: Descriptor['type'];
+    bluetoothProps?: BluetoothDeviceProps;
 };
 export type Device = KnownDevice | UnknownDevice | UnreadableDevice;
 export type Features = PROTO.Features;

package/lib/types/fees.d.ts

@@ -6,6 +6,13 @@ export declare const FeeInfo: import("@trezor/schema-utils").TObject<{
     maxFee: import("@trezor/schema-utils").TNumber;
     dustLimit: import("@trezor/schema-utils").TNumber;
 }>;
+export type PriorityFeeEstimationDetails = Static<typeof PriorityFeeEstimationDetails>;
+export declare const PriorityFeeEstimationDetails: import("@trezor/schema-utils").TObject<{
+    maxFeePerGas: import("@trezor/schema-utils").TString;
+    maxPriorityFeePerGas: import("@trezor/schema-utils").TString;
+    maxWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+    minWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+}>;
 export type FeeLevel = Static<typeof FeeLevel>;
 export declare const FeeLevel: import("@trezor/schema-utils").TObject<{
     label: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<"high">, import("@trezor/schema-utils").TLiteral<"normal">, import("@trezor/schema-utils").TLiteral<"economy">, import("@trezor/schema-utils").TLiteral<"low">, import("@trezor/schema-utils").TLiteral<"custom">]>;
@@ -13,6 +20,12 @@ export declare const FeeLevel: import("@trezor/schema-utils").TObject<{
     blocks: import("@trezor/schema-utils").TNumber;
     feeLimit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
     feePerTx: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    baseFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    maxFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    effectiveGasPrice: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    maxPriorityFeePerGas: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+    maxWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+    minWaitTimeEstimate: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
 }>;
 export type SelectFeeLevel = Static<typeof SelectFeeLevel>;
 export declare const SelectFeeLevel: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TObject<{

package/lib/types/fees.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelectFeeLevel = exports.FeeLevel = exports.FeeInfo = void 0;
+exports.SelectFeeLevel = exports.FeeLevel = exports.PriorityFeeEstimationDetails = exports.FeeInfo = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
 exports.FeeInfo = schema_utils_1.Type.Object({
     blockTime: schema_utils_1.Type.Number(),
@@ -8,6 +8,12 @@ exports.FeeInfo = schema_utils_1.Type.Object({
     maxFee: schema_utils_1.Type.Number(),
     dustLimit: schema_utils_1.Type.Number(),
 });
+exports.PriorityFeeEstimationDetails = schema_utils_1.Type.Object({
+    maxFeePerGas: schema_utils_1.Type.String(),
+    maxPriorityFeePerGas: schema_utils_1.Type.String(),
+    maxWaitTimeEstimate: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    minWaitTimeEstimate: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+});
 exports.FeeLevel = schema_utils_1.Type.Object({
     label: schema_utils_1.Type.Union([
         schema_utils_1.Type.Literal('high'),
@@ -20,6 +26,12 @@ exports.FeeLevel = schema_utils_1.Type.Object({
     blocks: schema_utils_1.Type.Number(),
     feeLimit: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
     feePerTx: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    baseFeePerGas: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    maxFeePerGas: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    effectiveGasPrice: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    maxPriorityFeePerGas: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    maxWaitTimeEstimate: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    minWaitTimeEstimate: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
 });
 exports.SelectFeeLevel = schema_utils_1.Type.Union([
     schema_utils_1.Type.Object({

package/lib/types/settings.d.ts

@@ -7,13 +7,14 @@ export interface Manifest {
 }
 export type Proxy = BlockchainSettings['proxy'];
 type KnownTransport = Exclude<Transport['name'], 'NativeUsbTransport' | 'BluetoothTransport'>;
+export type ConnectSettingsTransport = KnownTransport | Transport | (new (...args: any[]) => Transport);
 export interface ConnectSettingsPublic {
     manifest?: Manifest;
     connectSrc?: string;
     debug?: boolean;
     popup?: boolean;
     transportReconnect?: boolean;
-    transports?: (KnownTransport | Transport | (new (...args: any[]) => Transport))[];
+    transports?: ConnectSettingsTransport[];
     pendingTransportEvent?: boolean;
     lazyLoad?: boolean;
     interactionTimeout?: number;
@@ -29,6 +30,7 @@ export interface ConnectSettingsInternal {
     popupSrc: string;
     webusbSrc: string;
     version: string;
+    npmVersion?: string;
     priority: number;
     extension?: string;
     env: 'node' | 'web' | 'webextension' | 'electron' | 'react-native';

package/lib/types/utils.d.ts

@@ -12,5 +12,4 @@ export type MessageFactoryFn<Group, Event> = UnionToIntersection<Event extends {
     type: Event['type'];
     payload: undefined;
 } : never>;
-export declare const typedObjectKeys: <T extends Record<any, any>>(obj: T) => Array<keyof T>;
 //# sourceMappingURL=utils.d.ts.map

package/lib/types/utils.js

@@ -1,6 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typedObjectKeys = void 0;
-const typedObjectKeys = (obj) => Object.keys(obj);
-exports.typedObjectKeys = typedObjectKeys;
 //# sourceMappingURL=utils.js.map

package/lib/utils/assets-browser.d.ts

@@ -1,3 +1,7 @@
 import { HttpRequestOptions, HttpRequestReturnType, HttpRequestType } from './assetsTypes';
+export declare class HttpRequestError extends Error {
+    response: Response;
+    constructor(response: Response);
+}
 export declare const httpRequest: <T extends HttpRequestType>(url: string, type?: T, options?: HttpRequestOptions) => Promise<HttpRequestReturnType<T>>;
 //# sourceMappingURL=assets-browser.d.ts.map

package/lib/utils/assets-browser.js

@@ -1,8 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.httpRequest = void 0;
+exports.httpRequest = exports.HttpRequestError = void 0;
 const tslib_1 = require("tslib");
 const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
+class HttpRequestError extends Error {
+    response;
+    constructor(response) {
+        const message = `${response.status} while fetching ${response.url}`;
+        super(message);
+        this.response = response;
+    }
+}
+exports.HttpRequestError = HttpRequestError;
 const httpRequest = async (url, type = 'text', options) => {
     const init = { ...options, credentials: 'same-origin' };
     const response = await (0, cross_fetch_1.default)(url, init);
@@ -16,7 +25,7 @@ const httpRequest = async (url, type = 'text', options) => {
         }
         return response.text();
     }
-    throw new Error(`httpRequest error: ${url} ${response.statusText}`);
+    throw new HttpRequestError(response);
 };
 exports.httpRequest = httpRequest;
 //# sourceMappingURL=assets-browser.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.5.0",
+  "version": "9.5.1-beta.1",
   "author": "Trezor <info@trezor.io>",
   "homepage": "https://github.com/trezor/trezor-suite/tree/develop/packages/connect",
   "description": "High-level javascript interface for Trezor hardware wallet.",
@@ -68,7 +68,6 @@
     "prepublish": "yarn tsx ../../scripts/prepublish.js"
   },
   "dependencies": {
-    "@babel/preset-typescript": "^7.24.7",
     "@ethereumjs/common": "^4.4.0",
     "@ethereumjs/tx": "^5.4.0",
     "@fivebinaries/coin-selection": "3.0.0",
@@ -80,24 +79,25 @@
     "@solana-program/token": "^0.4.1",
     "@solana-program/token-2022": "^0.3.4",
     "@solana/web3.js": "^2.0.0",
-    "@trezor/blockchain-link": "2.4.0",
-    "@trezor/blockchain-link-types": "1.3.0",
-    "@trezor/blockchain-link-utils": "1.3.0",
+    "@trezor/blockchain-link": "2.4.1-beta.1",
+    "@trezor/blockchain-link-types": "1.3.1-beta.1",
+    "@trezor/blockchain-link-utils": "1.3.1-beta.1",
     "@trezor/connect-analytics": "1.3.0",
-    "@trezor/connect-common": "0.3.0",
-    "@trezor/crypto-utils": "1.1.0",
-    "@trezor/protobuf": "1.3.0",
-    "@trezor/protocol": "1.2.2",
-    "@trezor/schema-utils": "1.3.0",
-    "@trezor/transport": "1.4.0",
-    "@trezor/utils": "9.3.0",
-    "@trezor/utxo-lib": "2.3.0",
+    "@trezor/connect-common": "0.3.1-beta.1",
+    "@trezor/crypto-utils": "1.1.1-beta.1",
+    "@trezor/protobuf": "1.3.1-beta.1",
+    "@trezor/protocol": "1.2.3-beta.1",
+    "@trezor/schema-utils": "1.3.1-beta.1",
+    "@trezor/transport": "1.4.1-beta.1",
+    "@trezor/utils": "9.3.1-beta.1",
+    "@trezor/utxo-lib": "2.3.1-beta.1",
     "blakejs": "^1.2.1",
     "bs58": "^6.0.0",
     "bs58check": "^4.0.0",
     "cross-fetch": "^4.0.0"
   },
   "devDependencies": {
+    "@babel/preset-typescript": "^7.24.7",
     "@trezor/eslint": "1.0.0",
     "@trezor/trezor-user-env-link": "1.0.2",
     "@types/karma": "^6.3.9",
@@ -112,8 +112,8 @@
     "karma-webpack": "^5.0.1",
     "node-fetch": "^2.6.4",
     "node-libs-browser": "^2.2.1",
-    "ts-node": "^10.9.1",
-    "tsx": "^4.16.3",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.19.3",
     "web3-utils": "^4.3.2",
     "webpack": "^5.97.1",
     "ws": "^8.18.0"