@trezor/connect 9.4.7 → 9.4.8-beta.2

package/lib/types/coinInfo.d.ts

@@ -31,6 +31,7 @@ export declare const CoinSupport: import("@trezor/schema-utils").TObject<{
     T3B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
     T3T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
     T3W1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+    UNKNOWN: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
 }>;
 export type BlockchainLink = Static<typeof BlockchainLink>;
 export declare const BlockchainLink: import("@trezor/schema-utils").TObject<{
@@ -51,6 +52,7 @@ export declare const BitcoinNetworkInfo: import("@trezor/schema-utils").TInterse
         T3B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3W1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        UNKNOWN: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
     }>;
     decimals: import("@trezor/schema-utils").TNumber;
     blockchainLink: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
@@ -111,6 +113,7 @@ export declare const EthereumNetworkInfo: import("@trezor/schema-utils").TInters
         T3B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3W1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        UNKNOWN: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
     }>;
     decimals: import("@trezor/schema-utils").TNumber;
     blockchainLink: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
@@ -132,6 +135,32 @@ export declare const EthereumNetworkInfo: import("@trezor/schema-utils").TInters
     chainId: import("@trezor/schema-utils").TNumber;
     network: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
 }>]>;
+export type EthereumNetworkInfoDefinitionValues = Static<typeof EthereumNetworkInfoDefinitionValues>;
+export declare const EthereumNetworkInfoDefinitionValues: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
+    label: import("@trezor/schema-utils").TString;
+    name: import("@trezor/schema-utils").TString;
+    shortcut: import("@trezor/schema-utils").TString;
+    slip44: import("@trezor/schema-utils").TNumber;
+    support: import("@trezor/schema-utils").TObject<{
+        connect: import("@trezor/schema-utils").TBoolean;
+        T1B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        T2T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        T2B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        T3B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        T3T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        T3W1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        UNKNOWN: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+    }>;
+    decimals: import("@trezor/schema-utils").TNumber;
+    blockchainLink: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+        type: import("@trezor/schema-utils").TString;
+        url: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
+    }>>;
+}>, import("@trezor/schema-utils").TObject<{
+    type: import("@trezor/schema-utils").TLiteral<"ethereum">;
+    network: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
+    chainId: import("@trezor/schema-utils").TNumber;
+}>]>;
 export type MiscNetworkInfo = Static<typeof MiscNetworkInfo>;
 export declare const MiscNetworkInfo: import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
     label: import("@trezor/schema-utils").TString;
@@ -146,6 +175,7 @@ export declare const MiscNetworkInfo: import("@trezor/schema-utils").TIntersect<
         T3B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3W1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        UNKNOWN: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
     }>;
     decimals: import("@trezor/schema-utils").TNumber;
     blockchainLink: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
@@ -181,6 +211,7 @@ export declare const CoinInfo: import("@trezor/schema-utils").TUnion<[import("@t
         T3B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3W1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        UNKNOWN: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
     }>;
     decimals: import("@trezor/schema-utils").TNumber;
     blockchainLink: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
@@ -239,6 +270,7 @@ export declare const CoinInfo: import("@trezor/schema-utils").TUnion<[import("@t
         T3B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3W1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        UNKNOWN: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
     }>;
     decimals: import("@trezor/schema-utils").TNumber;
     blockchainLink: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
@@ -272,6 +304,7 @@ export declare const CoinInfo: import("@trezor/schema-utils").TUnion<[import("@t
         T3B1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3T1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
         T3W1: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
+        UNKNOWN: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TLiteral<false>]>;
     }>;
     decimals: import("@trezor/schema-utils").TNumber;
     blockchainLink: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{

package/lib/types/coinInfo.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoinInfo = exports.MiscNetworkInfo = exports.EthereumNetworkInfo = exports.BitcoinNetworkInfo = exports.BlockchainLink = exports.CoinSupport = exports.CoinObj = exports.Network = exports.Bip32 = void 0;
+exports.CoinInfo = exports.MiscNetworkInfo = exports.EthereumNetworkInfoDefinitionValues = exports.EthereumNetworkInfo = exports.BitcoinNetworkInfo = exports.BlockchainLink = exports.CoinSupport = exports.CoinObj = exports.Network = exports.Bip32 = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
-const fees_1 = require("./fees");
 const device_1 = require("./device");
+const fees_1 = require("./fees");
 exports.Bip32 = schema_utils_1.Type.Object({
     public: schema_utils_1.Type.Number(),
     private: schema_utils_1.Type.Number(),
@@ -74,6 +74,12 @@ exports.EthereumNetworkInfo = schema_utils_1.Type.Intersect([
         network: schema_utils_1.Type.Optional(schema_utils_1.Type.Undefined()),
     }),
 ]);
+exports.EthereumNetworkInfoDefinitionValues = schema_utils_1.Type.Omit(exports.EthereumNetworkInfo, [
+    'minFee',
+    'maxFee',
+    'defaultFees',
+    'blockTime',
+]);
 exports.MiscNetworkInfo = schema_utils_1.Type.Intersect([
     Common,
     schema_utils_1.Type.Object({

package/lib/types/params.d.ts

@@ -1,4 +1,4 @@
-import { TSchema, Static } from '@trezor/schema-utils';
+import { Static, TSchema } from '@trezor/schema-utils';
 import { DeviceState, DeviceUniquePath } from './device';
 import { ErrorCode } from '../constants/errors';
 export interface DeviceIdentity {

package/lib/utils/abortablePromise.d.ts

@@ -0,0 +1,5 @@
+export declare const abortablePromise: <T = void>(signal: AbortSignal) => {
+    promise: Promise<T>;
+    resolve: (t: T) => void;
+};
+//# sourceMappingURL=abortablePromise.d.ts.map

package/lib/utils/abortablePromise.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortablePromise = void 0;
+const utils_1 = require("@trezor/utils");
+const abortablePromise = (signal) => {
+    const { promise, reject, resolve } = (0, utils_1.createDeferred)();
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener('abort', onAbort);
+    if (signal.aborted)
+        onAbort();
+    return {
+        promise: promise.finally(() => signal.removeEventListener('abort', onAbort)),
+        resolve,
+    };
+};
+exports.abortablePromise = abortablePromise;
+//# sourceMappingURL=abortablePromise.js.map

package/lib/utils/accountUtils.d.ts

@@ -1,4 +1,4 @@
-import type { CoinInfo, BitcoinNetworkInfo } from '../types';
+import type { BitcoinNetworkInfo, CoinInfo } from '../types';
 type Bip44Options = {
     purpose?: number;
     coinType?: number;

package/lib/utils/accountUtils.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isUtxoBased = exports.getPublicKeyLabel = exports.getAccountLabel = exports.getAccountAddressN = void 0;
 const pathUtils_1 = require("./pathUtils");
-const coinInfo_1 = require("../data/coinInfo");
 const constants_1 = require("../constants");
+const coinInfo_1 = require("../data/coinInfo");
 const getAccountAddressN = (coinInfo, accountIndex, bip44) => {
     if (!coinInfo) {
         throw constants_1.ERRORS.TypedError('Method_UnknownCoin');

package/lib/utils/assetUtils.js

@@ -5,6 +5,7 @@ const utils_1 = require("@trezor/utils");
 const types_1 = require("../types");
 const isDeviceModel = (model) => (0, utils_1.isArrayMember)(model, Object.values(types_1.DeviceModelInternal));
 exports.firmwareAssets = {
+    [types_1.DeviceModelInternal.UNKNOWN]: {},
     [types_1.DeviceModelInternal.T1B1]: require('@trezor/connect-common/files/firmware/t1b1/releases.json'),
     [types_1.DeviceModelInternal.T2T1]: require('@trezor/connect-common/files/firmware/t2t1/releases.json'),
     [types_1.DeviceModelInternal.T2B1]: require('@trezor/connect-common/files/firmware/t2b1/releases.json'),
@@ -19,8 +20,6 @@ const tryLocalAssetRequire = (url) => {
             return require('@trezor/connect-common/files/coins.json');
         case './data/coins-eth.json':
             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/messages/messages.json':
             return require('@trezor/protobuf/messages.json');
     }

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

@@ -1,3 +1,3 @@
-import { HttpRequestType, HttpRequestReturnType, HttpRequestOptions } from './assetsTypes';
+import { HttpRequestOptions, HttpRequestReturnType, HttpRequestType } from './assetsTypes';
 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.js

@@ -4,8 +4,8 @@ exports.httpRequest = httpRequest;
 const tslib_1 = require("tslib");
 const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
 const fs_1 = require("fs");
-const assets_browser_1 = require("./assets-browser");
 const assetUtils_1 = require("./assetUtils");
+const assets_browser_1 = require("./assets-browser");
 if (global && typeof global.fetch !== 'function') {
     global.fetch = cross_fetch_1.default;
 }

package/lib/utils/assets.native.d.ts

@@ -1,3 +1,3 @@
-import { HttpRequestType, HttpRequestReturnType, HttpRequestOptions } from './assetsTypes';
+import { HttpRequestOptions, HttpRequestReturnType, HttpRequestType } from './assetsTypes';
 export declare function httpRequest<T extends HttpRequestType>(url: string, type: T, options?: HttpRequestOptions): Promise<HttpRequestReturnType<T>>;
 //# sourceMappingURL=assets.native.d.ts.map

package/lib/utils/deviceFeaturesUtils.d.ts

@@ -1,5 +1,5 @@
 import { PROTO } from '../constants';
-import { Features, CoinInfo, UnavailableCapabilities, DeviceModelInternal } from '../types';
+import { CoinInfo, DeviceModelInternal, Features, UnavailableCapabilities } from '../types';
 export declare const parseCapabilities: (features?: Features) => PROTO.Capability[];
 export declare const getUnavailableCapabilities: (features: Features, coins: CoinInfo[]) => UnavailableCapabilities;
 export declare const parseRevision: (features: Features) => string | null;

package/lib/utils/deviceFeaturesUtils.js

@@ -44,22 +44,15 @@ const getUnavailableCapabilities = (features, coins) => {
         return list;
     const fw = [features.major_version, features.minor_version, features.patch_version].join('.');
     const key = features.internal_model;
-    const duplicatedShortcuts = ['bnb'];
     const supported = coins.filter(info => {
         if (!info.support || info.support[key] === false) {
             const shortcut = info.shortcut.toLowerCase();
-            if (!duplicatedShortcuts.includes(shortcut)) {
+            const occurrences = coins.filter(coin => shortcut == coin.shortcut.toLowerCase());
+            const allUnsupported = occurrences.every(info2 => !info2.support || info2.support[key] === false);
+            if (allUnsupported) {
                 list[shortcut] = 'no-support';
-                return false;
-            }
-            else {
-                const occurrences = coins.filter(coin => shortcut == coin.shortcut.toLowerCase());
-                const allUnsupported = occurrences.every(info2 => !info2.support || info2.support[key] === false);
-                if (allUnsupported) {
-                    list[shortcut] = 'no-support';
-                }
-                return false;
             }
+            return false;
         }
         return true;
     });
@@ -137,8 +130,9 @@ const ensureInternalModelFeature = (model) => {
         case 'T':
             return types_1.DeviceModelInternal.T2T1;
         case '1':
-        default:
             return types_1.DeviceModelInternal.T1B1;
+        default:
+            return types_1.DeviceModelInternal.UNKNOWN;
     }
 };
 exports.ensureInternalModelFeature = ensureInternalModelFeature;

package/lib/utils/ethereumUtils.d.ts

@@ -1,3 +1,4 @@
-import type { CoinInfo } from '../types';
-export declare const getNetworkLabel: (label: string, network?: CoinInfo) => string;
+export declare const getNetworkLabel: (label: string, network?: {
+    name: string;
+}) => string;
 //# sourceMappingURL=ethereumUtils.d.ts.map

package/lib/utils/firmwareUtils.d.ts

@@ -1,4 +1,4 @@
-import type { Features, StrictFeatures, FirmwareRelease, VersionArray } from '../types';
+import type { Features, FirmwareRelease, StrictFeatures, VersionArray } from '../types';
 export declare const isStrictFeatures: (extFeatures: Features) => extFeatures is StrictFeatures;
 export declare const isValidReleases: (extReleases: any) => extReleases is FirmwareRelease[];
 export declare const filterSafeListByBootloader: (releasesList: FirmwareRelease[], bootloaderVersion: VersionArray) => FirmwareRelease[];

package/lib/utils/firmwareUtils.js

@@ -10,10 +10,17 @@ exports.isStrictFeatures = isStrictFeatures;
 const isValidReleases = (extReleases) => Array.isArray(extReleases) &&
     extReleases.every(release => release.version && release.min_firmware_version && release.min_bootloader_version);
 exports.isValidReleases = isValidReleases;
-const filterSafeListByBootloader = (releasesList, bootloaderVersion) => releasesList.filter(item => (!item.min_bootloader_version ||
-    utils_1.versionUtils.isNewerOrEqual(bootloaderVersion, item.min_bootloader_version)) &&
-    (!item.bootloader_version ||
-        utils_1.versionUtils.isNewerOrEqual(item.bootloader_version, bootloaderVersion)));
+const filterSafeListByBootloader = (releasesList, bootloaderVersion) => {
+    const bootloaderVersions = releasesList.flatMap(item => item.bootloader_version ? [item.bootloader_version] : []);
+    const compatibleRelease = bootloaderVersions.find(item => utils_1.versionUtils.isNewerOrEqual(item, bootloaderVersion));
+    if (bootloaderVersions.length > 0 && !compatibleRelease) {
+        return [];
+    }
+    return releasesList.filter(item => (!item.min_bootloader_version ||
+        utils_1.versionUtils.isNewerOrEqual(bootloaderVersion, item.min_bootloader_version)) &&
+        (!item.bootloader_version ||
+            utils_1.versionUtils.isNewerOrEqual(item.bootloader_version, bootloaderVersion)));
+};
 exports.filterSafeListByBootloader = filterSafeListByBootloader;
 const filterSafeListByFirmware = (releasesList, firmwareVersion) => releasesList.filter(item => utils_1.versionUtils.isNewerOrEqual(firmwareVersion, item.min_firmware_version));
 exports.filterSafeListByFirmware = filterSafeListByFirmware;

package/lib/utils/pathUtils.d.ts

@@ -1,5 +1,5 @@
 import { PROTO } from '../constants';
-import type { CoinInfo, DerivationPath, ProtoWithDerivationPath, ProtoWithAddressN } from '../types';
+import type { CoinInfo, DerivationPath, ProtoWithAddressN, ProtoWithDerivationPath } from '../types';
 export declare const HD_HARDENED = 2147483648;
 export declare const toHardened: (n: number) => number;
 export declare const fromHardened: (n: number) => number;

package/lib/utils/urlUtils.js

@@ -19,6 +19,8 @@ const getHost = (url) => {
     const [, , uri] = (_a = url.match(/^(https?):\/\/([^:/]+)?/i)) !== null && _a !== void 0 ? _a : [];
     if (uri) {
         const parts = uri.split('.');
+        if (parts[parts.length - 1] === 'localhost')
+            return 'localhost';
         return parts.length > 2
             ?
                 parts.slice(parts.length - 2, parts.length).join('.')

package/lib/workers/workers-browser.d.ts

@@ -1,7 +1,7 @@
+import type { BaseWorker } from '@trezor/blockchain-link/lib/workers/baseWorker';
 import BlockbookWorker from '@trezor/blockchain-link/lib/workers/blockbook';
-import RippleWorker from '@trezor/blockchain-link/lib/workers/ripple';
 import BlockfrostWorker from '@trezor/blockchain-link/lib/workers/blockfrost';
-import type { BaseWorker } from '@trezor/blockchain-link/lib/workers/baseWorker';
+import RippleWorker from '@trezor/blockchain-link/lib/workers/ripple';
 type WorkerAsyncImporter = () => Promise<BaseWorker<unknown>>;
 declare const SolanaWorker: WorkerAsyncImporter;
 declare const ElectrumWorker: undefined;

package/lib/workers/workers-browser.js

@@ -4,10 +4,10 @@ exports.SolanaWorker = exports.ElectrumWorker = exports.BlockfrostWorker = expor
 const tslib_1 = require("tslib");
 const blockbook_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/blockbook"));
 exports.BlockbookWorker = blockbook_1.default;
-const ripple_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/ripple"));
-exports.RippleWorker = ripple_1.default;
 const blockfrost_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/blockfrost"));
 exports.BlockfrostWorker = blockfrost_1.default;
+const ripple_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/ripple"));
+exports.RippleWorker = ripple_1.default;
 const SolanaWorker = () => Promise.resolve().then(() => tslib_1.__importStar(require('@trezor/blockchain-link/lib/workers/solana'))).then(w => w.default());
 exports.SolanaWorker = SolanaWorker;
 const ElectrumWorker = undefined;

package/lib/workers/workers.native.d.ts

@@ -1,6 +1,6 @@
 import BlockbookWorker from '@trezor/blockchain-link/lib/workers/blockbook';
-import RippleWorker from '@trezor/blockchain-link/lib/workers/ripple';
 import BlockfrostWorker from '@trezor/blockchain-link/lib/workers/blockfrost';
+import RippleWorker from '@trezor/blockchain-link/lib/workers/ripple';
 import SolanaWorker from '@trezor/blockchain-link/lib/workers/solana';
 declare const ElectrumWorker: undefined;
 export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker };

package/lib/workers/workers.native.js

@@ -4,10 +4,10 @@ exports.SolanaWorker = exports.ElectrumWorker = exports.BlockfrostWorker = expor
 const tslib_1 = require("tslib");
 const blockbook_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/blockbook"));
 exports.BlockbookWorker = blockbook_1.default;
-const ripple_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/ripple"));
-exports.RippleWorker = ripple_1.default;
 const blockfrost_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/blockfrost"));
 exports.BlockfrostWorker = blockfrost_1.default;
+const ripple_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/ripple"));
+exports.RippleWorker = ripple_1.default;
 const solana_1 = tslib_1.__importDefault(require("@trezor/blockchain-link/lib/workers/solana"));
 exports.SolanaWorker = solana_1.default;
 const ElectrumWorker = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.4.7",
+  "version": "9.4.8-beta.2",
   "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.",
@@ -71,17 +71,27 @@
     "@babel/preset-typescript": "^7.24.7",
     "@ethereumjs/common": "^4.4.0",
     "@ethereumjs/tx": "^5.4.0",
-    "@fivebinaries/coin-selection": "2.2.1",
-    "@trezor/blockchain-link": "2.3.6",
-    "@trezor/blockchain-link-types": "1.2.5",
-    "@trezor/connect-analytics": "1.2.4",
-    "@trezor/connect-common": "0.2.7",
-    "@trezor/protobuf": "1.2.6",
+    "@fivebinaries/coin-selection": "3.0.0",
+    "@mobily/ts-belt": "^3.13.1",
+    "@noble/hashes": "^1.6.1",
+    "@scure/bip39": "^1.5.1",
+    "@solana-program/compute-budget": "^0.6.1",
+    "@solana-program/system": "^0.6.2",
+    "@solana-program/token": "^0.4.1",
+    "@solana-program/token-2022": "^0.3.1",
+    "@solana/web3.js": "^2.0.0",
+    "@trezor/blockchain-link": "2.3.7-beta.1",
+    "@trezor/blockchain-link-types": "1.2.6-beta.1",
+    "@trezor/blockchain-link-utils": "1.2.7-beta.1",
+    "@trezor/connect-analytics": "1.2.5-beta.1",
+    "@trezor/connect-common": "0.2.8-beta.1",
+    "@trezor/crypto-utils": "1.0.1-beta.1",
+    "@trezor/protobuf": "1.2.7-beta.1",
     "@trezor/protocol": "1.2.2",
-    "@trezor/schema-utils": "1.2.3",
-    "@trezor/transport": "1.3.7",
-    "@trezor/utils": "9.2.6",
-    "@trezor/utxo-lib": "2.2.6",
+    "@trezor/schema-utils": "1.2.4-beta.1",
+    "@trezor/transport": "1.3.8-beta.1",
+    "@trezor/utils": "9.2.7-beta.2",
+    "@trezor/utxo-lib": "2.2.7-beta.1",
     "blakejs": "^1.2.1",
     "bs58": "^6.0.0",
     "bs58check": "^4.0.0",
@@ -90,7 +100,7 @@
   "devDependencies": {
     "@trezor/eslint": "1.0.0",
     "@trezor/trezor-user-env-link": "1.0.2",
-    "@types/karma": "^6.3.8",
+    "@types/karma": "^6.3.9",
     "babel-loader": "^9.1.3",
     "jest": "29.7.0",
     "karma": "^6.4.4",

package/lib/utils/promiseUtils.d.ts

@@ -1,5 +0,0 @@
-export declare const resolveAfter: <T = void>(msec: number, value?: T) => {
-    promise: Promise<T>;
-    reject: (e: Error) => void;
-};
-//# sourceMappingURL=promiseUtils.d.ts.map

package/lib/utils/promiseUtils.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveAfter = void 0;
-const utils_1 = require("@trezor/utils");
-const resolveAfter = (msec, value) => {
-    const { promise, reject, resolve } = (0, utils_1.createDeferred)();
-    const timeout = setTimeout(resolve, msec, value);
-    return {
-        promise: promise.finally(() => clearTimeout(timeout)),
-        reject,
-    };
-};
-exports.resolveAfter = resolveAfter;
-//# sourceMappingURL=promiseUtils.js.map