@trezor/connect 9.7.3 → 10.0.0-alpha.1

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,202 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,131 @@
+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

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

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

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

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,13 @@
+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;
+    }>;
+}