@trezor/connect 9.1.5 → 9.1.7

package/lib/device/DeviceCommands.js

@@ -157,7 +157,7 @@ class DeviceCommands {
         }
         return response;
     }
-    async getAddress({ address_n, show_display, multisig, script_type }, coinInfo) {
+    async getAddress({ address_n, show_display, multisig, script_type, chunkify }, coinInfo) {
         if (!script_type) {
             script_type = (0, pathUtils_1.getScriptType)(address_n);
             if (script_type === 'SPENDMULTISIG' && !multisig) {
@@ -177,6 +177,7 @@ class DeviceCommands {
             show_display,
             multisig,
             script_type: script_type || 'SPENDADDRESS',
+            chunkify,
         });
         return {
             path: address_n,
@@ -184,11 +185,12 @@ class DeviceCommands {
             address: response.message.address,
         };
     }
-    async ethereumGetAddress({ address_n, show_display, encoded_network, }) {
+    async ethereumGetAddress({ address_n, show_display, encoded_network, chunkify, }) {
         const response = await this.typedCall('EthereumGetAddress', 'EthereumAddress', {
             address_n,
             show_display,
             encoded_network,
+            chunkify,
         });
         return {
             path: address_n,
@@ -245,6 +247,7 @@ class DeviceCommands {
             session: this.sessionId,
             name: type,
             data: msg,
+            protocol: this.device.protocol,
         });
         const res = await this.callPromise.promise;
         this.callPromise = undefined;
@@ -264,7 +267,10 @@ class DeviceCommands {
             assertType(response, resType);
         }
         catch (error) {
-            await this.transport.receive({ session: this.sessionId });
+            await this.transport.receive({
+                session: this.sessionId,
+                protocol: this.device.protocol,
+            });
             throw error;
         }
         return response;
@@ -474,6 +480,15 @@ class DeviceCommands {
                 address_n,
             };
         }
+        if (coinInfo.shortcut === 'SOL' || coinInfo.shortcut === 'DSOL') {
+            const { message } = await this.typedCall('SolanaGetAddress', 'SolanaAddress', {
+                address_n,
+            });
+            return {
+                descriptor: message.address,
+                address_n,
+            };
+        }
         throw constants_1.ERRORS.TypedError('Runtime', 'DeviceCommands.getAccountDescriptor: unsupported coinInfo.type');
     }
     async cancel() {
@@ -502,6 +517,7 @@ class DeviceCommands {
         }
         else {
             await this.transport.send({
+                protocol: this.device.protocol,
                 session: this.sessionId,
                 name: 'Cancel',
                 data: {},

package/lib/device/DeviceList.js

@@ -60,7 +60,10 @@ class DeviceList extends typedEventEmitter_1.TypedEmitter {
                 }
             }
             else if (transportType instanceof transport_1.Transport) {
-                this.transports.unshift(transportType);
+                if (!transportType.getMessage()) {
+                    transportType.updateMessages(this.messages);
+                }
+                this.transports.push(transportType);
             }
             else {
                 throw constants_1.ERRORS.TypedError('Runtime', 'DeviceList.init: transports[] of unexpected type');

package/lib/events/popup.d.ts

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

package/lib/events/popup.js

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

package/lib/events/ui-request.d.ts

@@ -132,7 +132,7 @@ export interface UiRequestPermission {
 export interface UiRequestConfirmation {
     type: typeof UI_REQUEST.REQUEST_CONFIRMATION;
     payload: {
-        view: string;
+        view: 'no-backup' | 'export-xpub' | 'export-address' | 'export-account-info' | 'device-management';
         label?: string;
         customConfirmButton?: {
             className: string;

package/lib/factory.js

@@ -42,6 +42,7 @@ const factory = ({ eventEmitter, manifest, init, call, requestLogin, uiResponse,
         cardanoGetNativeScriptHash: params => call({ ...params, method: 'cardanoGetNativeScriptHash' }),
         cardanoGetPublicKey: params => call({ ...params, method: 'cardanoGetPublicKey' }),
         cardanoSignTransaction: params => call({ ...params, method: 'cardanoSignTransaction' }),
+        cardanoComposeTransaction: params => call({ ...params, method: 'cardanoComposeTransaction' }),
         cipherKeyValue: params => call({ ...params, method: 'cipherKeyValue' }),
         composeTransaction: params => call({ ...params, method: 'composeTransaction' }),
         ethereumGetAddress: params => call({
@@ -54,6 +55,7 @@ const factory = ({ eventEmitter, manifest, init, call, requestLogin, uiResponse,
         ethereumSignTransaction: params => call({ ...params, method: 'ethereumSignTransaction' }),
         ethereumSignTypedData: params => call({ ...params, method: 'ethereumSignTypedData' }),
         ethereumVerifyMessage: params => call({ ...params, method: 'ethereumVerifyMessage' }),
+        getAccountDescriptor: params => call({ ...params, method: 'getAccountDescriptor' }),
         getAccountInfo: params => call({ ...params, method: 'getAccountInfo' }),
         getAddress: params => call({
             ...params,
@@ -81,6 +83,9 @@ const factory = ({ eventEmitter, manifest, init, call, requestLogin, uiResponse,
         rippleSignTransaction: params => call({ ...params, method: 'rippleSignTransaction' }),
         signMessage: params => call({ ...params, method: 'signMessage' }),
         signTransaction: params => call({ ...params, method: 'signTransaction' }),
+        solanaGetPublicKey: params => call({ ...params, method: 'solanaGetPublicKey' }),
+        solanaGetAddress: params => call({ ...params, method: 'solanaGetAddress' }),
+        solanaSignTransaction: params => call({ ...params, method: 'solanaSignTransaction' }),
         stellarGetAddress: params => call({
             ...params,
             method: 'stellarGetAddress',

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

@@ -26,5 +26,6 @@ export interface BinancePreparedTransaction extends BinanceSDKTransaction {
 export interface BinanceSignTransaction {
     path: DerivationPath;
     transaction: BinanceSDKTransaction;
+    chunkify?: boolean;
 }
 //# sourceMappingURL=index.d.ts.map

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

@@ -49,6 +49,7 @@ export interface TransactionOptions {
     amount_unit?: PROTO.AmountUnit;
     serialize?: boolean;
     coinjoin_request?: PROTO.CoinJoinRequest;
+    chunkify?: boolean;
 }
 export interface SignTransaction {
     inputs: ProtoWithDerivationPath<PROTO.TxInputType>[];
@@ -74,6 +75,7 @@ export interface SignTransaction {
     unlockPath?: PROTO.UnlockPath;
     serialize?: boolean;
     coinjoinRequest?: PROTO.CoinJoinRequest;
+    chunkify?: boolean;
 }
 export type SignedTransaction = {
     signatures: string[];

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

@@ -21,6 +21,7 @@ export interface CardanoGetAddress {
     address?: string;
     showOnTrezor?: boolean;
     derivationType?: PROTO.CardanoDerivationType;
+    chunkify?: boolean;
 }
 export interface CardanoAddress {
     addressParameters: CardanoAddressParameters;
@@ -177,6 +178,7 @@ export interface CardanoSignTransaction {
     signingMode: PROTO.CardanoTxSigningMode;
     derivationType?: PROTO.CardanoDerivationType;
     includeNetworkId?: boolean;
+    chunkify?: boolean;
 }
 export interface CardanoSignedTxWitness {
     type: PROTO.CardanoTxWitnessType;

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

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

package/lib/types/api/cardanoComposeTransaction.js

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

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

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

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

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

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

@@ -112,5 +112,6 @@ export interface EosSDKTransaction {
 export interface EosSignTransaction {
     path: DerivationPath;
     transaction: EosSDKTransaction;
+    chunkify?: boolean;
 }
 //# sourceMappingURL=index.d.ts.map

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

@@ -35,11 +35,13 @@ export interface EthereumTransactionEIP1559 {
 export interface EthereumSignTransaction {
     path: DerivationPath;
     transaction: EthereumTransaction | EthereumTransactionEIP1559;
+    chunkify?: boolean;
 }
 export interface EthereumSignedTx {
     v: string;
     r: string;
     s: string;
+    serializedTx: string;
 }
 interface EthereumSignTypedDataTypeProperty {
     name: string;

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

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

package/lib/types/api/getAccountDescriptor.js

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

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

@@ -22,6 +22,7 @@ import { cardanoGetAddress } from './cardanoGetAddress';
 import { cardanoGetNativeScriptHash } from './cardanoGetNativeScriptHash';
 import { cardanoGetPublicKey } from './cardanoGetPublicKey';
 import { cardanoSignTransaction } from './cardanoSignTransaction';
+import { cardanoComposeTransaction } from './cardanoComposeTransaction';
 import { changePin } from './changePin';
 import { cipherKeyValue } from './cipherKeyValue';
 import { composeTransaction } from './composeTransaction';
@@ -36,6 +37,7 @@ import { ethereumSignTransaction } from './ethereumSignTransaction';
 import { ethereumSignTypedData } from './ethereumSignTypedData';
 import { ethereumVerifyMessage } from './ethereumVerifyMessage';
 import { firmwareUpdate } from './firmwareUpdate';
+import { getAccountDescriptor } from './getAccountDescriptor';
 import { getAccountInfo } from './getAccountInfo';
 import { getAddress } from './getAddress';
 import { getCoinInfo } from './getCoinInfo';
@@ -66,6 +68,9 @@ import { setBusy } from './setBusy';
 import { setProxy } from './setProxy';
 import { signMessage } from './signMessage';
 import { signTransaction } from './signTransaction';
+import { solanaGetPublicKey } from './solanaGetPublicKey';
+import { solanaGetAddress } from './solanaGetAddress';
+import { solanaSignTransaction } from './solanaSignTransaction';
 import { stellarGetAddress } from './stellarGetAddress';
 import { stellarSignTransaction } from './stellarSignTransaction';
 import { tezosGetAddress } from './tezosGetAddress';
@@ -105,6 +110,7 @@ export interface TrezorConnect {
     cardanoGetNativeScriptHash: typeof cardanoGetNativeScriptHash;
     cardanoGetPublicKey: typeof cardanoGetPublicKey;
     cardanoSignTransaction: typeof cardanoSignTransaction;
+    cardanoComposeTransaction: typeof cardanoComposeTransaction;
     changePin: typeof changePin;
     cipherKeyValue: typeof cipherKeyValue;
     composeTransaction: typeof composeTransaction;
@@ -120,6 +126,7 @@ export interface TrezorConnect {
     ethereumSignTypedData: typeof ethereumSignTypedData;
     ethereumVerifyMessage: typeof ethereumVerifyMessage;
     firmwareUpdate: typeof firmwareUpdate;
+    getAccountDescriptor: typeof getAccountDescriptor;
     getAccountInfo: typeof getAccountInfo;
     getAddress: typeof getAddress;
     getCoinInfo: typeof getCoinInfo;
@@ -149,6 +156,9 @@ export interface TrezorConnect {
     setProxy: typeof setProxy;
     signMessage: typeof signMessage;
     signTransaction: typeof signTransaction;
+    solanaGetPublicKey: typeof solanaGetPublicKey;
+    solanaGetAddress: typeof solanaGetAddress;
+    solanaSignTransaction: typeof solanaSignTransaction;
     stellarGetAddress: typeof stellarGetAddress;
     stellarSignTransaction: typeof stellarSignTransaction;
     tezosGetAddress: typeof tezosGetAddress;

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

@@ -87,5 +87,6 @@ export type NEMTransaction = NEMRegularTransaction | NEMMultisigTransaction;
 export interface NEMSignTransaction {
     path: DerivationPath;
     transaction: NEMTransaction;
+    chunkify?: boolean;
 }
 //# sourceMappingURL=index.d.ts.map

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

@@ -14,6 +14,7 @@ export interface RippleTransaction {
 export interface RippleSignTransaction {
     path: DerivationPath;
     transaction: RippleTransaction;
+    chunkify?: boolean;
 }
 export interface RippleSignedTx {
     serializedTx: string;

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

@@ -0,0 +1,22 @@
+import type { PublicKey } from '../../params';
+export interface SolanaPublicKey extends PublicKey {
+    publicKey: string;
+}
+export interface SolanaTxTokenAccountInfo {
+    baseAddress: string;
+    tokenProgram: string;
+    tokenMint: string;
+    tokenAccount: string;
+}
+export interface SolanaTxAdditionalInfo {
+    tokenAccountsInfos?: SolanaTxTokenAccountInfo[];
+}
+export interface SolanaSignTransaction {
+    path: string | number[];
+    serializedTx: string;
+    additionalInfo?: SolanaTxAdditionalInfo;
+}
+export interface SolanaSignedTransaction {
+    signature: string;
+}
+//# sourceMappingURL=index.d.ts.map

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

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

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

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

package/lib/types/api/solanaGetAddress.js

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

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

@@ -0,0 +1,5 @@
+import type { GetPublicKey, Params, BundledParams, Response } from '../params';
+import type { SolanaPublicKey } from './solana';
+export declare function solanaGetPublicKey(params: Params<GetPublicKey>): Response<SolanaPublicKey>;
+export declare function solanaGetPublicKey(params: BundledParams<GetPublicKey>): Response<SolanaPublicKey[]>;
+//# sourceMappingURL=solanaGetPublicKey.d.ts.map

package/lib/types/api/solanaGetPublicKey.js

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

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

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

package/lib/types/api/solanaSignTransaction.js

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

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

@@ -55,5 +55,6 @@ export interface TezosSignTransaction {
     path: DerivationPath;
     branch: string;
     operation: TezosOperation;
+    chunkify?: boolean;
 }
 //# sourceMappingURL=index.d.ts.map

package/lib/types/coinInfo.d.ts

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

package/lib/types/device.d.ts

@@ -2,7 +2,7 @@ import type { PROTO } from '../constants';
 import type { ReleaseInfo } from './firmware';
 export type DeviceStatus = 'available' | 'occupied' | 'used';
 export type DeviceMode = 'normal' | 'bootloader' | 'initialize' | 'seedless';
-export type DeviceFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'none';
+export type DeviceFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'custom' | 'none';
 export type UnavailableCapability = 'no-capability' | 'no-support' | 'update-required' | 'trezor-connect-outdated';
 export declare enum FirmwareType {
     BitcoinOnly = "bitcoin-only",

package/lib/types/device.js

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