@trezor/connect 9.1.6 → 9.1.8

package/CHANGELOG.md

@@ -1,3 +1,46 @@
+# 9.1.8
+
+-   fix(connect-explorer): eth getAccountInfo coin fix (0108b96)
+-   fix(connect): do not check firmware range for devices in bootloader (ed53f9f)
+-   feat(connect): add changeWipeCode method (b85d957)
+-   deps(connect-plugin-ethereum): @metamask/eth-sig-util@^7.0.0->^7.0.1 (e24c80a)
+-   chore(connect): improve origTxs and refTxs (ffcb3ee)
+-   feat(connect): blockchain-link API adjusted (2df1416)
+-   chore(connect-explorer): add ADA params (9969d65)
+
+# 9.1.7
+
+-   fix(connect): correct UiRequestConfirmation type in solanaGetPublicKey (a93ea1890)
+-   chore(connect): stricter UiRequestConfirmation types (f35bd28bf)
+-   feat(connect-common): add more backend urls for solana (29f042470)
+-   chore: Throttler throttling instead of debouncing in `@trezor/blockchain-link` (#10288) (f7ff0cf9f)
+-   feat(transport): accept encoding protocols as parameter of send, receive and call methods (b64af958e)
+-   fix(connect-explorer): fs, path, fallbacks in webpack (4f5a15e32)
+-   chore(connect-common): update fw binaries to 2.6.4 (398509788)
+-   docs(connect): update index page (8cb5262f6)
+-   feat(connect-explorer): update SVG in Header component (e8d9beace)
+-   feat(connect-explorer): update favicon image (a8d660dd2)
+-   feat(connect-explorer): add Solana (799bf63f5)
+-   chore(connect): update downgraded @ethereumjs libs (9ac430c42)
+-   chore(connect): add option for chunkify solana `getAddress` method (98d234f31)
+-   fix(connect-explorer-webextension): add commitHash to webpack (6b6b77d9d)
+-   feat(suite): add Solana support (f2a89b34f)
+-   chore: add Holesky (175707861,8776bb79c)
+-   feat(connect-explorer): version docs (6ea9ef1f2)
+-   fix(connect-popup): when connect-src not same as host popup display unknown origin (1bc6f2da1)
+-   feat(connect-explorer, connect): add `chunkify` paramater to getAddress and signTx methods (7e01923f0,2926b2bdb)
+-   fix(connect-popup): handle METHOD_INFO (e6d11072b)
+-   fix(connect): support unknown (custom) internal_models (0915d8893)
+-   fix(cardano): fee estimate for set-max output (c50a8f2c7)
+-   chore(connect): use `tslib` as dependency in all public libs (606ecc63b)
+-   chore: update `jest` and related dependency (b8a321c83)
+-   chore(connect-examples): cleanup unused lines in script (b509d24d5)
+-   chore(connect-webextension): postMessage useQueue param (4e626e758)
+-   chore(repo): update tsx (53de3e3a8)
+-   chore(connect): remove Solana beta console logs (3ea8343ee)
+-   chore(docs): add link to internal description of device authenticity config update (ee9ad470a)
+-   chore(connect): add new CA pubkeys and update timestamp (b64c3f411)
+
 # 9.1.6
 
 -   chore(connect): remove web3-utils (2f683f6)

package/README.md

@@ -1,6 +1,6 @@
 # @trezor/connect
 
-API version 9.1.6
+API version 9.1.8
 
 [![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/binance/api/binanceGetAddress.d.ts

@@ -16,7 +16,7 @@ export default class BinanceGetAddress extends AbstractMethod<'binanceGetAddress
     } | undefined;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(): Promise<boolean>;
-    _call({ address_n, show_display }: Params): Promise<PROTO.BinanceAddress>;
+    _call({ address_n, show_display, chunkify }: Params): Promise<PROTO.BinanceAddress>;
     run(): Promise<import("../../..").Address | import("../../..").Address[]>;
 }
 export {};

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

@@ -27,12 +27,14 @@ class BinanceGetAddress extends AbstractMethod_1.AbstractMethod {
                 { 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,
                 address: batch.address,
                 show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+                chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false,
             };
         });
         const useEventListener = payload.useEventListener &&
@@ -79,11 +81,12 @@ class BinanceGetAddress extends AbstractMethod_1.AbstractMethod {
         const uiResp = await uiPromise.promise;
         return uiResp.payload;
     }
-    async _call({ address_n, show_display }) {
+    async _call({ address_n, show_display, chunkify }) {
         const cmd = this.device.getCommands();
         const response = await cmd.typedCall('BinanceGetAddress', 'BinanceAddress', {
             address_n,
             show_display,
+            chunkify,
         });
         return response.message;
     }

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

@@ -3,6 +3,7 @@ import type { BinancePreparedTransaction } from '../../../types/api/binance';
 type Params = {
     path: number[];
     transaction: BinancePreparedTransaction;
+    chunkify?: boolean;
 };
 export default class BinanceSignTransaction extends AbstractMethod<'binanceSignTransaction', Params> {
     init(): void;

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

@@ -14,19 +14,21 @@ class BinanceSignTransaction extends AbstractMethod_1.AbstractMethod {
         (0, paramsValidator_1.validateParams)(payload, [
             { name: 'path', type: 'string', required: true },
             { name: 'transaction', required: true },
+            { name: 'chunkify', type: 'boolean' },
         ]);
         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,
         };
     }
     get info() {
         return 'Sign Binance transaction';
     }
     run() {
-        return helper.signTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.transaction);
+        return helper.signTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.transaction, this.params.chunkify);
     }
 }
 exports.default = BinanceSignTransaction;

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

@@ -2,5 +2,5 @@ import { PROTO } from '../../constants';
 import type { 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) => Promise<PROTO.BinanceSignedTx>;
+export declare const signTx: (typedCall: TypedCall, address_n: number[], tx: BinancePreparedTransaction, chunkify?: boolean) => Promise<PROTO.BinanceSignedTx>;
 //# sourceMappingURL=binanceSignTx.d.ts.map

package/lib/api/binance/binanceSignTx.js

@@ -73,7 +73,7 @@ const validate = (tx) => {
     return preparedTx;
 };
 exports.validate = validate;
-const signTx = async (typedCall, address_n, tx) => {
+const signTx = async (typedCall, address_n, tx, chunkify) => {
     const { account_number, chain_id, memo, sequence, source, messages } = tx;
     const msg_count = messages.length;
     await typedCall('BinanceSignTx', 'BinanceTxRequest', {
@@ -84,6 +84,7 @@ const signTx = async (typedCall, address_n, tx) => {
         memo,
         sequence,
         source,
+        chunkify,
     });
     return processTxRequest(typedCall, messages, 0);
 };

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

@@ -1,8 +1,8 @@
-import type { TypedRawTransaction } from '@trezor/blockchain-link';
+import { Transaction as BitcoinJsTransaction } from '@trezor/utxo-lib';
 import type { BitcoinNetworkInfo, ProtoWithDerivationPath } from '../../types';
 import type { ComposeUtxo } from '../../types/api/composeTransaction';
 import type { PROTO } from '../../constants';
 export declare const validateTrezorInputs: (inputs: ProtoWithDerivationPath<PROTO.TxInputType>[], coinInfo: BitcoinNetworkInfo) => PROTO.TxInputType[];
-export declare const enhanceTrezorInputs: (inputs: PROTO.TxInputType[], rawTxs: TypedRawTransaction[]) => void;
+export declare const enhanceTrezorInputs: (inputs: PROTO.TxInputType[], rawTxs: BitcoinJsTransaction[]) => void;
 export declare const inputToTrezor: (input: ComposeUtxo, sequence?: number) => PROTO.TxInputType;
 //# sourceMappingURL=inputs.d.ts.map

package/lib/api/bitcoin/inputs.js

@@ -37,9 +37,9 @@ const enhanceTrezorInputs = (inputs, rawTxs) => {
     inputs.forEach(input => {
         if (!input.amount) {
             console.warn('TrezorConnect.singTransaction deprecation: missing input amount.');
-            const refTx = rawTxs.find(t => 'txid' in t.tx && t.tx.txid === input.prev_hash);
-            if (refTx && refTx.type === 'blockbook' && refTx.tx.vout[input.prev_index]) {
-                input.amount = refTx.tx.vout[input.prev_index].value;
+            const refTx = rawTxs.find(t => t.getId() === input.prev_hash);
+            if (refTx && refTx.outs[input.prev_index]) {
+                input.amount = refTx.outs[input.prev_index].value;
             }
         }
     });

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

@@ -1,19 +1,19 @@
-import { Transaction as BitcoinJsTransaction } from '@trezor/utxo-lib';
-import type { TypedRawTransaction } from '@trezor/blockchain-link';
-import type { CoinInfo, AccountAddresses, AccountTransaction } from '../../types';
+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';
 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 transformOrigTransactions: (txs: TypedRawTransaction[], coinInfo: CoinInfo, addresses?: AccountAddresses) => RefTransaction[];
+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 transformOrigTransactions: (txs: BitcoinJsTransaction[], coinInfo: BitcoinNetworkInfo, currentInputs: PROTO.TxInputType[], addresses: AccountAddresses) => RefTransaction[];
 export declare const transformReferencedTransaction: (tx: BitcoinJsTransaction) => RefTransaction;
-export declare const transformReferencedTransactions: (txs: TypedRawTransaction[], coinInfo: CoinInfo) => RefTransaction[];
+export declare const transformReferencedTransactions: (txs: BitcoinJsTransaction[]) => RefTransaction[];
 export declare const validateReferencedTransactions: ({ transactions, inputs, outputs, addresses, coinInfo, }: {
-    transactions?: (RefTransaction | AccountTransaction)[] | undefined;
+    transactions?: (AccountTransaction | RefTransaction)[] | undefined;
     inputs: PROTO.TxInputType[];
     outputs: PROTO.TxOutputType[];
     addresses?: AccountAddresses | undefined;
-    coinInfo: CoinInfo;
+    coinInfo: BitcoinNetworkInfo;
 }) => RefTransaction[] | undefined;
 //# sourceMappingURL=refTx.d.ts.map

package/lib/api/bitcoin/refTx.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateReferencedTransactions = exports.transformReferencedTransactions = exports.transformReferencedTransaction = exports.transformOrigTransactions = exports.getOrigTransactions = exports.getReferencedTransactions = exports.requireReferencedTransactions = void 0;
+exports.validateReferencedTransactions = exports.transformReferencedTransactions = exports.transformReferencedTransaction = exports.transformOrigTransactions = exports.parseTransactionHexes = exports.getOrigTransactions = exports.getReferencedTransactions = exports.requireReferencedTransactions = void 0;
 const utxo_lib_1 = require("@trezor/utxo-lib");
 const utils_1 = require("@trezor/utils");
 const pathUtils_1 = require("../../utils/pathUtils");
@@ -39,6 +39,8 @@ const getOrigTransactions = (inputs, outputs) => {
     return result;
 };
 exports.getOrigTransactions = getOrigTransactions;
+const parseTransactionHexes = (network) => (hexes) => hexes.map(hex => utxo_lib_1.Transaction.fromHex(hex, { network }));
+exports.parseTransactionHexes = parseTransactionHexes;
 const enhanceTransaction = (refTx, srcTx) => {
     const extraData = srcTx.getExtraData();
     if (extraData) {
@@ -55,27 +57,38 @@ const enhanceTransaction = (refTx, srcTx) => {
     }
     return refTx;
 };
-const transformOrigTransaction = (origTx, tx, addresses) => {
-    const { vin, vout, txid } = origTx;
-    const inputAddresses = addresses.used.concat(addresses.change).concat(addresses.unused);
+const parseOutputScript = (output, network) => {
+    try {
+        const address = utxo_lib_1.address.fromOutputScript(output, network);
+        return { type: 'address', address };
+    }
+    catch {
+        try {
+            const { data } = utxo_lib_1.payments.embed({ output }, { validate: true });
+            return { type: 'data', data };
+        }
+        catch {
+            return { type: 'unknown' };
+        }
+    }
+};
+const transformOrigTransaction = (tx, coinInfo, currentInputs, addresses) => {
     const inputsMap = (input, i) => {
         var _a;
-        const rawInput = vin[i];
-        if (!(rawInput === null || rawInput === void 0 ? void 0 : rawInput.value) || !(rawInput === null || rawInput === void 0 ? void 0 : rawInput.addresses) || rawInput.addresses.length !== 1) {
-            throw (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid input at ${txid} [${i}]`);
+        const prev_hash = utils_1.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}]`);
         }
-        const [address] = rawInput.addresses;
-        const inputAddress = inputAddresses.find(addr => addr.address === address);
-        const address_n = (0, pathUtils_1.getHDPath)((inputAddress === null || inputAddress === void 0 ? void 0 : inputAddress.path) || '');
         return {
-            address_n,
-            prev_hash: utils_1.bufferUtils.reverseBuffer(input.hash).toString('hex'),
+            address_n: currentInput.address_n,
+            prev_hash,
             prev_index: input.index,
             script_sig: input.script.toString('hex'),
             sequence: input.sequence,
-            script_type: (0, pathUtils_1.getScriptType)(address_n),
+            script_type: (0, pathUtils_1.getScriptType)(currentInput.address_n),
             multisig: undefined,
-            amount: rawInput.value,
+            amount: currentInput.amount,
             decred_tree: undefined,
             witness: (_a = tx.getWitness(i)) === null || _a === void 0 ? void 0 : _a.toString('hex'),
             ownership_proof: undefined,
@@ -83,38 +96,41 @@ const transformOrigTransaction = (origTx, tx, addresses) => {
         };
     };
     const outputsMap = (output, i) => {
-        var _a;
-        const rawOutput = vout[i];
-        if (!rawOutput.isAddress) {
-            const { data } = utxo_lib_1.payments.embed({ output: output.script });
-            const op_return_data = (_a = data === null || data === void 0 ? void 0 : data.shift()) === null || _a === void 0 ? void 0 : _a.toString('hex');
-            if (typeof op_return_data !== 'string') {
-                throw (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid op_return_data at ${txid} [${i}]`);
+        var _a, _b;
+        const parsed = parseOutputScript(output.script, coinInfo.network);
+        switch (parsed.type) {
+            case 'data': {
+                const op_return_data = (_b = (_a = parsed.data) === null || _a === void 0 ? void 0 : _a.shift()) === null || _b === void 0 ? void 0 : _b.toString('hex');
+                if (typeof op_return_data !== 'string') {
+                    throw (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid op_return_data at ${tx.getId()} [${i}]`);
+                }
+                return {
+                    script_type: 'PAYTOOPRETURN',
+                    amount: '0',
+                    op_return_data,
+                };
             }
-            return {
-                script_type: 'PAYTOOPRETURN',
-                amount: '0',
-                op_return_data,
-            };
-        }
-        if (!rawOutput.addresses || rawOutput.addresses.length !== 1) {
-            throw (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid output at ${txid} [${i}]`);
-        }
-        const [address] = rawOutput.addresses;
-        const changeAddress = addresses.change.find(addr => addr.address === address);
-        const address_n = changeAddress && (0, pathUtils_1.getHDPath)(changeAddress.path);
-        const amount = output.value.toString();
-        return address_n
-            ? {
-                address_n,
-                amount,
-                script_type: (0, pathUtils_1.getOutputScriptType)(address_n),
+            case 'address': {
+                const { address } = parsed;
+                const changeAddress = addresses.change.find(addr => addr.address === address);
+                const address_n = changeAddress && (0, pathUtils_1.getHDPath)(changeAddress.path);
+                const amount = output.value.toString();
+                return address_n
+                    ? {
+                        address_n,
+                        amount,
+                        script_type: (0, pathUtils_1.getOutputScriptType)(address_n),
+                    }
+                    : {
+                        address,
+                        amount,
+                        script_type: 'PAYTOADDRESS',
+                    };
             }
-            : {
-                address,
-                amount,
-                script_type: 'PAYTOADDRESS',
-            };
+            case 'unknown':
+            default:
+                throw (0, errors_1.TypedError)('Method_InvalidParameter', `transformOrigTransactions: invalid output at ${tx.getId()} [${i}]`);
+        }
     };
     const refTx = {
         version: tx.version,
@@ -127,13 +143,7 @@ const transformOrigTransaction = (origTx, tx, addresses) => {
     };
     return enhanceTransaction(refTx, tx);
 };
-const isTransactionWithHex = (tx) => tx.type === 'blockbook' && !!tx.tx.hex;
-const transformOrigTransactions = (txs, coinInfo, addresses) => coinInfo.type !== 'bitcoin' || !addresses
-    ? []
-    : txs.filter(isTransactionWithHex).map(raw => {
-        const tx = utxo_lib_1.Transaction.fromHex(raw.tx.hex, { network: coinInfo.network });
-        return transformOrigTransaction(raw.tx, tx, addresses);
-    });
+const transformOrigTransactions = (txs, coinInfo, currentInputs, addresses) => txs.map(tx => transformOrigTransaction(tx, coinInfo, currentInputs, addresses));
 exports.transformOrigTransactions = transformOrigTransactions;
 const transformReferencedTransaction = (tx) => {
     const inputsMap = (input) => ({
@@ -158,27 +168,8 @@ const transformReferencedTransaction = (tx) => {
     return enhanceTransaction(refTx, tx);
 };
 exports.transformReferencedTransaction = transformReferencedTransaction;
-const transformReferencedTransactions = (txs, coinInfo) => coinInfo.type !== 'bitcoin'
-    ? []
-    : txs.filter(isTransactionWithHex).map(raw => {
-        const tx = utxo_lib_1.Transaction.fromHex(raw.tx.hex, { network: coinInfo.network });
-        return (0, exports.transformReferencedTransaction)(tx);
-    });
+const transformReferencedTransactions = (txs) => txs.map(exports.transformReferencedTransaction);
 exports.transformReferencedTransactions = transformReferencedTransactions;
-const transformAccountToOrigTransaction = ({ tx, addresses, coinInfo, }) => {
-    if (!tx.hex)
-        throw (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: hex for ${tx.txid} not provided`);
-    if (!addresses)
-        throw (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: addresses for ${tx.txid} not provided`);
-    const srcTx = utxo_lib_1.Transaction.fromHex(tx.hex, { network: coinInfo.network });
-    return transformOrigTransaction({ ...tx.details, txid: tx.txid }, srcTx, addresses);
-};
-const transformAccountToReferencedTransaction = ({ tx, coinInfo, }) => {
-    if (!tx.hex)
-        throw (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: hex for ${tx.txid} not provided`);
-    const srcTx = utxo_lib_1.Transaction.fromHex(tx.hex, { network: coinInfo.network });
-    return (0, exports.transformReferencedTransaction)(srcTx);
-};
 const validateReferencedTransactions = ({ transactions, inputs, outputs, addresses, coinInfo, }) => {
     if (!Array.isArray(transactions) || transactions.length === 0)
         return;
@@ -186,10 +177,15 @@ const validateReferencedTransactions = ({ transactions, inputs, outputs, address
     const origTxs = (0, exports.getOrigTransactions)(inputs, outputs);
     const transformedTxs = transactions.map(tx => {
         if ('details' in tx) {
+            if (!tx.hex)
+                throw (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: hex for ${tx.txid} not provided`);
+            const srcTx = utxo_lib_1.Transaction.fromHex(tx.hex, { network: coinInfo.network });
             if (origTxs.includes(tx.txid)) {
-                return transformAccountToOrigTransaction({ tx, addresses, coinInfo });
+                if (!addresses)
+                    throw (0, errors_1.TypedError)('Method_InvalidParameter', `refTx: addresses for ${tx.txid} not provided`);
+                return transformOrigTransaction(srcTx, coinInfo, inputs, addresses);
             }
-            return transformAccountToReferencedTransaction({ tx, coinInfo });
+            return (0, exports.transformReferencedTransaction)(srcTx);
         }
         (0, paramsValidator_1.validateParams)(tx, [
             { name: 'hash', type: 'string', required: true },

package/lib/api/blockchainGetTransactions.d.ts

@@ -6,7 +6,7 @@ type Params = {
 };
 export default class BlockchainGetTransactions extends AbstractMethod<'blockchainGetTransactions', Params> {
     init(): void;
-    run(): Promise<import("packages/blockchain-link-types/lib").TypedRawTransaction[]>;
+    run(): Promise<import("packages/blockchain-link-types/lib/common").Transaction[]>;
 }
 export {};
 //# sourceMappingURL=blockchainGetTransactions.d.ts.map

package/lib/api/cardano/api/cardanoGetAddress.d.ts

@@ -16,7 +16,7 @@ export default class CardanoGetAddress extends AbstractMethod<'cardanoGetAddress
     } | undefined;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(): Promise<boolean>;
-    _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, }: Params): Promise<PROTO.CardanoAddress>;
+    _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, chunkify, }: Params): Promise<PROTO.CardanoAddress>;
     _ensureFirmwareSupportsBatch(batch: Params): void;
     run(): Promise<import("../../..").CardanoAddress | import("../../..").CardanoAddress[]>;
 }

package/lib/api/cardano/api/cardanoGetAddress.js

@@ -31,6 +31,7 @@ class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
                 { name: 'derivationType', type: 'number' },
                 { name: 'address', type: 'string' },
                 { name: 'showOnTrezor', type: 'boolean' },
+                { name: 'chunkify', type: 'boolean' },
             ]);
             (0, cardanoAddressParameters_1.validateAddressParameters)(batch.addressParameters);
             return {
@@ -42,6 +43,7 @@ class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
                     ? batch.derivationType
                     : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
                 show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+                chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false,
             };
         });
         const useEventListener = payload.useEventListener &&
@@ -88,7 +90,7 @@ class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
         const uiResp = await uiPromise.promise;
         return uiResp.payload;
     }
-    async _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, }) {
+    async _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, chunkify, }) {
         const cmd = this.device.getCommands();
         const response = await cmd.typedCall('CardanoGetAddress', 'CardanoAddress', {
             address_parameters,
@@ -96,6 +98,7 @@ class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
             network_id,
             derivation_type,
             show_display,
+            chunkify,
         });
         return response.message;
     }

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

@@ -46,6 +46,7 @@ export type CardanoSignTransactionParams = {
         hash: string;
     };
     testnet?: boolean;
+    chunkify?: boolean;
 };
 export default class CardanoSignTransaction extends AbstractMethod<'cardanoSignTransaction', CardanoSignTransactionParams> {
     init(): void;

package/lib/api/cardano/api/cardanoSignTransaction.js

@@ -68,6 +68,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             { name: 'includeNetworkId', type: 'boolean' },
             { name: 'unsignedTx', type: 'object' },
             { name: 'testnet', type: 'boolean' },
+            { name: 'chunkify', type: 'boolean' },
         ]);
         const inputsWithPath = payload.inputs.map(cardanoInputs_1.transformInput);
         const outputsWithData = payload.outputs.map(cardanoOutputs_1.transformOutput);
@@ -153,6 +154,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             includeNetworkId: payload.includeNetworkId,
             unsignedTx: 'unsignedTx' in payload ? payload.unsignedTx : undefined,
             testnet: 'testnet' in payload ? payload.testnet : undefined,
+            chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false,
         };
     }
     get info() {
@@ -254,6 +256,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             reference_inputs_count: this.params.referenceInputs.length,
             derivation_type: this.params.derivationType,
             include_network_id: this.params.includeNetworkId,
+            chunkify: this.params.chunkify,
         };
         await typedCall('CardanoSignTxInit', 'CardanoTxItemAck', signTxInitMessage);
         for (const { input } of this.params.inputsWithPath) {

package/lib/api/changeWipeCode.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class ChangeWipeCode extends AbstractMethod<'changeWipeCode', PROTO.ChangeWipeCode> {
+    init(): void;
+    run(): Promise<PROTO.Success>;
+}
+//# sourceMappingURL=changeWipeCode.d.ts.map

package/lib/api/changeWipeCode.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+class ChangeWipeCode extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['management'];
+        this.useDeviceState = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [{ name: 'remove', type: 'boolean' }]);
+        this.params = {
+            remove: payload.remove,
+        };
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('ChangeWipeCode', 'Success', this.params);
+        return response.message;
+    }
+}
+exports.default = ChangeWipeCode;
+//# sourceMappingURL=changeWipeCode.js.map

package/lib/api/common/paramsValidator.js

@@ -72,12 +72,14 @@ const getFirmwareRange = (method, coinInfo, currentRange) => {
     const models = Object.keys(range);
     if (coinInfo) {
         models.forEach(model => {
-            if (!coinInfo.support || typeof coinInfo.support[model] !== 'string') {
+            const supportVersion = coinInfo.support ? coinInfo.support[model] : false;
+            if (supportVersion === false) {
                 range[model].min = '0';
             }
             else if (range[model].min !== '0' &&
-                utils_1.versionUtils.isNewer(coinInfo.support[model], range[model].min)) {
-                range[model].min = coinInfo.support[model];
+                typeof supportVersion === 'string' &&
+                utils_1.versionUtils.isNewer(supportVersion, range[model].min)) {
+                range[model].min = supportVersion;
             }
         });
     }

package/lib/api/composeTransaction.js

@@ -228,9 +228,10 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
         const requiredRefTxs = (0, bitcoin_1.requireReferencedTransactions)(inputs, options, coinInfo);
         const refTxsIds = (0, bitcoin_1.getReferencedTransactions)(inputs);
         if (requiredRefTxs && refTxsIds.length > 0) {
-            const blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage);
-            const rawTxs = await blockchain.getTransactions(refTxsIds);
-            refTxs = (0, bitcoin_1.transformReferencedTransactions)(rawTxs, coinInfo);
+            refTxs = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage)
+                .then(blockchain => blockchain.getTransactionHexes(refTxsIds))
+                .then((0, bitcoin_1.parseTransactionHexes)(coinInfo.network))
+                .then(bitcoin_1.transformReferencedTransactions);
         }
         const signTxMethod = !this.device.unavailableCapabilities.replaceTransaction
             ? bitcoin_1.signTx

package/lib/api/eos/api/eosGetPublicKey.js

@@ -18,11 +18,13 @@ class EosGetPublicKey extends AbstractMethod_1.AbstractMethod {
             (0, paramsValidator_1.validateParams)(batch, [
                 { name: 'path', required: true },
                 { name: 'showOnTrezor', type: 'boolean' },
+                { name: 'chunkify', type: 'boolean' },
             ]);
             const path = (0, pathUtils_1.validatePath)(batch.path, 3);
             return {
                 address_n: path,
                 show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false,
+                chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false,
             };
         });
     }

package/lib/api/eos/api/eosSignTransaction.d.ts

@@ -5,6 +5,7 @@ type Params = {
     chain_id: string;
     header: PROTO.EosTxHeader;
     ack: PROTO.EosTxActionAck[];
+    chunkify: boolean;
 };
 export default class EosSignTransaction extends AbstractMethod<'eosSignTransaction', Params> {
     init(): void;

package/lib/api/eos/api/eosSignTransaction.js

@@ -14,6 +14,7 @@ class EosSignTransaction extends AbstractMethod_1.AbstractMethod {
         (0, paramsValidator_1.validateParams)(payload, [
             { name: 'path', required: true },
             { name: 'transaction', required: true },
+            { name: 'chunkify', type: 'boolean' },
         ]);
         const path = (0, pathUtils_1.validatePath)(payload.path, 3);
         const { chain_id, header, ack } = helper.validate(payload.transaction);
@@ -22,13 +23,14 @@ class EosSignTransaction extends AbstractMethod_1.AbstractMethod {
             chain_id,
             header,
             ack,
+            chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false,
         };
     }
     get info() {
         return 'Sign EOS transaction';
     }
     async run() {
-        const response = await helper.signTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.chain_id, this.params.header, this.params.ack);
+        const response = await helper.signTx(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.params.path, this.params.chain_id, this.params.header, this.params.ack, this.params.chunkify);
         return {
             signature: response.signature,
         };

package/lib/api/eos/eosSignTx.d.ts

@@ -13,5 +13,5 @@ export declare const validate: (tx: EosSDKTransaction) => {
     };
     ack: PROTO.EosTxActionAck[];
 };
-export declare const signTx: (typedCall: TypedCall, address_n: number[], chain_id: string, header: PROTO.EosTxHeader, actions: PROTO.EosTxActionAck[]) => Promise<PROTO.EosSignedTx>;
+export declare const signTx: (typedCall: TypedCall, address_n: number[], chain_id: string, header: PROTO.EosTxHeader, actions: PROTO.EosTxActionAck[], chunkify: boolean) => Promise<PROTO.EosSignedTx>;
 //# sourceMappingURL=eosSignTx.d.ts.map