@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/bitcoin/signtx.js

@@ -1,10 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.signTx = void 0;
-const constants_1 = require("../../constants");
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
 const requestPrevTxInfo = ({
   typedCall,
   txRequest: {
@@ -13,57 +7,73 @@ const requestPrevTxInfo = ({
   },
   refTxs
 }) => {
+  if (!details?.tx_hash) {
+    throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
+  }
   const {
     tx_hash
   } = details;
-  if (!tx_hash) {
-    throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
-  }
   const tx = refTxs[tx_hash.toLowerCase()];
   if (!tx) {
-    throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+    throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
   }
   if (request_type === 'TXINPUT') {
-    if (!tx.bin_outputs) throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
+    if (!tx.bin_outputs) throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
+    const {
+      inputs
+    } = tx;
+    const prevInput = inputs[details.request_index];
     return typedCall('TxAckPrevInput', 'TxRequest', {
       tx: {
-        input: tx.inputs[details.request_index]
+        input: prevInput
       }
     });
   }
   if (request_type === 'TXOUTPUT') {
-    if (!tx.bin_outputs) throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`);
+    if (!tx.bin_outputs) throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`);
+    const {
+      bin_outputs
+    } = tx;
+    const prevOutput = bin_outputs[details.request_index];
     return typedCall('TxAckPrevOutput', 'TxRequest', {
       tx: {
-        output: tx.bin_outputs[details.request_index]
+        output: prevOutput
       }
     });
   }
   if (request_type === 'TXORIGINPUT') {
-    if (!tx.outputs) throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
+    if (!tx.outputs) throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
+    const {
+      inputs
+    } = tx;
+    const origInput = inputs[details.request_index];
     return typedCall('TxAckInput', 'TxRequest', {
       tx: {
-        input: tx.inputs[details.request_index]
+        input: origInput
       }
     });
   }
   if (request_type === 'TXORIGOUTPUT') {
-    if (!tx.outputs) throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
+    if (!tx.outputs) throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
+    const {
+      outputs
+    } = tx;
+    const origOutput = outputs[details.request_index];
     return typedCall('TxAckOutput', 'TxRequest', {
       tx: {
-        output: tx.outputs[details.request_index]
+        output: origOutput
       }
     });
   }
   if (request_type === 'TXEXTRADATA') {
     if (typeof details.extra_data_len !== 'number') {
-      throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
+      throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
     }
     if (typeof details.extra_data_offset !== 'number') {
-      throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
+      throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
     }
     if (typeof tx.extra_data !== 'string') {
-      throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
+      throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
     }
     const data = tx.extra_data;
     const dataLen = details.extra_data_len;
@@ -92,7 +102,7 @@ const requestPrevTxInfo = ({
       tx: meta
     });
   }
-  throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
+  throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
 };
 const requestSignedTxInfo = ({
   typedCall,
@@ -105,23 +115,26 @@ const requestSignedTxInfo = ({
   paymentRequests
 }) => {
   if (request_type === 'TXINPUT') {
+    const input = inputs[details.request_index];
     return typedCall('TxAckInput', 'TxRequest', {
       tx: {
-        input: inputs[details.request_index]
+        input
       }
     });
   }
   if (request_type === 'TXOUTPUT') {
+    const output = outputs[details.request_index];
     return typedCall('TxAckOutput', 'TxRequest', {
       tx: {
-        output: outputs[details.request_index]
+        output
       }
     });
   }
   if (request_type === 'TXPAYMENTREQ') {
-    const req = paymentRequests[details.request_index];
+    const request_index = details?.request_index;
+    const req = typeof request_index === 'number' ? paymentRequests[request_index] : undefined;
     if (!req) {
-      throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown payment request at ${details.request_index}`);
+      throw ERRORS.TypedError('Runtime', `requestSignedTxInfo: Requested unknown payment request at ${request_index}`);
     }
     return typedCall('PaymentRequest', 'TxRequest', {
       nonce: req.nonce,
@@ -132,18 +145,15 @@ const requestSignedTxInfo = ({
     });
   }
   if (request_type === 'TXMETA') {
-    throw constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
+    throw ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
   }
   if (request_type === 'TXEXTRADATA') {
-    throw constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
+    throw ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
   }
-  throw constants_1.ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
+  throw ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
 };
 const requestTxAck = props => {
-  const {
-    tx_hash
-  } = props.txRequest.details;
-  if (tx_hash) {
+  if (props.txRequest.details?.tx_hash) {
     return requestPrevTxInfo(props);
   }
   return requestSignedTxInfo(props);
@@ -159,7 +169,7 @@ const saveTxSignatures = (txRequest, serializedTx, signatures) => {
   }
   if (typeof signature_index === 'number') {
     if (!signature) {
-      throw constants_1.ERRORS.TypedError('Runtime', 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+      throw ERRORS.TypedError('Runtime', 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
     }
     signatures[signature_index] = signature;
   }
@@ -185,7 +195,7 @@ const processTxRequest = async props => {
     txRequest: message
   });
 };
-const signTx = async ({
+export const signTx = async ({
   typedCall,
   inputs,
   outputs,
@@ -216,6 +226,4 @@ const signTx = async ({
     serializedTx: [],
     signatures: []
   });
-};
-exports.signTx = signTx;
-//# sourceMappingURL=signtx.js.map
+};

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

@@ -1,4 +1,10 @@
-import type { SignTxHelperParams } from './signtx';
-import type { SignedTransaction } from '../../types/api/bitcoin';
-export declare const signTxLegacy: ({ typedCall, inputs, outputs, refTxs, options, coinInfo, }: SignTxHelperParams) => Promise<SignedTransaction>;
-//# sourceMappingURL=signtxLegacy.d.ts.map
+import type { SignedTransaction } from '@trezor/connect-common';
+import type { SignTxHelperParams } from "./signtx.js";
+export declare const signTxLegacy: ({
+  typedCall,
+  inputs,
+  outputs,
+  refTxs,
+  options,
+  coinInfo
+}: SignTxHelperParams) => Promise<SignedTransaction>;

package/lib/api/bitcoin/signtxLegacy.js

@@ -1,10 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.signTxLegacy = void 0;
-const constants_1 = require("../../constants");
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
 const requestPrevTxInfo = ({
   txRequest: {
     request_type,
@@ -12,38 +6,46 @@ const requestPrevTxInfo = ({
   },
   refTxs
 }) => {
+  if (!details?.tx_hash) {
+    throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
+  }
   const {
     tx_hash
   } = details;
-  if (!tx_hash) {
-    throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
-  }
   const tx = refTxs[tx_hash.toLowerCase()];
   if (!tx) {
-    throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+    throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
   }
   if (!tx.bin_outputs) {
-    throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
+    throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
   }
   if (request_type === 'TXINPUT') {
+    const {
+      inputs
+    } = tx;
+    const input = inputs[details.request_index];
     return {
-      inputs: [tx.inputs[details.request_index]]
+      inputs: [input]
     };
   }
   if (request_type === 'TXOUTPUT') {
+    const {
+      bin_outputs
+    } = tx;
+    const binOutput = bin_outputs[details.request_index];
     return {
-      bin_outputs: [tx.bin_outputs[details.request_index]]
+      bin_outputs: [binOutput]
     };
   }
   if (request_type === 'TXEXTRADATA') {
     if (typeof details.extra_data_len !== 'number') {
-      throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
+      throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
     }
     if (typeof details.extra_data_offset !== 'number') {
-      throw constants_1.ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
+      throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
     }
     if (typeof tx.extra_data !== 'string') {
-      throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
+      throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
     }
     const data = tx.extra_data;
     const dataLen = details.extra_data_len;
@@ -73,7 +75,7 @@ const requestPrevTxInfo = ({
     }
     return meta;
   }
-  throw constants_1.ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
+  throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
 };
 const requestSignedTxInfo = ({
   txRequest: {
@@ -84,28 +86,27 @@ const requestSignedTxInfo = ({
   outputs
 }) => {
   if (request_type === 'TXINPUT') {
+    const input = inputs[details.request_index];
     return {
-      inputs: [inputs[details.request_index]]
+      inputs: [input]
     };
   }
   if (request_type === 'TXOUTPUT') {
+    const output = outputs[details.request_index];
     return {
-      outputs: [outputs[details.request_index]]
+      outputs: [output]
     };
   }
   if (request_type === 'TXMETA') {
-    throw constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
+    throw ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
   }
   if (request_type === 'TXEXTRADATA') {
-    throw constants_1.ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
+    throw ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
   }
-  throw constants_1.ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
+  throw ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
 };
 const requestTxAck = props => {
-  const {
-    tx_hash
-  } = props.txRequest.details;
-  if (tx_hash) {
+  if (props.txRequest.details?.tx_hash) {
     return requestPrevTxInfo(props);
   }
   return requestSignedTxInfo(props);
@@ -122,7 +123,7 @@ const saveTxSignatures = (txRequest, serializedTx, signatures) => {
   }
   if (typeof signature_index === 'number') {
     if (!signature) {
-      throw constants_1.ERRORS.TypedError('Runtime', 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+      throw ERRORS.TypedError('Runtime', 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
     }
     signatures[signature_index] = signature;
   }
@@ -152,7 +153,7 @@ const processTxRequest = async props => {
     txRequest: message
   });
 };
-const signTxLegacy = async ({
+export const signTxLegacy = async ({
   typedCall,
   inputs,
   outputs,
@@ -182,6 +183,4 @@ const signTxLegacy = async ({
     serializedTx: [],
     signatures: []
   });
-};
-exports.signTxLegacy = signTxLegacy;
-//# sourceMappingURL=signtxLegacy.js.map
+};

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

@@ -1,14 +1,12 @@
+import type { Network, PROTO } from '@trezor/connect-common';
 import { Transaction as BitcoinJsTransaction } from '@trezor/utxo-lib';
-import { PROTO } from '../../constants';
-import type { DeviceCommands } from '../../device/DeviceCommands';
-import type { Network } from '../../types';
+import type { DeviceCommands } from "../../device/DeviceCommands.js";
 type GetHDNode = (address_n: number[]) => ReturnType<ReturnType<typeof DeviceCommands>['getHDNode']>;
 export declare const deriveOutputScript: (getHDNode: GetHDNode, output: PROTO.TxOutputType, network: Network) => Promise<Buffer<ArrayBufferLike> | undefined>;
 export declare const verifyTx: (serializedTx: string, params: {
-    inputs: PROTO.TxInputType[];
-    outputs: PROTO.TxOutputType[];
-    outputScripts: Awaited<ReturnType<typeof deriveOutputScript>>[];
-    network: Network;
+  inputs: PROTO.TxInputType[];
+  outputs: PROTO.TxOutputType[];
+  outputScripts: Awaited<ReturnType<typeof deriveOutputScript>>[];
+  network: Network;
 }) => BitcoinJsTransaction;
-export {};
-//# sourceMappingURL=signtxVerify.d.ts.map
+export {};

package/lib/api/bitcoin/signtxVerify.js

@@ -1,32 +1,27 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.verifyTx = exports.deriveOutputScript = void 0;
-const utxo_lib_1 = require("@trezor/utxo-lib");
-const constants_1 = require("../../constants");
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { address as BitcoinJsAddress, payments as BitcoinJsPayments, Transaction as BitcoinJsTransaction, bip32 } from "@trezor/utxo-lib";
 const derivePubKeyHash = async (getHDNode, address_n, network) => {
   if (address_n.length === 5) {
     const response = await getHDNode(address_n.slice(0, 4));
-    const node = utxo_lib_1.bip32.fromBase58(response.xpub, network);
-    return node.derive(address_n[address_n.length - 1]);
+    const node = bip32.fromBase58(response.xpub, network);
+    const lastComponent = address_n[address_n.length - 1];
+    return node.derive(lastComponent);
   }
   const response = await getHDNode(address_n);
-  return utxo_lib_1.bip32.fromBase58(response.xpub, network);
+  return bip32.fromBase58(response.xpub, network);
 };
-const deriveOutputScript = async (getHDNode, output, network) => {
+export const deriveOutputScript = async (getHDNode, output, network) => {
   if ('multisig' in output) return;
   if ('op_return_data' in output) {
-    return utxo_lib_1.payments.embed({
+    return BitcoinJsPayments.embed({
       data: [Buffer.from(output.op_return_data, 'hex')]
     }).output;
   }
   if (output.address) {
-    return utxo_lib_1.address.toOutputScript(output.address, network);
+    return BitcoinJsAddress.toOutputScript(output.address, network);
   }
   if (!output.address_n) {
-    throw constants_1.ERRORS.TypedError('Runtime', 'deriveOutputScript: Neither address or address_n is set');
+    throw ERRORS.TypedError('Runtime', 'deriveOutputScript: Neither address or address_n is set');
   }
   const node = await derivePubKeyHash(getHDNode, output.address_n, network);
   const payment = {
@@ -34,62 +29,67 @@ const deriveOutputScript = async (getHDNode, output, network) => {
     network
   };
   if (output.script_type === 'PAYTOADDRESS') {
-    return utxo_lib_1.payments.p2pkh(payment).output;
+    return BitcoinJsPayments.p2pkh(payment).output;
   }
   if (output.script_type === 'PAYTOSCRIPTHASH') {
-    return utxo_lib_1.payments.p2sh(payment).output;
+    return BitcoinJsPayments.p2sh(payment).output;
   }
   if (output.script_type === 'PAYTOP2SHWITNESS') {
-    return utxo_lib_1.payments.p2sh({
-      redeem: utxo_lib_1.payments.p2wpkh(payment)
+    return BitcoinJsPayments.p2sh({
+      redeem: BitcoinJsPayments.p2wpkh(payment)
     }).output;
   }
   if (output.script_type === 'PAYTOWITNESS') {
-    return utxo_lib_1.payments.p2wpkh(payment).output;
+    return BitcoinJsPayments.p2wpkh(payment).output;
   }
   if (output.script_type === 'PAYTOTAPROOT') {
-    return utxo_lib_1.payments.p2tr({
+    return BitcoinJsPayments.p2tr({
       pubkey: node.publicKey,
       network
     }).output;
   }
   if (output.script_type === 'PAYTOMULTISIG') {
-    throw constants_1.ERRORS.TypedError('Runtime', `deriveOutputScript: script_type PAYTOMULTISIG not expected without multisig defined`);
+    throw ERRORS.TypedError('Runtime', `deriveOutputScript: script_type PAYTOMULTISIG not expected without multisig defined`);
   }
-  throw constants_1.ERRORS.TypedError('Runtime', `deriveOutputScript: Unknown script type ${output.script_type}`);
+  throw ERRORS.TypedError('Runtime', `deriveOutputScript: Unknown script type ${output.script_type}`);
 };
-exports.deriveOutputScript = deriveOutputScript;
-const verifyTx = (serializedTx, params) => {
+export const verifyTx = (serializedTx, params) => {
   const {
     inputs,
     outputs,
     outputScripts,
     network
   } = params;
-  const bitcoinTx = utxo_lib_1.Transaction.fromHex(serializedTx, {
+  const bitcoinTx = BitcoinJsTransaction.fromHex(serializedTx, {
     network
   });
   if (inputs.length !== bitcoinTx.ins.length) {
-    throw constants_1.ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction inputs invalid length');
+    throw ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction inputs invalid length');
   }
   if (outputs.length !== bitcoinTx.outs.length) {
-    throw constants_1.ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction outputs invalid length');
+    throw ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction outputs invalid length');
   }
   outputs.forEach((output, i) => {
+    const {
+      outs
+    } = bitcoinTx;
+    const txOut = outs[i];
     if (output.amount) {
-      if (output.amount.toString() !== bitcoinTx.outs[i].value) {
-        throw constants_1.ERRORS.TypedError('Runtime', `verifyTx: Wrong output amount at output ${i}. Requested: ${output.amount}, signed: ${bitcoinTx.outs[i].value}`);
+      if (output.amount.toString() !== txOut.value) {
+        throw ERRORS.TypedError('Runtime', `verifyTx: Wrong output amount at output ${i}. Requested: ${output.amount}, signed: ${txOut.value}`);
       }
     }
   });
   for (let i = 0; i < outputs.length; i++) {
-    const scriptB = bitcoinTx.outs[i].script;
+    const {
+      outs
+    } = bitcoinTx;
+    const out = outs[i];
+    const scriptB = out.script;
     const scriptA = outputScripts[i];
     if (scriptA && scriptA.compare(scriptB) !== 0) {
-      throw constants_1.ERRORS.TypedError('Runtime', `verifyTx: Output ${i} scripts differ`);
+      throw ERRORS.TypedError('Runtime', `verifyTx: Output ${i} scripts differ`);
     }
   }
   return bitcoinTx;
-};
-exports.verifyTx = verifyTx;
-//# sourceMappingURL=signtxVerify.js.map
+};

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

@@ -1,5 +1,3 @@
-import { PROTO } from '../../constants';
-import { BitcoinNetworkInfo } from '../../types';
-export declare function mapOutputScriptToKey(script_type: string): "p2tr" | "p2wpkh" | "p2sh" | "p2pkh" | undefined;
-export declare const getTransactionVbytes: (inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], coinInfo: BitcoinNetworkInfo) => number | undefined;
-//# sourceMappingURL=transactionBytes.d.ts.map
+import type { BitcoinNetworkInfo, PROTO } from '@trezor/connect-common';
+export declare function mapOutputScriptToKey(script_type: string): "p2pkh" | "p2sh" | "p2tr" | "p2wpkh" | undefined;
+export declare const getTransactionVbytes: (inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], coinInfo: BitcoinNetworkInfo) => number | undefined;

package/lib/api/bitcoin/transactionBytes.js

@@ -1,15 +1,6 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getTransactionVbytes = void 0;
-exports.mapOutputScriptToKey = mapOutputScriptToKey;
-const tslib_1 = require("tslib");
-const baddress = tslib_1.__importStar(require("@trezor/utxo-lib/lib/address"));
-const txWeightCalculator_1 = require("@trezor/utxo-lib/lib/txWeightCalculator");
-const pathUtils_1 = require("../../utils/pathUtils");
-function mapOutputScriptToKey(script_type) {
+import { TxWeightCalculator, address as baddress } from "@trezor/utxo-lib";
+import { getOutputScriptType, getScriptType } from "../../utils/pathUtils.js";
+export function mapOutputScriptToKey(script_type) {
   switch (script_type) {
     case 'PAYTOADDRESS':
       return 'p2pkh';
@@ -25,11 +16,11 @@ function mapOutputScriptToKey(script_type) {
       return undefined;
   }
 }
-const getTransactionVbytes = (inputs, outputs, coinInfo) => {
-  const calc = new txWeightCalculator_1.TxWeightCalculator();
+export const getTransactionVbytes = (inputs, outputs, coinInfo) => {
+  const calc = new TxWeightCalculator();
   let cannotProcess = false;
   inputs.forEach(input => {
-    const script_type = input.script_type ?? (0, pathUtils_1.getScriptType)(input.address_n);
+    const script_type = input.script_type ?? getScriptType(input.address_n);
     if (script_type && !input.witness) {
       calc.addInput({
         script_type,
@@ -56,7 +47,7 @@ const getTransactionVbytes = (inputs, outputs, coinInfo) => {
       });
       return;
     } else if (out.address_n || out.script_type) {
-      const script_type = out.script_type ?? (0, pathUtils_1.getOutputScriptType)(out.address_n);
+      const script_type = out.script_type ?? getOutputScriptType(out.address_n);
       if (script_type) {
         const script_key = mapOutputScriptToKey(script_type);
         if (script_key) {
@@ -71,6 +62,4 @@ const getTransactionVbytes = (inputs, outputs, coinInfo) => {
     return undefined;
   }
   return calc.getVirtualBytes();
-};
-exports.getTransactionVbytes = getTransactionVbytes;
-//# sourceMappingURL=transactionBytes.js.map
+};

package/lib/api/bleUnpair.d.ts

@@ -1,9 +1,11 @@
-import { PROTO } from '../constants';
-import { AbstractMethod } from '../core/AbstractMethod';
+import { type PermissionRequest } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 export default class BleUnpair extends AbstractMethod<'bleUnpair', PROTO.BleUnpair> {
-    init(): void;
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=bleUnpair.d.ts.map
+  constructor(message: MethodMessage<'bleUnpair'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/bleUnpair.js

@@ -1,39 +1,37 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const transport_1 = require("@trezor/transport");
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const events_1 = require("../events");
-class BleUnpair extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
-    this.requiredPermissions = ['management'];
-    this.useDeviceState = false;
-    this.skipFinalReload = true;
+import { UI_REQUEST } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { TRANSPORT_ERROR } from "@trezor/transport-common";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class BleUnpair extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    this.params = {
+    } = message;
+    Assert(PROTO.BleUnpair, payload);
+    const params = {
       all: payload.all
     };
-    (0, schema_utils_1.Assert)(constants_1.PROTO.BleUnpair, payload);
+    super(message, params);
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
+    this.useDeviceState = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     try {
       const response = await cmd.typedCall('BleUnpair', 'Success', this.params);
       return response.message;
     } catch (error) {
-      if (this.device.descriptor.apiType === 'bluetooth' && error.message === transport_1.TRANSPORT_ERROR.INTERFACE_DATA_TRANSFER) {
-        throw constants_1.ERRORS.TypedError('Device_Disconnected');
+      if (this.getDevice().descriptor.apiType === 'bluetooth' && error.message === TRANSPORT_ERROR.INTERFACE_DATA_TRANSFER) {
+        throw ERRORS.TypedError('Device_Disconnected');
       }
       throw error;
     }
   }
-}
-exports.default = BleUnpair;
-//# sourceMappingURL=bleUnpair.js.map
+}