@trezor/connect 9.6.2-beta.3 → 9.6.3-beta.1

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CardanoSignedTxData = exports.CardanoAuxiliaryDataSupplement = exports.CardanoSignedTxWitness = exports.CardanoSignTransactionExtended = exports.CardanoSignTransaction = exports.CardanoAuxiliaryData = exports.CardanoCVoteRegistrationParameters = exports.CardanoCVoteRegistrationDelegation = exports.CardanoReferenceInput = exports.CardanoRequiredSigner = exports.CardanoCollateralInput = exports.CardanoMint = exports.CardanoWithdrawal = exports.CardanoCertificate = exports.CardanoDRep = exports.CardanoPoolParameters = exports.CardanoPoolMargin = exports.CardanoPoolMetadata = exports.CardanoPoolRelay = exports.CardanoPoolOwner = exports.CardanoOutput = exports.CardanoAssetGroup = exports.CardanoToken = exports.CardanoInput = exports.CardanoGetPublicKey = exports.CardanoNativeScriptHash = exports.CardanoGetNativeScriptHash = exports.CardanoNativeScript = exports.CardanoGetAddress = exports.CardanoAddressParameters = exports.CardanoCertificatePointer = void 0;
+exports.CardanoSignedMessage = exports.CardanoMessageHeaders = exports.CardanoMessageUnprotectedHeaders = exports.CardanoMessageProtectedHeaders = exports.CardanoSignMessage = exports.CardanoSignedTxData = exports.CardanoAuxiliaryDataSupplement = exports.CardanoSignedTxWitness = exports.CardanoSignTransactionExtended = exports.CardanoSignTransaction = exports.CardanoAuxiliaryData = exports.CardanoCVoteRegistrationParameters = exports.CardanoCVoteRegistrationDelegation = exports.CardanoReferenceInput = exports.CardanoRequiredSigner = exports.CardanoCollateralInput = exports.CardanoMint = exports.CardanoWithdrawal = exports.CardanoCertificate = exports.CardanoDRep = exports.CardanoPoolParameters = exports.CardanoPoolMargin = exports.CardanoPoolMetadata = exports.CardanoPoolRelay = exports.CardanoPoolOwner = exports.CardanoOutput = exports.CardanoAssetGroup = exports.CardanoToken = exports.CardanoInput = exports.CardanoGetPublicKey = exports.CardanoNativeScriptHash = exports.CardanoGetNativeScriptHash = exports.CardanoNativeScript = exports.CardanoGetAddress = exports.CardanoAddressParameters = exports.CardanoCertificatePointer = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
 const constants_1 = require("../../../constants");
 const params_1 = require("../../params");
@@ -216,4 +216,33 @@ exports.CardanoSignedTxData = schema_utils_1.Type.Object({
     witnesses: schema_utils_1.Type.Array(exports.CardanoSignedTxWitness),
     auxiliaryDataSupplement: schema_utils_1.Type.Optional(exports.CardanoAuxiliaryDataSupplement),
 });
+exports.CardanoSignMessage = schema_utils_1.Type.Object({
+    path: params_1.DerivationPath,
+    payload: schema_utils_1.Type.String(),
+    preferHexDisplay: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+    networkId: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    protocolMagic: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    addressParameters: schema_utils_1.Type.Optional(exports.CardanoAddressParameters),
+    derivationType: schema_utils_1.Type.Optional(constants_1.PROTO.EnumCardanoDerivationType),
+});
+exports.CardanoMessageProtectedHeaders = schema_utils_1.Type.Object({
+    1: schema_utils_1.Type.Literal(constants_1.CARDANO.ALGORITHM_IDS.EdDSA),
+    address: schema_utils_1.Type.String(),
+});
+exports.CardanoMessageUnprotectedHeaders = schema_utils_1.Type.Object({
+    hashed: schema_utils_1.Type.Boolean(),
+    version: schema_utils_1.Type.Number(),
+});
+exports.CardanoMessageHeaders = schema_utils_1.Type.Object({
+    protected: exports.CardanoMessageProtectedHeaders,
+    unprotected: exports.CardanoMessageUnprotectedHeaders,
+});
+exports.CardanoSignedMessage = schema_utils_1.Type.Object({
+    headers: exports.CardanoMessageHeaders,
+    payload: schema_utils_1.Type.String(),
+    signature: schema_utils_1.Type.String(),
+    pubKey: schema_utils_1.Type.String(),
+    coseSignature: schema_utils_1.Type.String(),
+    coseKey: schema_utils_1.Type.String(),
+});
 //# sourceMappingURL=index.js.map

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

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

package/lib/types/api/cardanoSignMessage.js

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

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

@@ -202,28 +202,33 @@ export type AccountTypeKey = DistributivePick<AccountTypeItem, 'symbol' | 'type'
 export type AdditionalParams = Pick<BlockchainLinkParams<'getAccountInfo'>, 'details' | 'pageSize'> & {
     identity?: string;
 };
-type TypedAccountParam = AccountTypeKey & AdditionalParams & {
-    skip?: number;
-};
-type UntypedAccountParam = AdditionalParams & {
-    symbol: AccountTypeItem['symbol'];
-    type?: undefined;
-    skip?: undefined;
-};
+type CoinParam<T extends AccountTypeKey['symbol'] = AccountTypeKey['symbol']> = T extends T ? AdditionalParams & {
+    symbol: T;
+    known?: {
+        type: Extract<AccountTypeKey, {
+            symbol: T;
+        }>['type'];
+        skip?: number;
+    }[];
+    knownOnly?: boolean;
+} : never;
 type DiscoverAccountsParams = {
-    accounts: (TypedAccountParam | UntypedAccountParam)[];
+    coins: CoinParam[];
 };
 type ProgressBaseType = AccountTypeKey & {
     index: number;
-};
-export type DiscoverAccountsProgressOk = ProgressBaseType & AccountInfo & {
     path: string;
     backendType?: string;
 };
-export type DiscoverAccountsProgressError = ProgressBaseType & {
+type DiscoveryError = {
+    failed: true;
     error: string;
     code?: string;
 };
+export type DiscoverAccountsProgressOk = ProgressBaseType & AccountInfo & {
+    failed: false;
+};
+export type DiscoverAccountsProgressError = ProgressBaseType & DiscoveryError;
 export type DiscoverAccountsProgress = DiscoverAccountsProgressOk | DiscoverAccountsProgressError;
 type DiscoverAccountsResult = {
     empty: number;

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

@@ -18,6 +18,33 @@ export declare const EthereumTransaction: import("@trezor/schema-utils").TObject
     data: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
     chainId: import("@trezor/schema-utils").TNumber;
     txType: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+    payment_req: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+        nonce: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        recipient_name: import("@trezor/schema-utils").TString;
+        memos: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+            text_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                text: import("@trezor/schema-utils").TString;
+            }>>;
+            refund_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                address: import("@trezor/schema-utils").TString;
+                address_n: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+                mac: import("@trezor/schema-utils").TString;
+            }>>;
+            coin_purchase_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                coin_type: import("@trezor/schema-utils").TNumber;
+                amount: import("@trezor/schema-utils").TString;
+                address: import("@trezor/schema-utils").TString;
+                address_n: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+                mac: import("@trezor/schema-utils").TString;
+            }>>;
+            text_details_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                title: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+                text: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            }>>;
+        }>>>;
+        amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
+        signature: import("@trezor/schema-utils").TString;
+    }>>;
 }>;
 export type EthereumAccessList = Static<typeof EthereumAccessList>;
 export declare const EthereumAccessList: import("@trezor/schema-utils").TObject<{
@@ -39,6 +66,33 @@ export declare const EthereumTransactionEIP1559: import("@trezor/schema-utils").
         address: import("@trezor/schema-utils").TString;
         storageKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
     }>>>;
+    payment_req: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+        nonce: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+        recipient_name: import("@trezor/schema-utils").TString;
+        memos: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+            text_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                text: import("@trezor/schema-utils").TString;
+            }>>;
+            refund_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                address: import("@trezor/schema-utils").TString;
+                address_n: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+                mac: import("@trezor/schema-utils").TString;
+            }>>;
+            coin_purchase_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                coin_type: import("@trezor/schema-utils").TNumber;
+                amount: import("@trezor/schema-utils").TString;
+                address: import("@trezor/schema-utils").TString;
+                address_n: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+                mac: import("@trezor/schema-utils").TString;
+            }>>;
+            text_details_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                title: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+                text: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            }>>;
+        }>>>;
+        amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
+        signature: import("@trezor/schema-utils").TString;
+    }>>;
 }>;
 export type EthereumSignTransaction = Static<typeof EthereumSignTransaction>;
 export declare const EthereumSignTransaction: import("@trezor/schema-utils").TObject<{
@@ -54,6 +108,33 @@ export declare const EthereumSignTransaction: import("@trezor/schema-utils").TOb
         data: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
         chainId: import("@trezor/schema-utils").TNumber;
         txType: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
+        payment_req: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            nonce: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            recipient_name: import("@trezor/schema-utils").TString;
+            memos: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+                text_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                    text: import("@trezor/schema-utils").TString;
+                }>>;
+                refund_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                    address: import("@trezor/schema-utils").TString;
+                    address_n: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+                    mac: import("@trezor/schema-utils").TString;
+                }>>;
+                coin_purchase_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                    coin_type: import("@trezor/schema-utils").TNumber;
+                    amount: import("@trezor/schema-utils").TString;
+                    address: import("@trezor/schema-utils").TString;
+                    address_n: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+                    mac: import("@trezor/schema-utils").TString;
+                }>>;
+                text_details_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                    title: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+                    text: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+                }>>;
+            }>>>;
+            amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
+            signature: import("@trezor/schema-utils").TString;
+        }>>;
     }>, import("@trezor/schema-utils").TObject<{
         to: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TNull]>;
         value: import("@trezor/schema-utils").TString;
@@ -68,6 +149,33 @@ export declare const EthereumSignTransaction: import("@trezor/schema-utils").TOb
             address: import("@trezor/schema-utils").TString;
             storageKeys: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TString>;
         }>>>;
+        payment_req: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+            nonce: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+            recipient_name: import("@trezor/schema-utils").TString;
+            memos: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
+                text_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                    text: import("@trezor/schema-utils").TString;
+                }>>;
+                refund_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                    address: import("@trezor/schema-utils").TString;
+                    address_n: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+                    mac: import("@trezor/schema-utils").TString;
+                }>>;
+                coin_purchase_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                    coin_type: import("@trezor/schema-utils").TNumber;
+                    amount: import("@trezor/schema-utils").TString;
+                    address: import("@trezor/schema-utils").TString;
+                    address_n: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+                    mac: import("@trezor/schema-utils").TString;
+                }>>;
+                text_details_memo: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
+                    title: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+                    text: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
+                }>>;
+            }>>>;
+            amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
+            signature: import("@trezor/schema-utils").TString;
+        }>>;
     }>]>;
     chunkify: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
 }>;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EthereumVerifyMessage = exports.EthereumSignTypedHash = exports.EthereumSignTypedData = exports.EthereumSignTypedDataMessage = exports.EthereumSignTypedDataTypes = exports.EthereumSignedTx = exports.EthereumSignTransaction = exports.EthereumTransactionEIP1559 = exports.EthereumAccessList = exports.EthereumTransaction = exports.EthereumSignMessage = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../../../constants");
 const params_1 = require("../../params");
 exports.EthereumSignMessage = schema_utils_1.Type.Object({
     path: params_1.DerivationPath,
@@ -19,6 +20,7 @@ exports.EthereumTransaction = schema_utils_1.Type.Object({
     data: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
     chainId: schema_utils_1.Type.Number(),
     txType: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    payment_req: schema_utils_1.Type.Optional(constants_1.PROTO.PaymentRequest),
 });
 exports.EthereumAccessList = schema_utils_1.Type.Object({
     address: schema_utils_1.Type.String(),
@@ -35,6 +37,7 @@ exports.EthereumTransactionEIP1559 = schema_utils_1.Type.Object({
     maxFeePerGas: schema_utils_1.Type.String(),
     maxPriorityFeePerGas: schema_utils_1.Type.String(),
     accessList: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.EthereumAccessList)),
+    payment_req: schema_utils_1.Type.Optional(constants_1.PROTO.PaymentRequest),
 });
 exports.EthereumSignTransaction = schema_utils_1.Type.Object({
     path: params_1.DerivationPath,

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

@@ -0,0 +1,4 @@
+import { PROTO } from '../../constants';
+import { Params, Response } from '../params';
+export declare function evoluGetNode(params: Params<PROTO.EvoluGetNode>): Response<PROTO.EvoluNode>;
+//# sourceMappingURL=evoluGetNode.d.ts.map

package/lib/types/api/evoluGetNode.js

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

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

@@ -23,6 +23,7 @@ import { cardanoComposeTransaction } from './cardanoComposeTransaction';
 import { cardanoGetAddress } from './cardanoGetAddress';
 import { cardanoGetNativeScriptHash } from './cardanoGetNativeScriptHash';
 import { cardanoGetPublicKey } from './cardanoGetPublicKey';
+import { cardanoSignMessage } from './cardanoSignMessage';
 import { cardanoSignTransaction } from './cardanoSignTransaction';
 import { changeLanguage } from './changeLanguage';
 import { changePin } from './changePin';
@@ -39,6 +40,7 @@ import { ethereumSignMessage } from './ethereumSignMessage';
 import { ethereumSignTransaction } from './ethereumSignTransaction';
 import { ethereumSignTypedData } from './ethereumSignTypedData';
 import { ethereumVerifyMessage } from './ethereumVerifyMessage';
+import { evoluGetNode } from './evoluGetNode';
 import { firmwareUpdate } from './firmwareUpdate';
 import { getAccountDescriptor } from './getAccountDescriptor';
 import { getAccountInfo } from './getAccountInfo';
@@ -82,6 +84,8 @@ import { stellarSignTransaction } from './stellarSignTransaction';
 import { tezosGetAddress } from './tezosGetAddress';
 import { tezosGetPublicKey } from './tezosGetPublicKey';
 import { tezosSignTransaction } from './tezosSignTransaction';
+import { thpGetCredentials } from './thpGetCredentials';
+import { thpRemoveCredentials } from './thpRemoveCredentials';
 import { uiResponse } from './uiResponse';
 import { unlockPath } from './unlockPath';
 import { verifyMessage } from './verifyMessage';
@@ -113,11 +117,13 @@ export interface TrezorConnect {
     cardanoGetNativeScriptHash: typeof cardanoGetNativeScriptHash;
     cardanoGetPublicKey: typeof cardanoGetPublicKey;
     cardanoSignTransaction: typeof cardanoSignTransaction;
+    cardanoSignMessage: typeof cardanoSignMessage;
     cardanoComposeTransaction: typeof cardanoComposeTransaction;
     changeLanguage: typeof changeLanguage;
     changePin: typeof changePin;
     changeWipeCode: typeof changeWipeCode;
     cipherKeyValue: typeof cipherKeyValue;
+    evoluGetNode: typeof evoluGetNode;
     composeTransaction: typeof composeTransaction;
     dispose: typeof dispose;
     eosGetPublicKey: typeof eosGetPublicKey;
@@ -142,6 +148,8 @@ export interface TrezorConnect {
     getPublicKey: typeof getPublicKey;
     getNonce: typeof getNonce;
     getSettings: typeof getSettings;
+    thpGetCredentials: typeof thpGetCredentials;
+    thpRemoveCredentials: typeof thpRemoveCredentials;
     init: typeof init;
     manifest: typeof manifest;
     nemGetAddress: typeof nemGetAddress;

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

@@ -2,7 +2,10 @@ import { Static } from '@trezor/schema-utils';
 import type { Params, Response } from '../params';
 export type PushTransaction = Static<typeof PushTransaction>;
 export declare const PushTransaction: import("@trezor/schema-utils").TObject<{
-    tx: import("@trezor/schema-utils").TString;
+    tx: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TObject<{
+        hex: import("@trezor/schema-utils").TString;
+        disableAlternativeRPC: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
+    }>]>;
     coin: import("@trezor/schema-utils").TString;
     identity: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
 }>;

package/lib/types/api/pushTransaction.js

@@ -3,7 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PushTransaction = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
 exports.PushTransaction = schema_utils_1.Type.Object({
-    tx: schema_utils_1.Type.String(),
+    tx: schema_utils_1.Type.Union([
+        schema_utils_1.Type.String(),
+        schema_utils_1.Type.Object({
+            hex: schema_utils_1.Type.String(),
+            disableAlternativeRPC: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+        }),
+    ]),
     coin: schema_utils_1.Type.String(),
     identity: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
 });

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

@@ -6,6 +6,7 @@ export declare const SolanaPublicKey: import("@trezor/schema-utils").TIntersect<
     serializedPath: import("@trezor/schema-utils").TString;
 }>, import("@trezor/schema-utils").TObject<{
     publicKey: import("@trezor/schema-utils").TString;
+    publicKeyBase58: import("@trezor/schema-utils").TString;
 }>]>;
 export type SolanaTxTokenAccountInfo = Static<typeof SolanaTxTokenAccountInfo>;
 export declare const SolanaTxTokenAccountInfo: import("@trezor/schema-utils").TObject<{
@@ -24,6 +25,7 @@ export declare const SolanaTxAdditionalInfo: import("@trezor/schema-utils").TObj
         tokenAccount: import("@trezor/schema-utils").TString;
         symbol: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
     }>>>;
+    isDevnet: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
 }>;
 export type SolanaSignTransaction = Static<typeof SolanaSignTransaction>;
 export declare const SolanaSignTransaction: import("@trezor/schema-utils").TObject<{
@@ -37,6 +39,7 @@ export declare const SolanaSignTransaction: import("@trezor/schema-utils").TObje
             tokenAccount: import("@trezor/schema-utils").TString;
             symbol: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
         }>>>;
+        isDevnet: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
     }>>;
     serialize: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
 }>;

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

@@ -7,6 +7,7 @@ exports.SolanaPublicKey = schema_utils_1.Type.Intersect([
     params_1.PublicKey,
     schema_utils_1.Type.Object({
         publicKey: schema_utils_1.Type.String(),
+        publicKeyBase58: schema_utils_1.Type.String(),
     }),
 ]);
 exports.SolanaTxTokenAccountInfo = schema_utils_1.Type.Object({
@@ -18,6 +19,7 @@ exports.SolanaTxTokenAccountInfo = schema_utils_1.Type.Object({
 });
 exports.SolanaTxAdditionalInfo = schema_utils_1.Type.Object({
     tokenAccountsInfos: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.SolanaTxTokenAccountInfo, { minItems: 1 })),
+    isDevnet: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
 });
 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())]),

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

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

package/lib/types/api/thpGetCredentials.js

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

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

@@ -0,0 +1,7 @@
+import type { ThpCredentials } from '@trezor/protocol';
+import type { PROTO } from '../../constants';
+import type { CommonParams, Response } from '../params';
+export declare function thpRemoveCredentials(params: CommonParams & {
+    credentials?: ThpCredentials[];
+}): Response<PROTO.Success>;
+//# sourceMappingURL=thpRemoveCredentials.d.ts.map

package/lib/types/api/thpRemoveCredentials.js

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

package/lib/types/device.d.ts

@@ -2,8 +2,8 @@ import { FeaturesNarrowing, FirmwareType } from '@trezor/device-utils';
 import type { ThpStateSerialized } from '@trezor/protocol';
 import { Branded } from '@trezor/type-utils';
 import type { PROTO } from '../constants';
-import type { ReleaseInfo } from './firmware';
-export type DeviceStatus = 'available' | 'occupied' | 'used';
+import type { FirmwareReleaseConfigInfo } from './firmware';
+export type DeviceStatus = 'available' | 'occupied' | 'used' | 'busy';
 export type DeviceMode = 'normal' | 'bootloader' | 'initialize' | 'seedless';
 export type DeviceFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'custom' | 'none';
 export type UnavailableCapability = 'no-capability' | 'no-support' | 'update-required' | 'trezor-connect-outdated';
@@ -24,7 +24,7 @@ export type FirmwareRevisionCheckResult = {
     error: FirmwareRevisionCheckError;
     errorPayload?: unknown;
 };
-export type FirmwareHashCheckError = 'hash-mismatch' | 'check-skipped' | 'check-unsupported' | 'unknown-release' | 'other-error';
+export type FirmwareHashCheckError = 'hash-mismatch' | 'check-skipped' | 'check-unsupported' | 'unknown-release' | 'takes-too-long' | 'other-error';
 export type FirmwareHashCheckResult = {
     success: true;
     attemptCount?: number;
@@ -50,7 +50,7 @@ export type KnownDevice = BaseDevice & {
     label: string;
     error?: typeof undefined;
     firmware: DeviceFirmwareStatus;
-    firmwareRelease?: ReleaseInfo | null;
+    firmwareReleaseConfigInfo?: FirmwareReleaseConfigInfo | null;
     firmwareType?: FirmwareType;
     color?: string;
     status: DeviceStatus;
@@ -60,8 +60,8 @@ export type KnownDevice = BaseDevice & {
     features: PROTO.Features;
     thp?: ThpStateSerialized;
     unavailableCapabilities: UnavailableCapabilities;
-    availableTranslations: string[];
-    authenticityChecks?: {
+    availableTranslations: Record<string, string>;
+    authenticityChecks: {
         firmwareRevision: FirmwareRevisionCheckResult | null;
         firmwareHash: FirmwareHashCheckResult | null;
     };
@@ -77,10 +77,10 @@ export type UnknownDevice = BaseDevice & {
     features?: typeof undefined;
     thp?: ThpStateSerialized;
     firmware?: typeof undefined;
-    firmwareRelease?: typeof undefined;
+    firmwareReleaseConfigInfo?: typeof undefined;
     firmwareType?: typeof undefined;
     color?: typeof undefined;
-    status?: typeof undefined;
+    status?: DeviceStatus;
     mode?: typeof undefined;
     _state?: typeof undefined;
     state?: typeof undefined;
@@ -98,7 +98,7 @@ export type UnreadableDevice = BaseDevice & {
     features?: typeof undefined;
     thp?: typeof undefined;
     firmware?: typeof undefined;
-    firmwareRelease?: typeof undefined;
+    firmwareReleaseConfigInfo?: typeof undefined;
     firmwareType?: typeof undefined;
     color?: typeof undefined;
     status?: typeof undefined;

package/lib/types/firmware.d.ts

@@ -1,21 +1,24 @@
-import type { DeviceModelInternal, FirmwareRelease, VersionArray } from '@trezor/device-utils';
+import type { ConditionalRelease, DeviceModelInternal, FirmwareRelease, FirmwareType, IntermediaryReleaseConfig, VersionArray } from '@trezor/device-utils';
 export type FirmwareRange = Record<DeviceModelInternal, {
     min: string;
     max: string;
 }>;
-export type IntermediaryVersion = 1 | 2 | 3;
-export declare const IntermediaryVersion: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TLiteral<1>, import("@trezor/schema-utils").TLiteral<2>, import("@trezor/schema-utils").TLiteral<3>]>;
-export type ReleaseInfo = {
-    changelog: FirmwareRelease[] | null;
-    release: FirmwareRelease;
-    isRequired: boolean | null;
-    isNewer: boolean | null;
-    intermediaryVersion?: IntermediaryVersion;
-    translations?: string[];
-};
 export type BinaryInfo = {
     binary: ArrayBuffer;
     binaryVersion: VersionArray;
-    releaseVersion: undefined;
+    releaseVersion?: VersionArray;
+};
+export type FirmwareReleaseConfigInfo = {
+    firmwareType: FirmwareType;
+    isBitcoinOnlyAvailable: boolean;
+    releaseConditions: ConditionalRelease['conditions'] & {
+        shouldBeOffered: boolean;
+    };
+    release: FirmwareRelease;
+    intermediary: IntermediaryReleaseConfig | undefined;
+    isRequired: boolean | null;
+    isNewer: boolean | null;
+    translations?: Record<string, string>;
 };
+export type FirmwareUpdateFlowType = 'reboot_and_wait' | 'reboot_and_upgrade' | 'manual' | 'unknown_flow';
 //# sourceMappingURL=firmware.d.ts.map

package/lib/types/firmware.js

@@ -1,6 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntermediaryVersion = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-exports.IntermediaryVersion = schema_utils_1.Type.Union([schema_utils_1.Type.Literal(1), schema_utils_1.Type.Literal(2), schema_utils_1.Type.Literal(3)]);
 //# sourceMappingURL=firmware.js.map

package/lib/types/params.d.ts

@@ -19,6 +19,7 @@ export interface CommonParams {
     useCardanoDerivation?: boolean;
     chunkify?: boolean;
     __info?: boolean;
+    __precomposed?: boolean;
 }
 export type Params<T> = CommonParams & T & {
     bundle?: undefined;

package/lib/types/settings.d.ts

@@ -1,6 +1,9 @@
 import type { BlockchainSettings } from '@trezor/blockchain-link';
+import type { DeviceModelInternal } from '@trezor/device-utils';
 import type { ThpCredentials, ThpPairingMethod } from '@trezor/protocol';
 import type { Transport } from '@trezor/transport';
+import { PartialRecord } from '@trezor/type-utils';
+import { FirmwareUpdateSource } from '../data/firmwareInfo';
 export type { SystemInfo } from '@trezor/connect-common';
 export interface Manifest {
     appName: string;
@@ -8,6 +11,7 @@ export interface Manifest {
     appUrl: string;
     email: string;
 }
+export type FirmwareHashCheckTimeouts = PartialRecord<DeviceModelInternal, number>;
 export type Proxy = BlockchainSettings['proxy'];
 export type LocalFirmwares = {
     firmwareDir: string;
@@ -16,6 +20,7 @@ export type LocalFirmwares = {
 type KnownTransport = Exclude<Transport['name'], 'NativeUsbTransport' | 'BluetoothTransport'>;
 export type ThpSettings = {
     hostName?: string;
+    appName?: string;
     staticKey?: string;
     knownCredentials?: ThpCredentials[];
     pairingMethods: ThpPairingMethod[] | (keyof typeof ThpPairingMethod)[];
@@ -34,6 +39,7 @@ export interface ConnectSettingsPublic {
     trustedHost: boolean;
     binFilesBaseUrl?: string;
     enableFirmwareHashCheck?: boolean;
+    firmwareHashCheckTimeouts?: FirmwareHashCheckTimeouts;
     thp?: ThpSettings;
 }
 export interface ConnectSettingsInternal {
@@ -52,6 +58,7 @@ export interface ConnectSettingsInternal {
     sharedLogger?: boolean;
     useCoreInPopup?: boolean;
     localFirmwares?: LocalFirmwares;
+    firmwareUpdateSource?: FirmwareUpdateSource;
 }
 export interface ConnectSettingsWeb {
     hostLabel?: string;

package/lib/utils/assetUtils.d.ts

@@ -1,5 +1,8 @@
-import { DeviceModelInternal } from '@trezor/device-utils';
-export declare const firmwareAssets: Record<DeviceModelInternal, NodeJS.Require>;
+import { DeviceModelInternal, FirmwareRelease, FirmwareType, VersionArray } from '@trezor/device-utils';
+export declare const getReleasesAssetByDeviceModelAndFirmwareType: (deviceModel: DeviceModelInternal, firmwareType: FirmwareType) => {
+    [file: string]: FirmwareRelease;
+};
+export declare const getReleaseAsset: (deviceModel: DeviceModelInternal, version: VersionArray, firmwareType: FirmwareType) => FirmwareRelease;
 export declare const firmwareReleaseConfigAssets: any;
 export declare const tryLocalAssetRequire: (url: string) => any;
 //# sourceMappingURL=assetUtils.d.ts.map