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

package/lib/api/monero/api/moneroSignTransaction.js

@@ -1,218 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { HD_HARDENED_PATH_PART } from "@trezor/crypto-utils";
-import { AbstractMethod } from "../../../core/AbstractMethod.js";
-import { getMiscNetwork } from "../../../data/coinInfo.js";
-import { validatePath } from "../../../utils/pathUtils.js";
-export default class MoneroSignTransactionMethod extends AbstractMethod {
-  get requiredPermissions() {
-    return this.coinPerms('sign', this.requiredFirmwareCoins);
-  }
-  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_PATH_PART) !== 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('xmr')];
-  }
-  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 {
-        inputs
-      } = this.params;
-      const input = inputs[i];
-      const setInputResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionSetInputRequest', 'MoneroTransactionSetInputAck', {
-        src_entr: input
-      });
-      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: input,
-        orig_idx: i
-      });
-    }
-    for (let i = 0; i < this.state.vinis.length; i++) {
-      const {
-        vinis
-      } = this.state;
-      const viniData = 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 output = outputs[i];
-      const {
-        hmacs
-      } = this.state;
-      const hmac = hmacs[i];
-      const setOutputResponse = await this.getDevice().getCommands().typedCall('MoneroTransactionSetOutputRequest', 'MoneroTransactionSetOutputAck', {
-        dst_entr: output,
-        dst_entr_hmac: hmac
-      });
-      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 {
-        vinis
-      } = this.state;
-      const viniData = 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/lib/api/nostr/nostrGetPublicKey.d.ts

@@ -1,15 +0,0 @@
-import { type PROTO } from '@trezor/connect-common';
-import type { MethodMessage } from "../../core/AbstractMethod.js";
-import { AbstractMethod } from "../../core/AbstractMethod.js";
-export default class NostrGetPublicKey extends AbstractMethod<'nostrGetPublicKey', PROTO.NostrGetPubkey> {
-  constructor(message: MethodMessage<'nostrGetPublicKey'>);
-  get requiredPermissions(): import("@trezor/connect-common").PermissionRequest[];
-  get info(): string;
-  get confirmation(): {
-    view: "export-xpub";
-    label: string;
-  };
-  run(): Promise<{
-    pubkey: string;
-  }>;
-}

package/lib/api/nostr/nostrGetPublicKey.js

@@ -1,38 +0,0 @@
-import { ExperimentalMethod, GetPublicKey as GetPublicKeySchema } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../../core/AbstractMethod.js";
-import { getMiscNetwork } from "../../data/coinInfo.js";
-import { validatePath } from "../../utils/pathUtils.js";
-export default class NostrGetPublicKey extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(GetPublicKeySchema, payload);
-    Assert(ExperimentalMethod, payload);
-    const params = {
-      address_n: validatePath(payload.path)
-    };
-    super(message, params);
-    this.requiredFirmwareCoins = [getMiscNetwork('nostr')];
-  }
-  get requiredPermissions() {
-    return this.coinPerms('read_xpub', this.requiredFirmwareCoins);
-  }
-  get info() {
-    return 'Export nostr public key';
-  }
-  get confirmation() {
-    return {
-      view: 'export-xpub',
-      label: 'Export Nostr public key'
-    };
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const {
-      message
-    } = await cmd.typedCall('NostrGetPubkey', 'NostrPubkey', this.params);
-    return message;
-  }
-}

package/lib/api/nostr/nostrSignEvent.d.ts

@@ -1,13 +0,0 @@
-import { type PROTO } from '@trezor/connect-common';
-import type { MethodMessage } from "../../core/AbstractMethod.js";
-import { AbstractMethod } from "../../core/AbstractMethod.js";
-export default class NostrSignEvent extends AbstractMethod<'nostrSignEvent', PROTO.NostrSignEvent> {
-  constructor(message: MethodMessage<'nostrSignEvent'>);
-  get requiredPermissions(): import("@trezor/connect-common").PermissionRequest[];
-  get info(): string;
-  run(): Promise<{
-    signature: string;
-    id: string;
-    pubkey: string;
-  }>;
-}

package/lib/api/nostr/nostrSignEvent.js

@@ -1,36 +0,0 @@
-import { ExperimentalMethod, NostrSignEvent as NostrSignEventSchema } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../../core/AbstractMethod.js";
-import { getMiscNetwork } from "../../data/coinInfo.js";
-import { validatePath } from "../../utils/pathUtils.js";
-export default class NostrSignEvent extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(NostrSignEventSchema, payload);
-    Assert(ExperimentalMethod, payload);
-    const params = {
-      address_n: validatePath(payload.path),
-      created_at: payload.created_at,
-      kind: payload.kind,
-      tags: payload.tags,
-      content: payload.content
-    };
-    super(message, params);
-    this.requiredFirmwareCoins = [getMiscNetwork('nostr')];
-  }
-  get requiredPermissions() {
-    return this.coinPerms('sign', this.requiredFirmwareCoins);
-  }
-  get info() {
-    return 'Sign Nostr event';
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const {
-      message
-    } = await cmd.typedCall('NostrSignEvent', 'NostrEventSignature', this.params);
-    return message;
-  }
-}

package/lib/api/pingDevice.d.ts

@@ -1,11 +0,0 @@
-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 PingDevice extends AbstractMethod<'pingDevice', PROTO.Ping> {
-  constructor(message: MethodMessage<'pingDevice'>);
-  get requiredPermissions(): PermissionRequest[];
-  run(): Promise<{
-    message: string;
-  }>;
-}

package/lib/api/pingDevice.js

@@ -1,29 +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.js";
-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 [{
-      permission: 'management'
-    }];
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('Ping', 'Success', this.params);
-    return response.message;
-  }
-}

package/lib/api/pushTransaction.d.ts

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

package/lib/api/pushTransaction.js

@@ -1,39 +0,0 @@
-import { PushTransaction as PushTransactionSchema } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { Assert } from "@trezor/schema-utils";
-import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { getCoinInfoOrThrow } from "../data/coinInfo.js";
-export default class PushTransaction extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(PushTransactionSchema, payload);
-    const coinInfo = getCoinInfoOrThrow(payload.coin);
-    assertBackendSupported(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 [this.coinPerm('push_tx', this.params.coinInfo)];
-  }
-  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/lib/api/recoveryDevice.d.ts

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

package/lib/api/recoveryDevice.js

@@ -1,52 +0,0 @@
-import { UI_REQUEST } from "@trezor/connect-common";
-import { RecoveryDevice as RecoveryDeviceSchema } from "@trezor/connect-common/lib/types/api/management/recoveryDevice.js";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-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 [{
-      permission: '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/lib/api/requestLogin.d.ts

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

package/lib/api/requestLogin.js

@@ -1,53 +0,0 @@
-import { RequestLoginSchema } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class RequestLogin extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(RequestLoginSchema, payload);
-    const identity = {};
-    const {
-      origin
-    } = payload;
-    if (origin) {
-      const originParts = origin.split(':');
-      const proto = originParts[0] ?? '';
-      const host = originParts[1] ?? '';
-      const port = originParts[2];
-      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 [{
-      permission: 'sign'
-    }];
-  }
-  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/lib/api/resetDevice.d.ts

@@ -1,22 +0,0 @@
-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 ResetDevice extends AbstractMethod<'resetDevice', PROTO.ResetDevice> {
-  constructor(message: MethodMessage<'resetDevice'>);
-  get requiredPermissions(): PermissionRequest[];
-  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;
-  }>;
-}