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

package/lib/api/resetDevice.js

@@ -1,133 +0,0 @@
-import { UI_REQUEST } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { TransportError } from "@trezor/connect-common/lib/constants/errors.js";
-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.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { validatePath } from "../utils/pathUtils.js";
-import { calculateXPubHashes } from "./firmware/calculateXPubHash.js";
-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 [{
-      permission: '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/lib/api/ripple/api/index.d.ts

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

package/lib/api/ripple/api/index.js

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

package/lib/api/ripple/api/rippleGetAddress.d.ts

@@ -1,17 +0,0 @@
-import type { MethodMessage } from "../../../core/AbstractMethod.js";
-import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
-import type { MiscGetAddressParams } from "../../common/AbstractMiscGetAddress.js";
-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/lib/api/ripple/api/rippleGetAddress.js

@@ -1,22 +0,0 @@
-import { getMiscNetwork } from "../../../data/coinInfo.js";
-import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
-export default class RippleGetAddress extends AbstractMiscGetAddress {
-  constructor(message) {
-    super(message, 3);
-    this.requiredDeviceCapabilities = ['Capability_Ripple'];
-    this.requiredFirmwareCoins = [getMiscNetwork('xrp')];
-  }
-  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/lib/api/ripple/api/rippleSignTransaction.d.ts

@@ -1,13 +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 RippleSignTransaction extends AbstractMethod<'rippleSignTransaction', PROTO.RippleSignTx> {
-  constructor(message: MethodMessage<'rippleSignTransaction'>);
-  get requiredPermissions(): PermissionRequest[];
-  get info(): string;
-  run(): Promise<{
-    serializedTx: string;
-    signature: string;
-  }>;
-}

package/lib/api/ripple/api/rippleSignTransaction.js

@@ -1,52 +0,0 @@
-import { RippleSignTransaction as RippleSignTransactionSchema } 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";
-import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.js";
-export default class RippleSignTransaction extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(RippleSignTransactionSchema, payload);
-    const path = validatePath(payload.path, 5);
-    const {
-      transaction,
-      chunkify
-    } = payload;
-    const params = {
-      address_n: path,
-      fee: transaction.fee,
-      flags: transaction.flags,
-      sequence: transaction.sequence,
-      last_ledger_sequence: transaction.maxLedgerVersion,
-      payment: {
-        amount: transaction.payment.amount,
-        destination: transaction.payment.destination,
-        destination_tag: transaction.payment.destinationTag
-      },
-      payment_req: payload.payment_req ? encodePaymentRequestAmount(payload.payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT) : undefined,
-      chunkify: typeof chunkify === 'boolean' ? chunkify : false
-    };
-    super(message, params);
-    this.requiredDeviceCapabilities = ['Capability_Ripple'];
-    this.requiredFirmwareCoins = [getMiscNetwork('xrp')];
-  }
-  get requiredPermissions() {
-    return this.coinPerms('sign', this.requiredFirmwareCoins);
-  }
-  get info() {
-    return 'Sign Ripple transaction';
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const {
-      message
-    } = await cmd.typedCall('RippleSignTx', 'RippleSignedTx', this.params);
-    return {
-      serializedTx: message.serialized_tx,
-      signature: message.signature
-    };
-  }
-}

package/lib/api/selectAccount.d.ts

@@ -1,15 +0,0 @@
-import { type CoinInfo, type PermissionRequest } from '@trezor/connect-common';
-import { type AddressSelection } from '@trezor/connect-common/lib/types/api/selectAccount';
-import type { MethodMessage, MethodReturnType } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-type Params = {
-  coinInfo: CoinInfo;
-  addressSelection?: AddressSelection;
-};
-export default class SelectAccount extends AbstractMethod<'selectAccount', Params> {
-  constructor(message: MethodMessage<'selectAccount'>);
-  get requiredPermissions(): PermissionRequest[];
-  get info(): string;
-  run(): Promise<MethodReturnType<'selectAccount'>>;
-}
-export {};

package/lib/api/selectAccount.js

@@ -1,42 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { SelectAccount as SelectAccountSchema } from "@trezor/connect-common/lib/types/api/selectAccount.js";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { getCoinInfoOrThrow } from "../data/coinInfo.js";
-import { isUtxoBased } from "../utils/accountUtils.js";
-import { getLabel } from "../utils/pathUtils.js";
-export default class SelectAccount extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(SelectAccountSchema, payload);
-    const {
-      selectionType
-    } = payload;
-    const bounds = typeof selectionType === 'object' && selectionType !== null ? selectionType : undefined;
-    if (bounds?.minCount !== undefined && bounds.maxCount !== undefined && bounds.minCount > bounds.maxCount) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'selectionType.minCount cannot be greater than selectionType.maxCount');
-    }
-    const coinInfo = getCoinInfoOrThrow(payload.coin);
-    super(message, {
-      coinInfo,
-      addressSelection: payload.addressSelection
-    });
-    this.useDevice = false;
-    this.useDeviceState = false;
-    this.useUi = true;
-    this.requiredFirmwareCoins = [coinInfo];
-  }
-  get requiredPermissions() {
-    const isFullAccount = this.params.addressSelection === undefined || this.params.addressSelection === 'fullAccount';
-    const permission = isUtxoBased(this.params.coinInfo) && isFullAccount ? 'read_xpub' : 'read_address';
-    return this.coinPerms(permission, this.requiredFirmwareCoins);
-  }
-  get info() {
-    return getLabel('Select #NETWORK account', this.params.coinInfo);
-  }
-  run() {
-    return Promise.resolve([]);
-  }
-}

package/lib/api/setBrightness.d.ts

@@ -1,12 +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 SetBrightness extends AbstractMethod<'setBrightness', PROTO.SetBrightness> {
-  constructor(message: MethodMessage<'setBrightness'>);
-  get requiredPermissions(): PermissionRequest[];
-  init(): void;
-  run(): Promise<{
-    message: string;
-  }>;
-}

package/lib/api/setBrightness.js

@@ -1,28 +0,0 @@
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class SetBrightness extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(PROTO.SetBrightness, payload);
-    const params = {
-      value: payload.value
-    };
-    super(message, params);
-    this.skipFinalReload = false;
-    this.useDeviceState = false;
-  }
-  get requiredPermissions() {
-    return [{
-      permission: 'management'
-    }];
-  }
-  init() {}
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('SetBrightness', 'Success', this.params);
-    return response.message;
-  }
-}

package/lib/api/setBusy.d.ts

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

package/lib/api/setBusy.js

@@ -1,31 +0,0 @@
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class SetBusy extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    const params = {
-      expiry_ms: payload.expiry_ms
-    };
-    super(message, params);
-    this.useDeviceState = false;
-    this.skipFinalReload = false;
-    this.overridePreviousCall = true;
-  }
-  get requiredPermissions() {
-    return [{
-      permission: 'management'
-    }];
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const {
-      message
-    } = await cmd.typedCall('SetBusy', 'Success', this.params);
-    if (this.keepSession && !!this.params.expiry_ms) {
-      this.getDevice().features.busy = true;
-      this.getDevice().emitDeviceChanged();
-    }
-    return message;
-  }
-}

package/lib/api/showDeviceTutorial.d.ts

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

package/lib/api/showDeviceTutorial.js

@@ -1,21 +0,0 @@
-import { UI_REQUEST } from "@trezor/connect-common";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class ShowDeviceTutorial extends AbstractMethod {
-  constructor(message) {
-    super(message, undefined);
-    this.useEmptyPassphrase = true;
-    this.useDeviceState = false;
-    this.allowDeviceMode = [UI_REQUEST.INITIALIZE];
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  get info() {
-    return 'Show device tutorial';
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('ShowDeviceTutorial', 'Success');
-    return response.message;
-  }
-}

package/lib/api/signMessage.d.ts

@@ -1,25 +0,0 @@
-import type { BitcoinNetworkInfo, 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";
-type Params = {
-  proto: PROTO.SignMessage;
-  readableMessage: string;
-};
-export default class SignMessage extends AbstractMethod<'signMessage', Params> {
-  constructor(message: MethodMessage<'signMessage'>);
-  coinInfo: BitcoinNetworkInfo | undefined;
-  get requiredPermissions(): PermissionRequest[];
-  get info(): string;
-  getButtonRequestData(code: string, name?: string): {
-    type: "message";
-    serializedPath: string;
-    coin: string;
-    message: string;
-  } | undefined;
-  run(): Promise<{
-    address: string;
-    signature: string;
-  }>;
-}
-export {};

package/lib/api/signMessage.js

@@ -1,75 +0,0 @@
-import { SignMessage as SignMessageSchema } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { validateCoinPath } from "./common/paramsValidator.js";
-import { getBitcoinNetwork } from "../data/coinInfo.js";
-import { validateModelOneMessageSize } from "../device/validateMessageSize.js";
-import { hexToText, messageToHex } from "../utils/formatUtils.js";
-import { getLabel, getScriptType, getSerializedPath, validatePath } from "../utils/pathUtils.js";
-export default class SignMessage extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(SignMessageSchema, payload);
-    const path = validatePath(payload.path);
-    let coinInfo;
-    if (payload.coin) {
-      coinInfo = getBitcoinNetwork(payload.coin);
-      if (!coinInfo) {
-        throw ERRORS.TypedError('Method_UnknownCoin');
-      }
-      validateCoinPath(path, coinInfo);
-    } else {
-      coinInfo = getBitcoinNetwork(path);
-    }
-    const messageHex = payload.hex ? messageToHex(payload.message) : Buffer.from(payload.message, 'utf8').toString('hex');
-    const readableMessage = payload.hex ? hexToText(payload.message) : payload.message;
-    const scriptType = getScriptType(path);
-    const proto = {
-      address_n: path,
-      message: messageHex,
-      coin_name: coinInfo ? coinInfo.name : undefined,
-      script_type: scriptType && scriptType !== 'SPENDMULTISIG' ? scriptType : 'SPENDADDRESS',
-      no_script_type: payload.no_script_type
-    };
-    const params = {
-      proto,
-      readableMessage
-    };
-    super(message, params);
-    this.coinInfo = coinInfo;
-    this.requiredFirmwareCoins = [coinInfo];
-    if (payload.no_script_type) {
-      this.requiredFirmwareCapabilities = ['signMessageNoScriptType'];
-    }
-  }
-  coinInfo;
-  get requiredPermissions() {
-    return [this.coinPerm('sign_message', this.coinInfo)];
-  }
-  get info() {
-    return getLabel('Sign #NETWORK message', this.coinInfo);
-  }
-  getButtonRequestData(code, name) {
-    if (code === 'ButtonRequest_Other' && name === 'sign_message') {
-      return {
-        type: 'message',
-        serializedPath: getSerializedPath(this.params.proto.address_n),
-        coin: this.coinInfo?.shortcut ?? 'BTC',
-        message: this.params.readableMessage
-      };
-    }
-  }
-  async run() {
-    validateModelOneMessageSize(this.getDevice(), this.params.proto.message);
-    const cmd = this.getDevice().getCommands();
-    const {
-      message
-    } = await cmd.typedCall('SignMessage', 'MessageSignature', this.params.proto);
-    const signatureBuffer = Buffer.from(message.signature, 'hex');
-    message.signature = signatureBuffer.toString('base64');
-    return message;
-  }
-}