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

package/lib/api/cancelCoinjoinAuthorization.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 CancelCoinjoinAuthorization extends AbstractMethod<'cancelCoinjoinAuthorization'> {
+  constructor(message: MethodMessage<'cancelCoinjoinAuthorization'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/cancelCoinjoinAuthorization.js

@@ -0,0 +1,33 @@
+import { CancelCoinjoinAuthorization as CancelCoinjoinAuthorizationSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class CancelCoinjoinAuthorization extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(CancelCoinjoinAuthorizationSchema, payload);
+    super(message, undefined);
+    this.preauthorized = typeof payload.preauthorized === 'boolean' ? payload.preauthorized : true;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'internal'
+    }];
+  }
+  get info() {
+    return 'Cancel Coinjoin Authorization';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    if (!this.preauthorized) {
+      if (!(await cmd.preauthorize(false))) {
+        return {
+          message: 'Not authorized'
+        };
+      }
+    }
+    const response = await cmd.typedCall('CancelAuthorization', 'Success');
+    return response.message;
+  }
+}

package/lib/api/cardano/api/cardanoComposeTransaction.d.ts

@@ -0,0 +1,10 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import { type CardanoComposeTransactionParams, type PrecomposedTransactionCardano } from '@trezor/connect-common/lib/types/api/cardano/cardanoComposeTransaction';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+export default class CardanoComposeTransaction extends AbstractMethod<'cardanoComposeTransaction', CardanoComposeTransactionParams> {
+  constructor(message: MethodMessage<'cardanoComposeTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<PrecomposedTransactionCardano[]>;
+}

package/lib/api/cardano/api/cardanoComposeTransaction.js

@@ -0,0 +1,84 @@
+import { CardanoComposeTransactionParamsSchema } from "@trezor/connect-common/lib/types/api/cardano/cardanoComposeTransaction.js";
+import cardano from "@trezor/network-cardano/runtime";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getCoinSelectionParams } from "../cardanoUtils.js";
+export default class CardanoComposeTransaction extends AbstractMethod {
+  constructor(message) {
+    Assert(CardanoComposeTransactionParamsSchema, message.payload);
+    super(message, message.payload);
+    this.useDevice = false;
+    this.useDeviceState = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  get info() {
+    return 'Compose Cardano transaction';
+  }
+  async run() {
+    const {
+      feeLevels = [{}],
+      account,
+      outputs = [],
+      certificates = [],
+      withdrawals = [],
+      changeAddress,
+      addressParameters,
+      testnet
+    } = this.params;
+    const {
+      trezorUtils,
+      asCoinSelectionError,
+      coinSelection
+    } = await cardano();
+    const result = feeLevels.map(({
+      feePerUnit
+    }) => {
+      try {
+        const txPlan = coinSelection(getCoinSelectionParams(account.descriptor, account.utxo, outputs, certificates, withdrawals, changeAddress.address, !!testnet), {
+          feeParams: feePerUnit ? {
+            a: feePerUnit
+          } : undefined
+        });
+        return {
+          fee: txPlan.fee,
+          feePerByte: feePerUnit ?? '0',
+          deposit: txPlan.deposit,
+          totalSpent: txPlan.totalSpent,
+          max: txPlan.max,
+          ...(txPlan.type === 'nonfinal' ? {
+            type: txPlan.type,
+            bytes: 0
+          } : {
+            type: txPlan.type,
+            bytes: txPlan.tx.size,
+            ttl: txPlan.ttl,
+            inputs: trezorUtils.transformToTrezorInputs(txPlan.inputs, account.utxo),
+            outputs: trezorUtils.transformToTrezorOutputs(txPlan.outputs, addressParameters),
+            unsignedTx: txPlan.tx
+          })
+        };
+      } catch (error) {
+        if (asCoinSelectionError(error)?.code === 'UTXO_BALANCE_INSUFFICIENT') {
+          return {
+            type: 'error',
+            error: 'UTXO_BALANCE_INSUFFICIENT'
+          };
+        }
+        if (asCoinSelectionError(error)?.code === 'UTXO_VALUE_TOO_SMALL') {
+          return {
+            type: 'error',
+            error: 'UTXO_VALUE_TOO_SMALL'
+          };
+        }
+        return {
+          type: 'error',
+          error: error.message
+        };
+      }
+    });
+    return result;
+  }
+}

package/lib/api/cardano/api/cardanoGetAddress.d.ts

@@ -0,0 +1,34 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  proto: PROTO.CardanoGetAddress;
+  address?: string;
+};
+export default class CardanoGetAddress extends AbstractMethod<'cardanoGetAddress', Params[]> {
+  hasBundle?: boolean;
+  progress: number;
+  constructor(message: MethodMessage<'cardanoGetAddress'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  getButtonRequestData(code: string): {
+    type: "address";
+    serializedPath: string;
+    address: string;
+  } | undefined;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  } | undefined;
+  _call({
+    proto
+  }: Params): Promise<{
+    mac?: string | undefined;
+    address: string;
+  }>;
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<import("@trezor/connect-common").CardanoAddress | import("@trezor/connect-common").CardanoAddress[]>;
+}
+export {};

package/lib/api/cardano/api/cardanoGetAddress.js

@@ -0,0 +1,130 @@
+import { Bundle, CardanoGetAddress as CardanoGetAddressSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { getSerializedPath } from "../../../utils/pathUtils.js";
+import { bundlify } from "../../common/paramsValidator.js";
+import { addressParametersFromProto, addressParametersToProto, modifyAddressParametersForBackwardsCompatibility, validateAddressParameters } from "../cardanoAddressParameters.js";
+export default class CardanoGetAddress extends AbstractMethod {
+  hasBundle;
+  progress = 0;
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(CardanoGetAddressSchema), payload);
+    const params = payload.bundle.map(batch => {
+      validateAddressParameters(batch.addressParameters);
+      const proto = {
+        address_parameters: addressParametersToProto(batch.addressParameters),
+        protocol_magic: batch.protocolMagic,
+        network_id: batch.networkId,
+        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+        chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
+      };
+      return {
+        proto,
+        address: batch.address
+      };
+    });
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.confirmMissingBackup = true;
+    this.requiredDeviceCapabilities = ['Capability_Cardano'];
+    this.requiredFirmwareCoins = [getMiscNetwork('ada')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_address', this.requiredFirmwareCoins);
+  }
+  get info() {
+    if (this.params.length === 1) {
+      const {
+        params
+      } = this;
+      const first = params[0];
+      const addressN = first.proto.address_parameters.address_n;
+      const accountIndex = addressN[2];
+      return `Export Cardano address for account #${fromHardenedPathPart(accountIndex) + 1}`;
+    }
+    return 'Export multiple Cardano addresses';
+  }
+  getButtonRequestData(code) {
+    if (code === 'ButtonRequest_Address') {
+      const {
+        params
+      } = this;
+      const current = params[this.progress];
+      return {
+        type: 'address',
+        serializedPath: getSerializedPath(current.proto.address_parameters.address_n),
+        address: current.address || 'not-set'
+      };
+    }
+  }
+  get confirmation() {
+    return !this.useUi ? undefined : {
+      view: 'export-address',
+      label: this.info
+    };
+  }
+  async _call({
+    proto
+  }) {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('CardanoGetAddress', 'CardanoAddress', proto);
+    return response.message;
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    for (let i = 0; i < this.params.length; i++) {
+      const {
+        params
+      } = this;
+      const batch = params[i];
+      batch.proto.address_parameters = modifyAddressParametersForBackwardsCompatibility(batch.proto.address_parameters);
+      if (batch.proto.show_display) {
+        const silent = await this._call({
+          ...batch,
+          proto: {
+            ...batch.proto,
+            show_display: false
+          }
+        });
+        if (typeof batch.address === 'string') {
+          if (batch.address !== silent.address) {
+            throw ERRORS.TypedError('Method_AddressNotMatch');
+          }
+        } else {
+          batch.address = silent.address;
+        }
+      }
+      const response = await this._call(batch);
+      responses.push({
+        addressParameters: addressParametersFromProto(batch.proto.address_parameters),
+        protocolMagic: batch.proto.protocol_magic,
+        networkId: batch.proto.network_id,
+        serializedPath: getSerializedPath(batch.proto.address_parameters.address_n),
+        serializedStakingPath: getSerializedPath(batch.proto.address_parameters.address_n_staking),
+        address: response.address,
+        mac: response.mac
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response
+        }));
+      }
+      this.progress++;
+    }
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
+  }
+}

package/lib/api/cardano/api/cardanoGetNativeScriptHash.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 CardanoGetNativeScriptHash extends AbstractMethod<'cardanoGetNativeScriptHash', PROTO.CardanoGetNativeScriptHash> {
+  constructor(message: MethodMessage<'cardanoGetNativeScriptHash'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    scriptHash: string;
+  }>;
+}

package/lib/api/cardano/api/cardanoGetNativeScriptHash.js

@@ -0,0 +1,66 @@
+import { CardanoGetNativeScriptHash as CardanoGetNativeScriptHashSchema } from "@trezor/connect-common";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+const validateScript = script => {
+  if (script.keyPath) {
+    validatePath(script.keyPath, 3);
+  }
+  script.scripts?.forEach(validateScript);
+};
+const scriptToProto = script => {
+  let scripts = [];
+  if (script.scripts) {
+    scripts = script.scripts.map(scriptToProto);
+  }
+  let keyPath = [];
+  if (script.keyPath) {
+    keyPath = validatePath(script.keyPath, 3);
+  }
+  return {
+    type: script.type,
+    scripts,
+    key_hash: script.keyHash,
+    key_path: keyPath,
+    required_signatures_count: script.requiredSignaturesCount,
+    invalid_before: script.invalidBefore,
+    invalid_hereafter: script.invalidHereafter
+  };
+};
+export default class CardanoGetNativeScriptHash extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(CardanoGetNativeScriptHashSchema, payload);
+    validateScript(payload.script);
+    const params = {
+      script: scriptToProto(payload.script),
+      display_format: payload.displayFormat,
+      derivation_type: typeof payload.derivationType !== 'undefined' ? payload.derivationType : PROTO.CardanoDerivationType.ICARUS_TREZOR
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Cardano'];
+    this.requiredFirmwareCoins = [getMiscNetwork('ada')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_address', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Get Cardano native script hash';
+  }
+  async run() {
+    const {
+      message
+    } = await this.getDevice().getCommands().typedCall('CardanoGetNativeScriptHash', 'CardanoNativeScriptHash', {
+      script: this.params.script,
+      display_format: this.params.display_format,
+      derivation_type: this.params.derivation_type
+    });
+    return {
+      scriptHash: message.script_hash
+    };
+  }
+}

package/lib/api/cardano/api/cardanoGetPublicKey.d.ts

@@ -0,0 +1,22 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+interface Params {
+  proto: PROTO.CardanoGetPublicKey;
+  suppressBackupWarning?: boolean;
+}
+export default class CardanoGetPublicKey extends AbstractMethod<'cardanoGetPublicKey', Params[]> {
+  hasBundle?: boolean;
+  constructor(message: MethodMessage<'cardanoGetPublicKey'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  get confirmation(): {
+    view: "export-xpub";
+    label: string;
+  };
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<import("@trezor/connect-common").CardanoPublicKey | import("@trezor/connect-common").CardanoPublicKey[]>;
+}
+export {};

package/lib/api/cardano/api/cardanoGetPublicKey.js

@@ -0,0 +1,92 @@
+import { Bundle, CardanoGetPublicKey as CardanoGetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { getSerializedPath, validatePath } from "../../../utils/pathUtils.js";
+import { bundlify } from "../../common/paramsValidator.js";
+export default class CardanoGetPublicKey extends AbstractMethod {
+  hasBundle;
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(CardanoGetPublicKeySchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 3);
+      const proto = {
+        address_n: path,
+        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false
+      };
+      return {
+        proto,
+        suppressBackupWarning: batch.suppressBackupWarning
+      };
+    });
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.confirmMissingBackup = !this.params.every(batch => batch.suppressBackupWarning || !batch.proto.show_display);
+    this.requiredDeviceCapabilities = ['Capability_Cardano'];
+    this.requiredFirmwareCoins = [getMiscNetwork('ada')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_xpub', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Export Cardano public key';
+  }
+  get confirmation() {
+    if (this.params.length > 1) {
+      return {
+        view: 'export-xpub',
+        label: 'Export multiple Cardano public keys'
+      };
+    }
+    const {
+      params
+    } = this;
+    const first = params[0];
+    const addressN = first.proto.address_n;
+    const accountIndex = addressN[2];
+    return {
+      view: 'export-xpub',
+      label: `Export Cardano public key for account #${fromHardenedPathPart(accountIndex) + 1}`
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const {
+        params
+      } = this;
+      const param = params[i];
+      const batch = param.proto;
+      const {
+        message
+      } = await cmd.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', batch);
+      responses.push({
+        path: batch.address_n,
+        serializedPath: getSerializedPath(batch.address_n),
+        publicKey: message.node.public_key,
+        xpub: message.xpub,
+        displayablePublicKey: message.xpub,
+        node: message.node
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response: message
+        }));
+      }
+    }
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
+  }
+}

package/lib/api/cardano/api/cardanoSignMessage.d.ts

@@ -0,0 +1,22 @@
+import { type CardanoMessageHeaders, type CardanoSignedMessage, 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";
+import type { Path } from "../cardanoInputs.js";
+export type CardanoSignMessageParams = {
+  path: Path;
+  payload: string;
+  preferHexDisplay: boolean;
+  networkId?: number;
+  protocolMagic?: number;
+  addressParameters?: PROTO.CardanoAddressParametersType;
+  derivationType: PROTO.CardanoDerivationType;
+};
+export default class CardanoSignMessage extends AbstractMethod<'cardanoSignMessage', CardanoSignMessageParams> {
+  static readonly VERSION = 1;
+  constructor(message: MethodMessage<'cardanoSignMessage'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<CardanoSignedMessage>;
+  _createHeaders(address: string): CardanoMessageHeaders;
+  get info(): string;
+}

package/lib/api/cardano/api/cardanoSignMessage.js

@@ -0,0 +1,90 @@
+import { CARDANO, CardanoSignMessage as CardanoSignMessageSchema } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import cardano from "@trezor/network-cardano/runtime";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { hasHexPrefix, isHexString } from "../../../utils/formatUtils.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+import { addressParametersToProto } from "../cardanoAddressParameters.js";
+import { hexStringByteLength } from "../cardanoUtils.js";
+export default class CardanoSignMessage extends AbstractMethod {
+  static VERSION = 1;
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(CardanoSignMessageSchema, payload);
+    if (!isHexString(payload.payload) || hasHexPrefix(payload.payload) || payload.payload.length % 2 !== 0) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Message payload must be a byte-aligned hexadecimal string (even number of characters) without a "0x" prefix.');
+    }
+    const params = {
+      path: validatePath(payload.path, 5),
+      payload: payload.payload,
+      preferHexDisplay: payload.preferHexDisplay ?? false,
+      networkId: payload.networkId,
+      protocolMagic: payload.protocolMagic,
+      addressParameters: payload.addressParameters && addressParametersToProto(payload.addressParameters),
+      derivationType: payload.derivationType ?? PROTO.CardanoDerivationType.ICARUS_TREZOR
+    };
+    super(message, params);
+    this.requiredFirmwareCoins = [getMiscNetwork('ada')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
+  }
+  async run() {
+    const typedCall = this.getDevice().getCommands().typedCall.bind(this.getDevice().getCommands());
+    const payloadSize = hexStringByteLength(this.params.payload);
+    let response = await typedCall('CardanoSignMessageInit', ['CardanoMessageSignature', 'CardanoMessageDataRequest'], {
+      signing_path: this.params.path,
+      payload_size: payloadSize,
+      network_id: this.params.networkId,
+      protocol_magic: this.params.protocolMagic,
+      address_parameters: this.params.addressParameters,
+      prefer_hex_display: this.params.preferHexDisplay,
+      derivation_type: this.params.derivationType
+    });
+    while (response.type !== 'CardanoMessageSignature') {
+      const {
+        length,
+        offset
+      } = response.message;
+      const data = this.params.payload.slice(offset * 2, (offset + length) * 2);
+      response = await typedCall('CardanoMessageDataResponse', ['CardanoMessageSignature', 'CardanoMessageDataRequest'], {
+        data
+      });
+    }
+    const {
+      signature,
+      address,
+      pub_key
+    } = response.message;
+    const {
+      createCose
+    } = await cardano();
+    return {
+      signature,
+      payload: this.params.payload,
+      headers: this._createHeaders(address),
+      pubKey: pub_key,
+      ...createCose(this.params.payload, signature, address, pub_key)
+    };
+  }
+  _createHeaders(address) {
+    return {
+      protected: {
+        1: CARDANO.ALGORITHM_IDS.EdDSA,
+        address
+      },
+      unprotected: {
+        hashed: false,
+        version: CardanoSignMessage.VERSION
+      }
+    };
+  }
+  get info() {
+    return 'Sign Cardano message';
+  }
+}