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

package/lib/api/resetDevice.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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