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

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

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

@@ -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 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

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

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

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

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

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

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

@@ -1,81 +0,0 @@
-import { type CardanoSignedTxData, 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 { CertificateWithPoolOwnersAndRelays } from "../cardanoCertificate.js";
-import type { CollateralInputWithPath, InputWithPath, Path } from "../cardanoInputs.js";
-import type { OutputWithData } from "../cardanoOutputs.js";
-import type { AssetGroupWithTokens } from "../cardanoTokenBundle.js";
-declare const CardanoSignTransactionFeatures: Readonly<{
-  Conway: string[];
-}>;
-export type CardanoSignTransactionParams = {
-  signingMode: PROTO.CardanoTxSigningMode;
-  inputsWithPath: InputWithPath[];
-  outputsWithData: OutputWithData[];
-  fee: PROTO.CardanoSignTxInit['fee'];
-  ttl?: PROTO.CardanoSignTxInit['ttl'];
-  certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[];
-  withdrawals: PROTO.CardanoTxWithdrawal[];
-  mint: AssetGroupWithTokens[];
-  auxiliaryData?: PROTO.CardanoTxAuxiliaryData;
-  validityIntervalStart?: PROTO.CardanoSignTxInit['validity_interval_start'];
-  scriptDataHash?: string;
-  collateralInputsWithPath: CollateralInputWithPath[];
-  requiredSigners: PROTO.CardanoTxRequiredSigner[];
-  collateralReturnWithData?: OutputWithData;
-  totalCollateral?: PROTO.CardanoSignTxInit['total_collateral'];
-  referenceInputs: PROTO.CardanoTxReferenceInput[];
-  protocolMagic: number;
-  networkId: number;
-  witnessPaths: Path[];
-  additionalWitnessRequests: Path[];
-  derivationType: PROTO.CardanoDerivationType;
-  includeNetworkId?: boolean;
-  tagCborSets?: boolean;
-  unsignedTx?: {
-    body: string;
-    hash: string;
-  };
-  testnet?: boolean;
-  chunkify?: boolean;
-  payment_req?: PROTO.PaymentRequest;
-};
-export default class CardanoSignTransaction extends AbstractMethod<'cardanoSignTransaction', CardanoSignTransactionParams> {
-  constructor(message: MethodMessage<'cardanoSignTransaction'>);
-  get requiredPermissions(): PermissionRequest[];
-  get info(): string;
-  _isFeatureSupported(feature: keyof typeof CardanoSignTransactionFeatures): boolean;
-  _ensureFeatureIsSupported(feature: keyof typeof CardanoSignTransactionFeatures): void;
-  _ensureFirmwareSupportsParams(): void;
-  _sign_tx(): Promise<CardanoSignedTxData>;
-  run(): Promise<{
-    auxiliaryDataSupplement?: {
-      cVoteRegistrationSignature?: string | undefined;
-      type: PROTO.CardanoTxAuxiliaryDataSupplementType;
-      auxiliaryDataHash: string;
-    } | undefined;
-    hash: string;
-    witnesses: {
-      chainCode?: string | undefined;
-      type: PROTO.CardanoTxWitnessType;
-      signature: string;
-      pubKey: string;
-    }[];
-  } | {
-    serializedTx: string;
-    auxiliaryDataSupplement?: {
-      cVoteRegistrationSignature?: string | undefined;
-      type: PROTO.CardanoTxAuxiliaryDataSupplementType;
-      auxiliaryDataHash: string;
-    } | undefined;
-    hash: string;
-    witnesses: {
-      chainCode?: string | undefined;
-      type: PROTO.CardanoTxWitnessType;
-      signature: string;
-      pubKey: string;
-    }[];
-  }>;
-}
-export {};