@trezor/connect 9.1.9 → 9.1.10

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 9.1.10
+
+-   chore(connect): bump ADA support version, min required version is now 2.4.3 (7937fea3ec)
+-   fix(connect): always check ADA passphrase (42c28cc95d)
+-   chore(connect): decrease build size by using lib of utils which is not treeshaken (b4ab48b25f)
+-   refactor(connect): rework validation of input params (0c035c26a6, 44430e47ff, c78cd9ad28, c5e9d50bf4)
+
 # 9.1.9
 
 -   fix(connect-popup): webusb pairing in webextensions using manifest version 2 [#10709](https://github.com/trezor/trezor-suite/pull/10709).

package/README.md

@@ -1,6 +1,6 @@
 # @trezor/connect
 
-API version 9.1.9
+API version 9.1.10
 
 [![Build Status](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml/badge.svg)](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml)
 [![NPM](https://img.shields.io/npm/v/@trezor/connect.svg)](https://www.npmjs.org/package/@trezor/connect)

package/lib/api/applyFlags.d.ts

@@ -1,8 +1,10 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { PROTO } from '../constants';
+import { PROTO } from '../constants';
 export default class ApplyFlags extends AbstractMethod<'applyFlags', PROTO.ApplyFlags> {
     init(): void;
     confirmation(): Promise<boolean>;
-    run(): Promise<PROTO.Success>;
+    run(): Promise<{
+        message: string;
+    }>;
 }
 //# sourceMappingURL=applyFlags.d.ts.map

package/lib/api/applyFlags.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
 const events_1 = require("../events");
+const constants_1 = require("../constants");
+const schema_utils_1 = require("@trezor/schema-utils");
 class ApplyFlags extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['management'];
         this.useDeviceState = false;
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [{ name: 'flags', type: 'number', required: true }]);
+        (0, schema_utils_1.Assert)(constants_1.PROTO.ApplyFlags, payload);
         this.params = {
             flags: payload.flags,
         };

package/lib/api/applySettings.d.ts

@@ -1,8 +1,10 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { PROTO } from '../constants';
+import { PROTO } from '../constants';
 export default class ApplySettings extends AbstractMethod<'applySettings', PROTO.ApplySettings> {
     init(): void;
     confirmation(): Promise<boolean>;
-    run(): Promise<PROTO.Success>;
+    run(): Promise<{
+        message: string;
+    }>;
 }
 //# sourceMappingURL=applySettings.d.ts.map

package/lib/api/applySettings.js

@@ -2,24 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractMethod_1 = require("../core/AbstractMethod");
 const events_1 = require("../events");
-const paramsValidator_1 = require("./common/paramsValidator");
+const schema_utils_1 = require("@trezor/schema-utils");
+const applySettings_1 = require("../types/api/applySettings");
 class ApplySettings extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['management'];
         this.useDeviceState = false;
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [
-            { name: 'language', type: 'string' },
-            { name: 'label', type: 'string' },
-            { name: 'use_passphrase', type: 'boolean' },
-            { name: 'homescreen', type: 'string' },
-            { name: 'passphrase_source', type: 'number' },
-            { name: 'passphrase_always_on_device', type: 'boolean' },
-            { name: 'auto_lock_delay_ms', type: 'number' },
-            { name: 'display_rotation', type: 'number' },
-            { name: 'safety_checks', type: 'string' },
-            { name: 'experimental_features', type: 'boolean' },
-        ]);
+        (0, schema_utils_1.Assert)(applySettings_1.ApplySettings, payload);
         this.params = {
             language: payload.language,
             label: payload.label,

package/lib/api/authenticateDevice.js

@@ -4,7 +4,9 @@ const AbstractMethod_1 = require("../core/AbstractMethod");
 const events_1 = require("../events");
 const paramsValidator_1 = require("./common/paramsValidator");
 const deviceAuthenticityConfig_1 = require("../data/deviceAuthenticityConfig");
+const authenticateDevice_1 = require("../types/api/authenticateDevice");
 const verifyAuthenticityProof_1 = require("./firmware/verifyAuthenticityProof");
+const schema_utils_1 = require("@trezor/schema-utils");
 class AuthenticateDevice extends AbstractMethod_1.AbstractMethod {
     init() {
         this.useEmptyPassphrase = true;
@@ -13,17 +15,7 @@ class AuthenticateDevice extends AbstractMethod_1.AbstractMethod {
         this.useDeviceState = false;
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [
-            { name: 'config', type: 'object' },
-            { name: 'allowDebugKeys', type: 'boolean' },
-        ]);
-        if (payload.config) {
-            (0, paramsValidator_1.validateParams)(payload.config, [{ name: 'timestamp', type: 'string', required: true }]);
-            (0, paramsValidator_1.validateParams)(payload.config.T2B1, [
-                { name: 'rootPubKeys', type: 'array', required: true },
-                { name: 'caPubKeys', type: 'array', required: true },
-            ]);
-        }
+        (0, schema_utils_1.Assert)(authenticateDevice_1.AuthenticateDeviceParams, payload);
         this.params = {
             config: payload.config,
             allowDebugKeys: payload.allowDebugKeys,

package/lib/api/authorizeCoinjoin.d.ts

@@ -2,6 +2,8 @@ import { AbstractMethod } from '../core/AbstractMethod';
 import { PROTO } from '../constants';
 export default class AuthorizeCoinjoin extends AbstractMethod<'authorizeCoinjoin', PROTO.AuthorizeCoinJoin> {
     init(): void;
-    run(): Promise<PROTO.Success>;
+    run(): Promise<{
+        message: string;
+    }>;
 }
 //# sourceMappingURL=authorizeCoinjoin.d.ts.map

package/lib/api/authorizeCoinjoin.js

@@ -4,20 +4,12 @@ const AbstractMethod_1 = require("../core/AbstractMethod");
 const paramsValidator_1 = require("./common/paramsValidator");
 const pathUtils_1 = require("../utils/pathUtils");
 const coinInfo_1 = require("../data/coinInfo");
+const schema_utils_1 = require("@trezor/schema-utils");
+const authorizeCoinjoin_1 = require("../types/api/authorizeCoinjoin");
 class AuthorizeCoinjoin extends AbstractMethod_1.AbstractMethod {
     init() {
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [
-            { name: 'path', required: true },
-            { name: 'coordinator', type: 'string', required: true },
-            { name: 'maxRounds', type: 'number', required: true },
-            { name: 'maxCoordinatorFeeRate', type: 'number', required: true },
-            { name: 'maxFeePerKvbyte', type: 'number', required: true },
-            { name: 'coin', type: 'string' },
-            { name: 'scriptType', type: 'string' },
-            { name: 'amountUnit', type: 'uint' },
-            { name: 'preauthorized', type: 'boolean' },
-        ]);
+        (0, schema_utils_1.Assert)(authorizeCoinjoin_1.AuthorizeCoinjoin, payload);
         const address_n = (0, pathUtils_1.validatePath)(payload.path, 3);
         const script_type = payload.scriptType || (0, pathUtils_1.getScriptType)(address_n);
         const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin || address_n);

package/lib/api/backupDevice.d.ts

@@ -2,6 +2,8 @@ import { AbstractMethod } from '../core/AbstractMethod';
 export default class BackupDevice extends AbstractMethod<'backupDevice'> {
     init(): void;
     confirmation(): Promise<boolean>;
-    run(): Promise<import("packages/protobuf/lib/messages").Success>;
+    run(): Promise<{
+        message: string;
+    }>;
 }
 //# sourceMappingURL=backupDevice.d.ts.map

package/lib/api/binance/api/binanceGetAddress.d.ts

@@ -16,8 +16,10 @@ export default class BinanceGetAddress extends AbstractMethod<'binanceGetAddress
     } | undefined;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(): Promise<boolean>;
-    _call({ address_n, show_display, chunkify }: Params): Promise<PROTO.BinanceAddress>;
-    run(): Promise<import("../../..").Address | import("../../..").Address[]>;
+    _call({ address_n, show_display, chunkify }: Params): Promise<{
+        address: string;
+    }>;
+    run(): Promise<import("../../../types").Address | import("../../../types").Address[]>;
 }
 export {};
 //# sourceMappingURL=binanceGetAddress.d.ts.map

package/lib/api/binance/api/binanceGetAddress.js

@@ -6,6 +6,9 @@ const coinInfo_1 = require("../../../data/coinInfo");
 const pathUtils_1 = require("../../../utils/pathUtils");
 const constants_1 = require("../../../constants");
 const events_1 = require("../../../events");
+const schema_utils_1 = require("@trezor/schema-utils");
+const types_1 = require("../../../types");
+const getAddress_1 = require("../../../types/api/getAddress");
 class BinanceGetAddress extends AbstractMethod_1.AbstractMethod {
     constructor() {
         super(...arguments);
@@ -18,17 +21,8 @@ class BinanceGetAddress extends AbstractMethod_1.AbstractMethod {
         const payload = !this.payload.bundle
             ? { ...this.payload, bundle: [this.payload] }
             : this.payload;
-        (0, paramsValidator_1.validateParams)(payload, [
-            { name: 'bundle', type: 'array' },
-            { name: 'useEventListener', type: 'boolean' },
-        ]);
+        (0, schema_utils_1.Assert)((0, types_1.Bundle)(getAddress_1.GetAddress), payload);
         this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'address', type: 'string' },
-                { name: 'showOnTrezor', type: 'boolean' },
-                { name: 'chunkify', type: 'boolean' },
-            ]);
             const path = (0, pathUtils_1.validatePath)(batch.path, 3);
             return {
                 address_n: path,

package/lib/api/binance/api/binanceGetPublicKey.d.ts

@@ -6,6 +6,14 @@ export default class BinanceGetPublicKey extends AbstractMethod<'binanceGetPubli
     init(): void;
     get info(): string;
     confirmation(): Promise<boolean>;
-    run(): Promise<import("../../..").PublicKey | import("../../..").PublicKey[]>;
+    run(): Promise<{
+        path: number[];
+        publicKey: string;
+        serializedPath: string;
+    } | {
+        path: number[];
+        publicKey: string;
+        serializedPath: string;
+    }[]>;
 }
 //# sourceMappingURL=binanceGetPublicKey.d.ts.map

package/lib/api/binance/api/binanceGetPublicKey.js

@@ -5,6 +5,8 @@ const paramsValidator_1 = require("../../common/paramsValidator");
 const coinInfo_1 = require("../../../data/coinInfo");
 const pathUtils_1 = require("../../../utils/pathUtils");
 const events_1 = require("../../../events");
+const schema_utils_1 = require("@trezor/schema-utils");
+const types_1 = require("../../../types");
 class BinanceGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
@@ -13,12 +15,8 @@ class BinanceGetPublicKey extends AbstractMethod_1.AbstractMethod {
         const payload = !this.payload.bundle
             ? { ...this.payload, bundle: [this.payload] }
             : this.payload;
-        (0, paramsValidator_1.validateParams)(payload, [{ name: 'bundle', type: 'array' }]);
+        (0, schema_utils_1.Assert)((0, types_1.Bundle)(types_1.GetPublicKey), payload);
         this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'showOnTrezor', type: 'boolean' },
-            ]);
             const path = (0, pathUtils_1.validatePath)(batch.path, 3);
             return {
                 address_n: path,

package/lib/api/binance/api/binanceSignTransaction.d.ts

@@ -8,7 +8,10 @@ type Params = {
 export default class BinanceSignTransaction extends AbstractMethod<'binanceSignTransaction', Params> {
     init(): void;
     get info(): string;
-    run(): Promise<import("packages/protobuf/lib/messages").BinanceSignedTx>;
+    run(): Promise<{
+        signature: string;
+        public_key: string;
+    }>;
 }
 export {};
 //# sourceMappingURL=binanceSignTransaction.d.ts.map

package/lib/api/binance/api/binanceSignTransaction.js

@@ -6,22 +6,21 @@ const paramsValidator_1 = require("../../common/paramsValidator");
 const coinInfo_1 = require("../../../data/coinInfo");
 const pathUtils_1 = require("../../../utils/pathUtils");
 const helper = tslib_1.__importStar(require("../binanceSignTx"));
+const binance_1 = require("../../../types/api/binance");
+const schema_utils_1 = require("@trezor/schema-utils");
 class BinanceSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
+        var _a;
         this.requiredPermissions = ['read', 'write'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('BNB'), this.firmwareRange);
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [
-            { name: 'path', type: 'string', required: true },
-            { name: 'transaction', required: true },
-            { name: 'chunkify', type: 'boolean' },
-        ]);
+        (0, schema_utils_1.Assert)(binance_1.BinanceSignTransaction, payload);
         const path = (0, pathUtils_1.validatePath)(payload.path, 3);
         const transaction = helper.validate(payload.transaction);
         this.params = {
             path,
             transaction,
-            chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false,
+            chunkify: (_a = payload.chunkify) !== null && _a !== void 0 ? _a : false,
         };
     }
     get info() {

package/lib/api/binance/binanceSignTx.d.ts

@@ -1,6 +1,87 @@
 import { PROTO } from '../../constants';
-import type { BinanceSDKTransaction, BinancePreparedTransaction } from '../../types/api/binance';
+import { BinanceSDKTransaction, BinancePreparedTransaction } from '../../types/api/binance';
 import type { TypedCall } from '../../device/DeviceCommands';
-export declare const validate: (tx: BinanceSDKTransaction) => BinancePreparedTransaction;
-export declare const signTx: (typedCall: TypedCall, address_n: number[], tx: BinancePreparedTransaction, chunkify?: boolean) => Promise<PROTO.BinanceSignedTx>;
+export declare const validate: (tx: BinanceSDKTransaction) => {
+    account_number?: number | undefined;
+    memo?: string | undefined;
+    sequence?: number | undefined;
+    source?: number | undefined;
+    transfer?: {
+        chunkify?: boolean | undefined;
+        inputs: {
+            address: string;
+            coins: {
+                amount: string | number;
+                denom: string;
+            }[];
+        }[];
+        outputs: {
+            address: string;
+            coins: {
+                amount: string | number;
+                denom: string;
+            }[];
+        }[];
+    } | undefined;
+    placeOrder?: {
+        symbol?: string | undefined;
+        id?: string | undefined;
+        sender?: string | undefined;
+        ordertype: PROTO.BinanceOrderType;
+        price: number;
+        quantity: number;
+        side: PROTO.BinanceOrderSide;
+        timeinforce: PROTO.BinanceTimeInForce;
+    } | undefined;
+    cancelOrder?: {
+        symbol?: string | undefined;
+        sender?: string | undefined;
+        refid?: string | undefined;
+    } | undefined;
+    chain_id: string;
+} & {
+    account_number: number;
+    sequence: number;
+    source: number;
+    messages: (({
+        chunkify?: boolean | undefined;
+        inputs: {
+            address: string;
+            coins: {
+                amount: string | number;
+                denom: string;
+            }[];
+        }[];
+        outputs: {
+            address: string;
+            coins: {
+                amount: string | number;
+                denom: string;
+            }[];
+        }[];
+    } & {
+        type: "BinanceTransferMsg";
+    }) | ({
+        symbol?: string | undefined;
+        id?: string | undefined;
+        sender?: string | undefined;
+        ordertype: PROTO.BinanceOrderType;
+        price: number;
+        quantity: number;
+        side: PROTO.BinanceOrderSide;
+        timeinforce: PROTO.BinanceTimeInForce;
+    } & {
+        type: "BinanceOrderMsg";
+    }) | ({
+        symbol?: string | undefined;
+        sender?: string | undefined;
+        refid?: string | undefined;
+    } & {
+        type: "BinanceCancelMsg";
+    }))[];
+};
+export declare const signTx: (typedCall: TypedCall, address_n: number[], tx: BinancePreparedTransaction, chunkify?: boolean) => Promise<{
+    signature: string;
+    public_key: string;
+}>;
 //# sourceMappingURL=binanceSignTx.d.ts.map

package/lib/api/binance/binanceSignTx.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.signTx = exports.validate = void 0;
 const constants_1 = require("../../constants");
-const paramsValidator_1 = require("../common/paramsValidator");
+const binance_1 = require("../../types/api/binance");
+const schema_utils_1 = require("@trezor/schema-utils");
 const processTxRequest = async (typedCall, messages, index) => {
     const { type, ...params } = messages[index];
     const lastOp = index + 1 >= messages.length;
@@ -15,14 +16,7 @@ const processTxRequest = async (typedCall, messages, index) => {
     return processTxRequest(typedCall, messages, index);
 };
 const validate = (tx) => {
-    (0, paramsValidator_1.validateParams)(tx, [
-        { name: 'chain_id', type: 'string', required: true },
-        { name: 'account_number', type: 'number' },
-        { name: 'memo', type: 'string' },
-        { name: 'sequence', type: 'number' },
-        { name: 'source', type: 'number' },
-        { name: 'message', type: 'object' },
-    ]);
+    (0, schema_utils_1.Assert)(binance_1.BinanceSDKTransaction, tx);
     const preparedTx = {
         chain_id: tx.chain_id,
         account_number: tx.account_number || 0,
@@ -33,35 +27,18 @@ const validate = (tx) => {
     };
     const { transfer, placeOrder, cancelOrder } = tx;
     if (transfer) {
-        (0, paramsValidator_1.validateParams)(transfer, [
-            { name: 'inputs', type: 'array', required: true },
-            { name: 'outputs', type: 'array', required: true },
-        ]);
         preparedTx.messages.push({
             ...transfer,
             type: 'BinanceTransferMsg',
         });
     }
     if (placeOrder) {
-        (0, paramsValidator_1.validateParams)(placeOrder, [
-            { name: 'id', type: 'string' },
-            { name: 'ordertype', type: 'number' },
-            { name: 'price', type: 'number' },
-            { name: 'quantity', type: 'number' },
-            { name: 'sender', type: 'string' },
-            { name: 'side', type: 'number' },
-        ]);
         preparedTx.messages.push({
             ...placeOrder,
             type: 'BinanceOrderMsg',
         });
     }
     if (cancelOrder) {
-        (0, paramsValidator_1.validateParams)(cancelOrder, [
-            { name: 'refid', type: 'string', required: true },
-            { name: 'sender', type: 'string', required: true },
-            { name: 'symbol', type: 'string', required: true },
-        ]);
         preparedTx.messages.push({
             ...cancelOrder,
             type: 'BinanceCancelMsg',

package/lib/api/bitcoin/Fees.d.ts

@@ -7,8 +7,20 @@ export declare class FeeLevels {
     longTermFeeRate?: string;
     blocks: Blocks;
     constructor(coinInfo: CoinInfo);
-    loadMisc(blockchain: Blockchain): Promise<FeeLevel[]>;
-    load(blockchain: Blockchain): Promise<FeeLevel[]>;
+    loadMisc(blockchain: Blockchain): Promise<{
+        feeLimit?: string | undefined;
+        feePerTx?: string | undefined;
+        label: "high" | "normal" | "economy" | "low" | "custom";
+        feePerUnit: string;
+        blocks: number;
+    }[]>;
+    load(blockchain: Blockchain): Promise<{
+        feeLimit?: string | undefined;
+        feePerTx?: string | undefined;
+        label: "high" | "normal" | "economy" | "low" | "custom";
+        feePerUnit: string;
+        blocks: number;
+    }[]>;
     updateCustomFee(feePerUnit: string): void;
 }
 export {};

package/lib/api/bitcoin/TransactionComposer.d.ts

@@ -1,7 +1,7 @@
 import { ComposeOutput } from '@trezor/utxo-lib';
 import { FeeLevels } from './Fees';
 import { Blockchain } from '../../backend/BlockchainLink';
-import type { BitcoinNetworkInfo, DiscoveryAccount, SelectFeeLevel } from '../../types';
+import type { BitcoinNetworkInfo, DiscoveryAccount } from '../../types';
 import type { ComposeUtxo, ComposedInputs, ComposeResult } from '../../types/api/composeTransaction';
 type Options = {
     account: DiscoveryAccount;
@@ -27,7 +27,18 @@ export declare class TransactionComposer {
     init(blockchain: Blockchain): Promise<void>;
     composeAllFeeLevels(): boolean;
     composeCustomFee(fee: string): void;
-    getFeeLevelList(): SelectFeeLevel[];
+    getFeeLevelList(): ({
+        feePerByte?: undefined;
+        name: string;
+        fee: "0";
+        disabled: true;
+    } | {
+        name: string;
+        fee: string;
+        feePerByte: string;
+        minutes: number;
+        total: string;
+    })[];
     compose(feeRate: string): ComposeResult;
     dispose(): void;
 }

package/lib/api/bitcoin/refTx.d.ts

@@ -1,11 +1,11 @@
 import { Transaction as BitcoinJsTransaction, Network } from '@trezor/utxo-lib';
 import type { CoinInfo, AccountAddresses, AccountTransaction, BitcoinNetworkInfo } from '../../types';
 import type { RefTransaction, TransactionOptions } from '../../types/api/bitcoin';
-import type { PROTO } from '../../constants';
+import { PROTO } from '../../constants';
 export declare const requireReferencedTransactions: (inputs: PROTO.TxInputType[], options?: TransactionOptions, coinInfo?: CoinInfo) => boolean;
 export declare const getReferencedTransactions: (inputs: PROTO.TxInputType[]) => string[];
 export declare const getOrigTransactions: (inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[]) => string[];
-export declare const parseTransactionHexes: (network?: Network) => (hexes: string[]) => (import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<undefined> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("packages/utxo-lib/lib/transaction/dash").DashSpecific> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("packages/utxo-lib/lib/transaction/zcash").ZcashSpecific>)[];
+export declare const parseTransactionHexes: (network?: Network) => (hexes: string[]) => (import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<undefined> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("@trezor/utxo-lib/lib/transaction/dash").DashSpecific> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("@trezor/utxo-lib/lib/transaction/zcash").ZcashSpecific>)[];
 export declare const transformOrigTransactions: (txs: BitcoinJsTransaction[], coinInfo: BitcoinNetworkInfo, currentInputs: PROTO.TxInputType[], addresses: AccountAddresses) => RefTransaction[];
 export declare const transformReferencedTransaction: (tx: BitcoinJsTransaction) => RefTransaction;
 export declare const transformReferencedTransactions: (txs: BitcoinJsTransaction[]) => RefTransaction[];

package/lib/api/bitcoin/refTx.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateReferencedTransactions = exports.transformReferencedTransactions = exports.transformReferencedTransaction = exports.transformOrigTransactions = exports.parseTransactionHexes = exports.getOrigTransactions = exports.getReferencedTransactions = exports.requireReferencedTransactions = void 0;
+const tslib_1 = require("tslib");
 const utxo_lib_1 = require("@trezor/utxo-lib");
-const utils_1 = require("@trezor/utils");
+const bufferUtils = tslib_1.__importStar(require("@trezor/utils/lib/bufferUtils"));
 const pathUtils_1 = require("../../utils/pathUtils");
-const paramsValidator_1 = require("../common/paramsValidator");
 const errors_1 = require("../../constants/errors");
+const constants_1 = require("../../constants");
+const schema_utils_1 = require("@trezor/schema-utils");
 const requireReferencedTransactions = (inputs, options = {}, coinInfo) => {
     if ((coinInfo === null || coinInfo === void 0 ? void 0 : coinInfo.shortcut) === 'ZEC' || (coinInfo === null || coinInfo === void 0 ? void 0 : coinInfo.shortcut) === 'TAZ') {
         return !(options.version && options.version >= 5);
@@ -75,7 +77,7 @@ const parseOutputScript = (output, network) => {
 const transformOrigTransaction = (tx, coinInfo, currentInputs, addresses) => {
     const inputsMap = (input, i) => {
         var _a;
-        const prev_hash = utils_1.bufferUtils.reverseBuffer(input.hash).toString('hex');
+        const prev_hash = bufferUtils.reverseBuffer(input.hash).toString('hex');
         const currentInput = currentInputs.find(inp => inp.prev_hash === prev_hash && inp.prev_index === input.index);
         if (!(currentInput === null || currentInput === void 0 ? void 0 : currentInput.address_n)) {
             throw (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid input at ${tx.getId()} [${i}]`);
@@ -149,7 +151,7 @@ const transformReferencedTransaction = (tx) => {
     const inputsMap = (input) => ({
         prev_index: input.index,
         sequence: input.sequence,
-        prev_hash: utils_1.bufferUtils.reverseBuffer(input.hash).toString('hex'),
+        prev_hash: bufferUtils.reverseBuffer(input.hash).toString('hex'),
         script_sig: input.script.toString('hex'),
     });
     const binOutputsMap = (output) => ({
@@ -187,29 +189,25 @@ const validateReferencedTransactions = ({ transactions, inputs, outputs, address
             }
             return (0, exports.transformReferencedTransaction)(srcTx);
         }
-        (0, paramsValidator_1.validateParams)(tx, [
-            { name: 'hash', type: 'string', required: true },
-            { name: 'inputs', type: 'array', required: true },
-            { name: 'version', type: 'number', required: true },
-            { name: 'lock_time', type: 'number', required: true },
-            { name: 'extra_data', type: 'string' },
-            { name: 'timestamp', type: 'number' },
-            { name: 'version_group_id', type: 'number' },
-        ]);
+        (0, schema_utils_1.Assert)(schema_utils_1.Type.Object({
+            hash: schema_utils_1.Type.String(),
+            version: schema_utils_1.Type.Number(),
+            lock_time: schema_utils_1.Type.Number(),
+            extra_data: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+            timestamp: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+            version_group_id: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+        }), tx);
         if (origTxs.includes(tx.hash)) {
-            (0, paramsValidator_1.validateParams)(tx, [{ name: 'outputs', type: 'array', required: true }]);
+            (0, schema_utils_1.Assert)(schema_utils_1.Type.Object({
+                inputs: schema_utils_1.Type.Array(constants_1.PROTO.TxInput, { minItems: 1 }),
+                outputs: schema_utils_1.Type.Array(constants_1.PROTO.TxOutputType, { minItems: 1 }),
+            }), tx);
             return tx;
         }
-        (0, paramsValidator_1.validateParams)(tx, [{ name: 'bin_outputs', type: 'array', required: true }]);
-        tx.inputs.forEach(input => {
-            (0, paramsValidator_1.validateParams)(input, [
-                { name: 'prev_hash', type: 'string', required: true },
-                { name: 'prev_index', type: 'number', required: true },
-                { name: 'script_sig', type: 'string', required: true },
-                { name: 'sequence', type: 'number', required: true },
-                { name: 'decred_tree', type: 'number' },
-            ]);
-        });
+        (0, schema_utils_1.Assert)(schema_utils_1.Type.Object({
+            inputs: schema_utils_1.Type.Array(constants_1.PROTO.PrevInput, { minItems: 1 }),
+            bin_outputs: schema_utils_1.Type.Array(constants_1.PROTO.TxOutputBinType, { minItems: 1 }),
+        }), tx);
         return {
             hash: tx.hash,
             version: tx.version,

package/lib/api/bitcoin/signtxVerify.d.ts

@@ -2,7 +2,7 @@ import { PROTO } from '../../constants';
 import type { BitcoinNetworkInfo } from '../../types';
 import type { DeviceCommands } from '../../device/DeviceCommands';
 type GetHDNode = DeviceCommands['getHDNode'];
-export declare const verifyTx: (getHDNode: GetHDNode, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], serializedTx: string, coinInfo: BitcoinNetworkInfo, unlockPath?: PROTO.UnlockPath) => Promise<import("packages/utxo-lib/lib/transaction/base").TransactionBase<undefined> | import("packages/utxo-lib/lib/transaction/base").TransactionBase<import("packages/utxo-lib/lib/transaction/dash").DashSpecific> | import("packages/utxo-lib/lib/transaction/base").TransactionBase<import("packages/utxo-lib/lib/transaction/zcash").ZcashSpecific>>;
+export declare const verifyTx: (getHDNode: GetHDNode, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], serializedTx: string, coinInfo: BitcoinNetworkInfo, unlockPath?: PROTO.UnlockPath) => Promise<import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<undefined> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("@trezor/utxo-lib/lib/transaction/dash").DashSpecific> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("@trezor/utxo-lib/lib/transaction/zcash").ZcashSpecific>>;
 export declare const verifyTicketTx: (getHDNode: GetHDNode, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], serializedTx: string, coinInfo: BitcoinNetworkInfo) => Promise<void>;
 export {};
 //# sourceMappingURL=signtxVerify.d.ts.map

package/lib/api/blockchainDisconnect.d.ts

@@ -1,5 +1,5 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { CoinInfo } from '../types';
+import { CoinInfo } from '../types';
 type Params = {
     coinInfo: CoinInfo;
 };