@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.2

package/libESM/api/monero/api/moneroSignTransaction.d.mts

@@ -1,17 +0,0 @@
-import type { MethodPermission, PROTO } from '@trezor/connect-common';
-import type { MethodMessage, MethodReturnType } from '../../../core/AbstractMethod';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-type Params = {
-    address_n: number[];
-    network_type: PROTO.MoneroNetworkType;
-    tsx_data: PROTO.MoneroTransactionData;
-    inputs: PROTO.MoneroTransactionSourceEntry[];
-};
-export default class MoneroSignTransactionMethod extends AbstractMethod<'moneroSignTransaction', Params> {
-    get requiredPermissions(): MethodPermission[];
-    private state;
-    constructor(message: MethodMessage<'moneroSignTransaction'>);
-    get info(): string;
-    run(): Promise<MethodReturnType<typeof this.name>>;
-}
-export {};

package/libESM/api/monero/api/moneroSignTransaction.mjs

@@ -1,202 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
-import { getMiscNetwork } from "../../../data/coinInfo.mjs";
-import { HD_HARDENED, validatePath } from "../../../utils/pathUtils.mjs";
-export default class MoneroSignTransactionMethod extends AbstractMethod {
-  get requiredPermissions() {
-    return ['read', 'write'];
-  }
-  state = {
-    hmacs: [],
-    vinis: [],
-    signatures: [],
-    pseudo_outs: [],
-    out_pks: [],
-    ecdh_infos: [],
-    tx_outs: [],
-    rsig_parts: []
-  };
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    const path = validatePath(payload.path, 3);
-    const allHardened = path.every(component => (component & HD_HARDENED) !== 0);
-    if (!allHardened) {
-      throw ERRORS.TypedError('Method_InvalidParameter', `Monero requires all path components to be hardened. Use m/44'/128'/0' format.`);
-    }
-    if (payload.inputs.length < 1) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'At least one input is required');
-    }
-    if (payload.tsx_data.outputs.length < 2) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'At least 2 outputs are required');
-    }
-    const rsigData = payload.tsx_data.rsig_data;
-    if (rsigData.grouping.length < 1) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'Missing required fields in rsig_data');
-    }
-    if (payload.inputs.length !== payload.tsx_data.num_inputs) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'Number of inputs does not match tsx_data.num_inputs');
-    }
-    const transformedTsxData = {};
-    transformedTsxData.num_inputs = payload.tsx_data.num_inputs;
-    transformedTsxData.mixin = payload.tsx_data.mixin;
-    transformedTsxData.fee = payload.tsx_data.fee;
-    transformedTsxData.account = payload.tsx_data.account;
-    transformedTsxData.hard_fork = payload.tsx_data.hard_fork;
-    transformedTsxData.unlock_time = payload.tsx_data.unlock_time;
-    transformedTsxData.minor_indices = payload.tsx_data.minor_indices || [];
-    transformedTsxData.integrated_indices = payload.tsx_data.integrated_indices || [];
-    transformedTsxData.outputs = payload.tsx_data.outputs;
-    transformedTsxData.client_version = 3;
-    transformedTsxData.version = 1;
-    if (payload.tsx_data.payment_id !== undefined && payload.tsx_data.payment_id !== '') {
-      transformedTsxData.payment_id = payload.tsx_data.payment_id;
-    }
-    if (payload.tsx_data.monero_version !== undefined && payload.tsx_data.monero_version !== '') {
-      transformedTsxData.monero_version = payload.tsx_data.monero_version;
-    }
-    if (payload.tsx_data.chunkify !== undefined) {
-      transformedTsxData.chunkify = payload.tsx_data.chunkify;
-    }
-    if (payload.tsx_data.change_dts) {
-      transformedTsxData.change_dts = payload.tsx_data.change_dts;
-    }
-    transformedTsxData.rsig_data = {
-      rsig_type: rsigData.rsig_type,
-      bp_version: rsigData.bp_version,
-      grouping: rsigData.grouping,
-      rsig_parts: rsigData.rsig_parts || []
-    };
-    if (rsigData.offload_type !== undefined) {
-      transformedTsxData.rsig_data.offload_type = rsigData.offload_type;
-    }
-    if (rsigData.mask !== undefined && rsigData.mask !== '') {
-      transformedTsxData.rsig_data.mask = rsigData.mask;
-    }
-    if (rsigData.rsig !== undefined && rsigData.rsig !== '') {
-      transformedTsxData.rsig_data.rsig = rsigData.rsig;
-    }
-    const transformedInputs = payload.inputs.map(input => {
-      const transformedInput = {};
-      transformedInput.amount = input.amount;
-      transformedInput.real_output = input.real_output;
-      transformedInput.real_output_in_tx_index = input.real_output_in_tx_index;
-      transformedInput.rct = input.rct;
-      transformedInput.subaddr_minor = input.subaddr_minor;
-      transformedInput.real_out_tx_key = input.real_out_tx_key;
-      transformedInput.real_out_additional_tx_keys = input.real_out_additional_tx_keys || [];
-      transformedInput.outputs = input.outputs;
-      transformedInput.mask = input.mask;
-      if (input.multisig_kLRki) {
-        transformedInput.multisig_kLRki = input.multisig_kLRki;
-      }
-      return transformedInput;
-    });
-    const params = {
-      address_n: path,
-      network_type: payload.networkType,
-      tsx_data: transformedTsxData,
-      inputs: transformedInputs
-    };
-    super(message, params);
-    this.requiredDeviceCapabilities = ['Capability_Monero'];
-    this.requiredFirmwareCoins = [getMiscNetwork('Monero')];
-  }
-  get info() {
-    return 'Sign Monero transaction';
-  }
-  async run() {
-    const initResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionInitRequest', 'MoneroTransactionInitAck', {
-      version: 0,
-      address_n: this.params.address_n,
-      network_type: this.params.network_type,
-      tsx_data: this.params.tsx_data
-    });
-    this.state.hmacs = initResponse.message.hmacs;
-    for (let i = 0; i < this.params.inputs.length; i++) {
-      const setInputResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionSetInputRequest', 'MoneroTransactionSetInputAck', {
-        src_entr: this.params.inputs[i]
-      });
-      this.state.vinis.push({
-        vini: setInputResponse.message.vini,
-        vini_hmac: setInputResponse.message.vini_hmac,
-        pseudo_out: setInputResponse.message.pseudo_out,
-        pseudo_out_hmac: setInputResponse.message.pseudo_out_hmac,
-        pseudo_out_alpha: setInputResponse.message.pseudo_out_alpha,
-        spend_key: setInputResponse.message.spend_key,
-        src_entr: this.params.inputs[i],
-        orig_idx: i
-      });
-    }
-    for (let i = 0; i < this.state.vinis.length; i++) {
-      const viniData = this.state.vinis[i];
-      await this.getDevice().getCommands().typedCall('MoneroTransactionInputViniRequest', 'MoneroTransactionInputViniAck', {
-        src_entr: viniData.src_entr,
-        vini: viniData.vini,
-        vini_hmac: viniData.vini_hmac,
-        pseudo_out: viniData.pseudo_out,
-        pseudo_out_hmac: viniData.pseudo_out_hmac,
-        orig_idx: viniData.orig_idx
-      });
-    }
-    await this.getDevice().getCommands().typedCall('MoneroTransactionAllInputsSetRequest', 'MoneroTransactionAllInputsSetAck', {});
-    const outputs = this.params.tsx_data.outputs || [];
-    for (let i = 0; i < outputs.length; i++) {
-      const setOutputResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionSetOutputRequest', 'MoneroTransactionSetOutputAck', {
-        dst_entr: outputs[i],
-        dst_entr_hmac: this.state.hmacs[i]
-      });
-      if (setOutputResponse.message.out_pk) {
-        this.state.out_pks.push(setOutputResponse.message.out_pk);
-      }
-      if (setOutputResponse.message.ecdh_info) {
-        this.state.ecdh_infos.push(setOutputResponse.message.ecdh_info);
-      }
-      if (setOutputResponse.message.tx_out) {
-        this.state.tx_outs.push(setOutputResponse.message.tx_out);
-      }
-      if (setOutputResponse.message.rsig_data?.rsig) {
-        this.state.rsig_parts.push(setOutputResponse.message.rsig_data.rsig);
-      }
-    }
-    const allOutSetResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionAllOutSetRequest', 'MoneroTransactionAllOutSetAck', {});
-    this.state.tx_prefix_hash = allOutSetResponse.message.tx_prefix_hash;
-    this.state.rv = allOutSetResponse.message.rv;
-    this.state.extra = allOutSetResponse.message.extra;
-    for (let i = 0; i < this.state.vinis.length; i++) {
-      const viniData = this.state.vinis[i];
-      const signResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionSignInputRequest', 'MoneroTransactionSignInputAck', {
-        src_entr: viniData.src_entr,
-        vini: viniData.vini,
-        vini_hmac: viniData.vini_hmac,
-        pseudo_out: viniData.pseudo_out,
-        pseudo_out_hmac: viniData.pseudo_out_hmac,
-        pseudo_out_alpha: viniData.pseudo_out_alpha,
-        spend_key: viniData.spend_key,
-        orig_idx: viniData.orig_idx
-      });
-      this.state.signatures.push(signResponse.message.signature);
-      if (signResponse.message.pseudo_out) {
-        this.state.pseudo_outs.push(signResponse.message.pseudo_out);
-      }
-    }
-    const finalResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionFinalRequest', 'MoneroTransactionFinalAck', {});
-    return {
-      signatures: this.state.signatures,
-      tx_prefix_hash: this.state.tx_prefix_hash,
-      rv: this.state.rv,
-      cout_key: finalResponse.message.cout_key,
-      salt: finalResponse.message.salt,
-      rand_mult: finalResponse.message.rand_mult,
-      tx_enc_keys: finalResponse.message.tx_enc_keys,
-      opening_key: finalResponse.message.opening_key,
-      pseudo_outs: this.state.pseudo_outs,
-      out_pks: this.state.out_pks,
-      ecdh_infos: this.state.ecdh_infos,
-      tx_outs: this.state.tx_outs,
-      rsig_parts: this.state.rsig_parts,
-      extra: this.state.extra
-    };
-  }
-}

package/libESM/api/pingDevice.d.mts

@@ -1,11 +0,0 @@
-import { type MethodPermission } from '@trezor/connect-common';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class PingDevice extends AbstractMethod<'pingDevice', PROTO.Ping> {
-    constructor(message: MethodMessage<'pingDevice'>);
-    get requiredPermissions(): MethodPermission[];
-    run(): Promise<{
-        message: string;
-    }>;
-}

package/libESM/api/pingDevice.mjs

@@ -1,27 +0,0 @@
-import { UI_REQUEST } from "@trezor/connect-common";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-export default class PingDevice extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(PROTO.Ping, payload);
-    const params = {
-      message: payload.message,
-      button_protection: payload.button_protection
-    };
-    super(message, params);
-    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS, UI_REQUEST.BOOTLOADER];
-    this.useDeviceState = false;
-  }
-  get requiredPermissions() {
-    return ['management'];
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('Ping', 'Success', this.params);
-    return response.message;
-  }
-}

package/libESM/api/pushTransaction.d.mts

@@ -1,17 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import { PushTransaction as PushTransactionSchema } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-type Params = {
-    tx: PushTransactionSchema['tx'];
-    coinInfo: CoinInfo;
-    identity?: string;
-};
-export default class PushTransaction extends AbstractMethod<'pushTransaction', Params> {
-    constructor(message: MethodMessage<'pushTransaction'>);
-    get requiredPermissions(): MethodPermission[];
-    run({ sendCoreMessage }: MethodContext): Promise<{
-        txid: string;
-    }>;
-}
-export {};

package/libESM/api/pushTransaction.mjs

@@ -1,42 +0,0 @@
-import { PushTransaction as PushTransactionSchema } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class PushTransaction extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(PushTransactionSchema, payload);
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(coinInfo);
-    if (coinInfo.type === 'bitcoin' && (typeof payload.tx !== 'string' || !/^[0-9A-Fa-f]*$/.test(payload.tx))) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'Transaction must be hexadecimal');
-    }
-    const params = {
-      tx: payload.tx,
-      coinInfo,
-      identity: payload.identity
-    };
-    super(message, params);
-    this.useUi = false;
-    this.useDevice = false;
-  }
-  get requiredPermissions() {
-    return ['push_tx'];
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
-    const txid = await backend.pushTransaction(this.params.tx);
-    return {
-      txid
-    };
-  }
-}

package/libESM/api/recoveryDevice.d.mts

@@ -1,20 +0,0 @@
-import { type MethodPermission } from '@trezor/connect-common';
-import type { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class RecoveryDevice extends AbstractMethod<'recoveryDevice', PROTO.RecoveryDevice> {
-    constructor(message: MethodMessage<'recoveryDevice'>);
-    get requiredPermissions(): MethodPermission[];
-    get confirmation(): {
-        view: "device-management";
-        customConfirmButton: {
-            className: string;
-            label: string;
-        };
-        label: string;
-    };
-    run(): Promise<{
-        message: string;
-    }>;
-    get info(): string;
-}

package/libESM/api/recoveryDevice.mjs

@@ -1,50 +0,0 @@
-import { UI_REQUEST } from "@trezor/connect-common";
-import { RecoveryDevice as RecoveryDeviceSchema } from "@trezor/connect-common/libESM/types/api/recoveryDevice.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-export default class RecoveryDevice extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(RecoveryDeviceSchema, payload);
-    const params = {
-      word_count: payload.word_count,
-      passphrase_protection: payload.passphrase_protection,
-      pin_protection: payload.pin_protection,
-      language: payload.language,
-      label: payload.label,
-      enforce_wordlist: payload.enforce_wordlist,
-      input_method: payload.input_method,
-      type: payload.type,
-      u2f_counter: payload.u2f_counter,
-      backup_method: payload.backup_method
-    };
-    super(message, params);
-    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
-    this.useDeviceState = false;
-    this.skipFinalReload = false;
-    this.useEmptyPassphrase = true;
-  }
-  get requiredPermissions() {
-    return ['management'];
-  }
-  get confirmation() {
-    return {
-      view: 'device-management',
-      customConfirmButton: {
-        className: 'confirm',
-        label: 'Proceed'
-      },
-      label: 'Do you want to recover device from seed?'
-    };
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('RecoveryDevice', 'Success', this.params);
-    return response.message;
-  }
-  get info() {
-    return 'Recover device';
-  }
-}

package/libESM/api/requestLogin.d.mts

@@ -1,14 +0,0 @@
-import type { MethodPermission } from '@trezor/connect-common';
-import type { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class RequestLogin extends AbstractMethod<'requestLogin', PROTO.SignIdentity> {
-    constructor(message: MethodMessage<'requestLogin'>);
-    get requiredPermissions(): MethodPermission[];
-    get info(): string;
-    run(): Promise<{
-        address: string;
-        publicKey: string;
-        signature: string;
-    }>;
-}

package/libESM/api/requestLogin.mjs

@@ -1,48 +0,0 @@
-import { RequestLoginSchema } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import * as settingsStore from "../data/settingsStore.mjs";
-export default class RequestLogin extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(RequestLoginSchema, payload);
-    const identity = {};
-    const settings = settingsStore.get();
-    const origin = payload.origin || settings.origin;
-    if (origin) {
-      const [proto, host, port] = origin.split(':');
-      identity.proto = proto;
-      identity.host = host.substring(2);
-      if (port) {
-        identity.port = port;
-      }
-      identity.index = 0;
-    }
-    const params = {
-      identity,
-      challenge_hidden: payload.challengeHidden || '',
-      challenge_visual: payload.challengeVisual || ''
-    };
-    super(message, params);
-    this.useEmptyPassphrase = true;
-  }
-  get requiredPermissions() {
-    return ['read', 'write'];
-  }
-  get info() {
-    return 'Login';
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const {
-      message
-    } = await cmd.typedCall('SignIdentity', 'SignedIdentity', this.params);
-    return {
-      address: message.address,
-      publicKey: message.public_key,
-      signature: message.signature
-    };
-  }
-}

package/libESM/api/resetDevice.d.mts

@@ -1,22 +0,0 @@
-import { type MethodPermission } from '@trezor/connect-common';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class ResetDevice extends AbstractMethod<'resetDevice', PROTO.ResetDevice> {
-    constructor(message: MethodMessage<'resetDevice'>);
-    get requiredPermissions(): MethodPermission[];
-    get info(): string;
-    get confirmation(): {
-        view: "device-management";
-        label: string;
-    };
-    private resetDeviceWorkflow;
-    private entropyCheckWorkflow;
-    run(): Promise<{
-        message: string;
-        xpubHashes: import("@trezor/connect-common").XPubHashesPerBip43Path;
-    } | {
-        message: string;
-        xpubHashes?: undefined;
-    }>;
-}

package/libESM/api/resetDevice.mjs

@@ -1,131 +0,0 @@
-import { UI_REQUEST } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { TransportError } from "@trezor/connect-common/libESM/constants/errors.mjs";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { getRandomInt } from "@trezor/utils";
-import { generateEntropy, verifyEntropy } from "../api/firmware/verifyEntropy.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validatePath } from "../utils/pathUtils.mjs";
-import { calculateXPubHashes } from "./firmware/calculateXPubHash.mjs";
-export default class ResetDevice extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(PROTO.ResetDevice, payload);
-    const params = {
-      strength: payload.strength || 256,
-      passphrase_protection: payload.passphrase_protection,
-      pin_protection: payload.pin_protection,
-      language: payload.language,
-      label: payload.label,
-      u2f_counter: payload.u2f_counter || Math.floor(Date.now() / 1000),
-      skip_backup: payload.skip_backup,
-      no_backup: payload.no_backup,
-      backup_type: payload.backup_type,
-      backup_method: payload.backup_method,
-      entropy_check: typeof payload.entropy_check === 'boolean' ? payload.entropy_check : true
-    };
-    super(message, params);
-    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
-    this.useDeviceState = false;
-    this.skipFinalReload = false;
-  }
-  get requiredPermissions() {
-    return ['management'];
-  }
-  get info() {
-    return 'Setup device';
-  }
-  get confirmation() {
-    return {
-      view: 'device-management',
-      label: 'Do you really you want to create a new wallet?'
-    };
-  }
-  async resetDeviceWorkflow() {
-    const cmd = this.getDevice().getCommands();
-    const entropy = generateEntropy(32).toString('hex');
-    await cmd.typedCall('ResetDevice', 'EntropyRequest', this.params);
-    await cmd.typedCall('EntropyAck', 'Success', {
-      entropy
-    });
-  }
-  async entropyCheckWorkflow() {
-    const cmd = this.getDevice().getCommands();
-    const paths = ["m/84'/0'/0'", "m/44'/60'/0'"];
-    const parsedPaths = paths.map(path => ({
-      path,
-      address_n: validatePath(path)
-    }));
-    const handleErr = error => {
-      throw error instanceof TransportError ? error : ERRORS.TypedError('Failure_EntropyCheck', error.message);
-    };
-    const getXPubs = async () => {
-      const xpubs = {};
-      for (const {
-        path,
-        address_n
-      } of parsedPaths) {
-        const pubKey = await cmd.getPublicKey({
-          address_n
-        }).catch(handleErr);
-        xpubs[path] = pubKey.xpub;
-      }
-      return xpubs;
-    };
-    let entropy = generateEntropy(32).toString('hex');
-    let commitment = await cmd.typedCall('ResetDevice', 'EntropyRequest', this.params).then(response => response.message.entropy_commitment);
-    await cmd.typedCall('EntropyAck', 'EntropyCheckReady', {
-      entropy
-    });
-    const tries = getRandomInt(1, 5);
-    for (let i = 0; i < tries; i++) {
-      const xpubs = await getXPubs();
-      const {
-        prev_entropy,
-        entropy_commitment
-      } = await cmd.typedCall('EntropyCheckContinue', 'EntropyRequest', {}).then(response => response.message).catch(handleErr);
-      const res = await verifyEntropy({
-        type: this.params.backup_type,
-        strength: this.params.strength,
-        commitment,
-        hostEntropy: entropy,
-        trezorEntropy: prev_entropy,
-        xpubs
-      });
-      if (res.error) {
-        await this.getDevice().getCurrentSession().cancelCall();
-        throw ERRORS.TypedError('Failure_EntropyCheck', res.error);
-      }
-      entropy = generateEntropy(32).toString('hex');
-      commitment = entropy_commitment;
-      await cmd.typedCall('EntropyAck', 'EntropyCheckReady', {
-        entropy
-      }).catch(handleErr);
-    }
-    const finalXPubs = await getXPubs();
-    await cmd.typedCall('EntropyCheckContinue', 'Success', {
-      finish: true
-    });
-    return finalXPubs;
-  }
-  async run() {
-    if (this.params.entropy_check && this.getDevice().unavailableCapabilities['entropyCheck']) {
-      this.params.entropy_check = false;
-    }
-    if (this.params.entropy_check) {
-      const xpubs = await this.entropyCheckWorkflow();
-      const xpubHashes = calculateXPubHashes(xpubs);
-      return {
-        message: 'Success',
-        xpubHashes
-      };
-    }
-    await this.resetDeviceWorkflow();
-    return {
-      message: 'Success'
-    };
-  }
-}

package/libESM/api/ripple/api/index.d.mts

@@ -1,2 +0,0 @@
-export { default as rippleGetAddress } from './rippleGetAddress';
-export { default as rippleSignTransaction } from './rippleSignTransaction';

package/libESM/api/ripple/api/index.mjs

@@ -1,2 +0,0 @@
-export { default as rippleGetAddress } from "./rippleGetAddress.mjs";
-export { default as rippleSignTransaction } from "./rippleSignTransaction.mjs";

package/libESM/api/ripple/api/rippleGetAddress.d.mts

@@ -1,15 +0,0 @@
-import type { MethodMessage } from '../../../core/AbstractMethod';
-import { AbstractMiscGetAddress } from '../../common/AbstractMiscGetAddress';
-import type { MiscGetAddressParams } from '../../common/AbstractMiscGetAddress';
-export default class RippleGetAddress extends AbstractMiscGetAddress<'rippleGetAddress'> {
-    constructor(message: MethodMessage<'rippleGetAddress'>);
-    get info(): string;
-    get confirmation(): {
-        view: "export-address";
-        label: string;
-    };
-    _call({ proto }: MiscGetAddressParams): Promise<{
-        mac?: string | undefined;
-        address: string;
-    }>;
-}

package/libESM/api/ripple/api/rippleGetAddress.mjs

@@ -1,22 +0,0 @@
-import { getMiscNetwork } from "../../../data/coinInfo.mjs";
-import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.mjs";
-export default class RippleGetAddress extends AbstractMiscGetAddress {
-  constructor(message) {
-    super(message, 3);
-    this.requiredDeviceCapabilities = ['Capability_Ripple'];
-    this.requiredFirmwareCoins = [getMiscNetwork('Ripple')];
-  }
-  get info() {
-    return this.getInfo('Ripple', true);
-  }
-  get confirmation() {
-    return this.getConfirmation('Ripple');
-  }
-  async _call({
-    proto
-  }) {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('RippleGetAddress', 'RippleAddress', proto);
-    return response.message;
-  }
-}

package/libESM/api/ripple/api/rippleSignTransaction.d.mts

@@ -1,13 +0,0 @@
-import { type MethodPermission } from '@trezor/connect-common';
-import type { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodMessage } from '../../../core/AbstractMethod';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-export default class RippleSignTransaction extends AbstractMethod<'rippleSignTransaction', PROTO.RippleSignTx> {
-    constructor(message: MethodMessage<'rippleSignTransaction'>);
-    get requiredPermissions(): MethodPermission[];
-    get info(): string;
-    run(): Promise<{
-        serializedTx: string;
-        signature: string;
-    }>;
-}