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

package/lib/api/cardano/cardanoCertificate.js

@@ -0,0 +1,142 @@
+import { CardanoCertificate, CardanoDRep, CardanoPoolParameters, CardanoPoolRelay } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { validatePath } from "../../utils/pathUtils.js";
+const ipv4AddressToHex = ipv4Address => Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
+const ipv6AddressToHex = ipv6Address => ipv6Address.split(':').join('');
+const validatePoolRelay = relay => {
+  Assert(CardanoPoolRelay, relay);
+  if (relay.type === PROTO.CardanoPoolRelayType.SINGLE_HOST_IP) {
+    if (!relay.ipv4Address && !relay.ipv6Address) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Either ipv4Address or ipv6Address must be supplied');
+    }
+  } else if (relay.type === PROTO.CardanoPoolRelayType.SINGLE_HOST_NAME) {
+    if (!relay.hostName) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
+    }
+    if (!relay.port) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'port must be supplied');
+    }
+  } else if (relay.type === PROTO.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
+    if (!relay.hostName) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
+    }
+  }
+};
+const validatePoolOwners = owners => {
+  owners.forEach(owner => {
+    if (owner.stakingKeyPath) {
+      validatePath(owner.stakingKeyPath, 5);
+    }
+    if (!owner.stakingKeyHash && !owner.stakingKeyPath) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Either stakingKeyHash or stakingKeyPath must be supplied');
+    }
+  });
+  const ownersAsPathCount = owners.filter(owner => !!owner.stakingKeyPath).length;
+  if (ownersAsPathCount !== 1) {
+    throw ERRORS.TypedError('Method_InvalidParameter', 'Exactly one pool owner must be given as a path');
+  }
+};
+const validatePoolParameters = poolParameters => {
+  Assert(CardanoPoolParameters, poolParameters);
+  validatePoolOwners(poolParameters.owners);
+  poolParameters.relays.forEach(validatePoolRelay);
+};
+const validateDRep = dRep => {
+  Assert(CardanoDRep, dRep);
+  if (dRep.type === PROTO.CardanoDRepType.KEY_HASH && !dRep.keyHash) {
+    throw ERRORS.TypedError('Method_InvalidParameter', 'keyHash must be supplied for KEY_HASH dRep type');
+  } else if (dRep.type === PROTO.CardanoDRepType.SCRIPT_HASH && !dRep.scriptHash) {
+    throw ERRORS.TypedError('Method_InvalidParameter', 'scriptHash must be supplied for SCRIPT_HASH dRep type');
+  }
+};
+const transformPoolParameters = poolParameters => {
+  if (!poolParameters) {
+    return {
+      poolParameters: undefined,
+      poolOwners: [],
+      poolRelays: []
+    };
+  }
+  validatePoolParameters(poolParameters);
+  return {
+    poolParameters: {
+      pool_id: poolParameters.poolId,
+      vrf_key_hash: poolParameters.vrfKeyHash,
+      pledge: poolParameters.pledge,
+      cost: poolParameters.cost,
+      margin_numerator: poolParameters.margin.numerator,
+      margin_denominator: poolParameters.margin.denominator,
+      reward_account: poolParameters.rewardAccount,
+      metadata: poolParameters.metadata,
+      owners_count: poolParameters.owners.length,
+      relays_count: poolParameters.relays.length
+    },
+    poolOwners: poolParameters.owners.map(owner => ({
+      staking_key_hash: owner.stakingKeyHash,
+      staking_key_path: owner.stakingKeyPath ? validatePath(owner.stakingKeyPath, 5) : undefined
+    })),
+    poolRelays: poolParameters.relays.map(relay => ({
+      type: relay.type,
+      ipv4_address: relay.ipv4Address ? ipv4AddressToHex(relay.ipv4Address) : undefined,
+      ipv6_address: relay.ipv6Address ? ipv6AddressToHex(relay.ipv6Address) : undefined,
+      host_name: relay.hostName,
+      port: relay.port
+    }))
+  };
+};
+const transformDRep = dRep => {
+  if (!dRep) {
+    return undefined;
+  }
+  validateDRep(dRep);
+  return {
+    type: dRep.type,
+    key_hash: dRep.keyHash,
+    script_hash: dRep.scriptHash
+  };
+};
+export const transformCertificate = certificate => {
+  Assert(CardanoCertificate, certificate);
+  if (certificate.type === PROTO.CardanoCertificateType.STAKE_DELEGATION) {
+    if (!certificate.pool) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'pool must be supplied for STAKE_DELEGATION');
+    }
+  }
+  if (certificate.type === PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+    if (!certificate.poolParameters) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'poolParameters must be supplied for STAKE_POOL_REGISTRATION');
+    }
+  }
+  if (certificate.type === PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY) {
+    if (!certificate.deposit) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'deposit must be supplied for STAKE_REGISTRATION_CONWAY or STAKE_DEREGISTRATION_CONWAY');
+    }
+  }
+  if (certificate.type === PROTO.CardanoCertificateType.VOTE_DELEGATION) {
+    if (!certificate.dRep) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'dRep must be supplied for VOTE_DELEGATION');
+    }
+  }
+  const {
+    poolParameters,
+    poolOwners,
+    poolRelays
+  } = transformPoolParameters(certificate.poolParameters);
+  const dRep = transformDRep(certificate.dRep);
+  return {
+    certificate: {
+      type: certificate.type,
+      path: certificate.path ? validatePath(certificate.path, 5) : undefined,
+      script_hash: certificate.scriptHash,
+      key_hash: certificate.keyHash,
+      pool: certificate.pool,
+      pool_parameters: poolParameters,
+      deposit: certificate.deposit,
+      drep: dRep
+    },
+    poolOwners,
+    poolRelays
+  };
+};

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

@@ -0,0 +1,25 @@
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { Static } from '@trezor/schema-utils';
+export type Path = number[];
+export declare const Path: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
+export type CollateralInputWithPath = {
+  collateralInput: PROTO.CardanoTxCollateralInput;
+  path?: Path;
+};
+export type InputWithPath = Static<typeof InputWithPath>;
+export declare const InputWithPath: import("@sinclair/typebox").TObject<{
+  input: import("@sinclair/typebox").TObject<{
+    prev_hash: import("@sinclair/typebox").TString;
+    prev_index: import("@sinclair/typebox").TNumber;
+  }>;
+  path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>>;
+}>;
+export type InputWithPathParam = Static<typeof InputWithPath>;
+export declare const InputWithPathParam: import("@sinclair/typebox").TObject<{
+  prev_hash: import("@sinclair/typebox").TString;
+  prev_index: import("@sinclair/typebox").TNumber;
+  path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>>;
+}>;
+export declare const transformInput: (input: unknown) => InputWithPath;
+export declare const transformCollateralInput: (collateralInput: unknown) => CollateralInputWithPath;
+export declare const transformReferenceInput: (referenceInput: unknown) => PROTO.CardanoTxReferenceInput;

package/lib/api/cardano/cardanoInputs.js

@@ -0,0 +1,39 @@
+import { DerivationPath } from "@trezor/connect-common";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert, Type } from "@trezor/schema-utils";
+import { validatePath } from "../../utils/pathUtils.js";
+export const Path = Type.Array(Type.Number());
+export const InputWithPath = Type.Object({
+  input: PROTO.CardanoTxInput,
+  path: Type.Optional(Path)
+});
+export const InputWithPathParam = Type.Composite([PROTO.CardanoTxInput, Type.Object({
+  path: Type.Optional(DerivationPath)
+})]);
+export const transformInput = input => {
+  Assert(InputWithPathParam, input);
+  return {
+    input: {
+      prev_hash: input.prev_hash,
+      prev_index: input.prev_index
+    },
+    path: input.path ? validatePath(input.path, 5) : undefined
+  };
+};
+export const transformCollateralInput = collateralInput => {
+  Assert(InputWithPathParam, collateralInput);
+  return {
+    collateralInput: {
+      prev_hash: collateralInput.prev_hash,
+      prev_index: collateralInput.prev_index
+    },
+    path: collateralInput.path ? validatePath(collateralInput.path, 5) : undefined
+  };
+};
+export const transformReferenceInput = referenceInput => {
+  Assert(PROTO.CardanoTxInput, referenceInput);
+  return {
+    prev_hash: referenceInput.prev_hash,
+    prev_index: referenceInput.prev_index
+  };
+};

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

@@ -0,0 +1,40 @@
+import type { PROTO } from '@trezor/connect-common';
+import type { MessagesSchema as Messages } from '@trezor/protobuf';
+import type { AssetGroupWithTokens } from "./cardanoTokenBundle.js";
+export type OutputWithData = {
+  output: PROTO.CardanoTxOutput;
+  tokenBundle?: AssetGroupWithTokens[];
+  inlineDatum?: string;
+  referenceScript?: string;
+};
+export declare const OutputValidation: import("@sinclair/typebox").TObject<{
+  address: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+  amount: import("@trezor/schema-utils/lib/custom-types/uint").TUint;
+  tokenBundle: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    policyId: import("@sinclair/typebox").TString;
+    tokenAmounts: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+      assetNameBytes: import("@sinclair/typebox").TString;
+      amount: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+      mintAmount: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>>;
+  }>>>;
+  datumHash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+  format: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+  inlineDatum: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+  referenceScript: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+  addressParameters: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+    addressType: import("@sinclair/typebox").TEnum<typeof PROTO.CardanoAddressType>;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>>;
+    stakingPath: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>>;
+    stakingKeyHash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    certificatePointer: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+      blockIndex: import("@sinclair/typebox").TNumber;
+      txIndex: import("@sinclair/typebox").TNumber;
+      certificateIndex: import("@sinclair/typebox").TNumber;
+    }>>;
+    paymentScriptHash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    stakingScriptHash: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+  }>>;
+}>;
+export declare const transformOutput: (output: unknown) => OutputWithData;
+export declare const sendOutput: (typedCall: Messages.TypedCall, outputWithData: OutputWithData) => Promise<void>;

package/lib/api/cardano/cardanoOutputs.js

@@ -0,0 +1,70 @@
+import { CardanoAddressParameters, CardanoAssetGroup } from "@trezor/connect-common";
+import { Assert, Type } from "@trezor/schema-utils";
+import { addressParametersToProto, validateAddressParameters } from "./cardanoAddressParameters.js";
+import { tokenBundleToProto } from "./cardanoTokenBundle.js";
+import { hexStringByteLength, sendChunkedHexString } from "./cardanoUtils.js";
+export const OutputValidation = Type.Object({
+  address: Type.Optional(Type.String()),
+  amount: Type.Uint(),
+  tokenBundle: Type.Optional(Type.Array(CardanoAssetGroup)),
+  datumHash: Type.Optional(Type.String()),
+  format: Type.Optional(Type.Number()),
+  inlineDatum: Type.Optional(Type.String()),
+  referenceScript: Type.Optional(Type.String()),
+  addressParameters: Type.Optional(CardanoAddressParameters)
+});
+export const transformOutput = output => {
+  Assert(OutputValidation, output);
+  const result = {
+    output: {
+      amount: output.amount,
+      asset_groups_count: 0,
+      datum_hash: output.datumHash,
+      format: output.format,
+      inline_datum_size: output.inlineDatum ? hexStringByteLength(output.inlineDatum) : undefined,
+      reference_script_size: output.referenceScript ? hexStringByteLength(output.referenceScript) : undefined
+    },
+    inlineDatum: output.inlineDatum,
+    referenceScript: output.referenceScript
+  };
+  if (output.addressParameters) {
+    validateAddressParameters(output.addressParameters);
+    result.output.address_parameters = addressParametersToProto(output.addressParameters);
+  } else {
+    result.output.address = output.address;
+  }
+  if (output.tokenBundle) {
+    result.tokenBundle = tokenBundleToProto(output.tokenBundle);
+    result.output.asset_groups_count = result.tokenBundle.length;
+  } else {
+    result.output.asset_groups_count = 0;
+  }
+  return result;
+};
+export const sendOutput = async (typedCall, outputWithData) => {
+  const MAX_CHUNK_SIZE = 1024 * 2;
+  const {
+    output,
+    tokenBundle,
+    inlineDatum,
+    referenceScript
+  } = outputWithData;
+  await typedCall('CardanoTxOutput', 'CardanoTxItemAck', output);
+  if (tokenBundle) {
+    for (const assetGroup of tokenBundle) {
+      await typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+        policy_id: assetGroup.policyId,
+        tokens_count: assetGroup.tokens.length
+      });
+      for (const token of assetGroup.tokens) {
+        await typedCall('CardanoToken', 'CardanoTxItemAck', token);
+      }
+    }
+  }
+  if (inlineDatum) {
+    await sendChunkedHexString(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
+  }
+  if (referenceScript) {
+    await sendChunkedHexString(typedCall, referenceScript, MAX_CHUNK_SIZE, 'CardanoTxReferenceScriptChunk');
+  }
+};

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

@@ -0,0 +1,12 @@
+import { CardanoAssetGroup } from '@trezor/connect-common';
+import type { Static } from '@trezor/schema-utils';
+export type AssetGroupWithTokens = Static<typeof AssetGroupWithTokens>;
+export declare const AssetGroupWithTokens: import("@sinclair/typebox").TObject<{
+  policyId: import("@sinclair/typebox").TString;
+  tokens: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    asset_name_bytes: import("@sinclair/typebox").TString;
+    amount: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
+    mint_amount: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
+  }>>;
+}>;
+export declare const tokenBundleToProto: (tokenBundle: CardanoAssetGroup[]) => AssetGroupWithTokens[];

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

@@ -0,0 +1,17 @@
+import type { AccountUtxo, CardanoCertificate } from '@trezor/connect-common';
+import type { types } from '@trezor/network-cardano/types';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+export declare const transformUtxos: (utxos: AccountUtxo[]) => types.Utxo[];
+export declare const prepareCertificates: (certs: CardanoCertificate[]) => types.Certificate[];
+export declare const getTtl: (testnet: boolean) => number;
+export declare const getCoinSelectionParams: (descriptor: string, utxo: AccountUtxo[], outputs: types.UserOutput[], certificates: CardanoCertificate[], withdrawals: types.Withdrawal[], changeAddress: string, isTestnet: boolean) => {
+  utxos: types.Utxo[];
+  outputs: types.UserOutput[];
+  changeAddress: string;
+  certificates: types.Certificate[];
+  withdrawals: types.Withdrawal[];
+  accountPubKey: string;
+  ttl: number;
+};
+export declare const hexStringByteLength: (s: string) => number;
+export declare const sendChunkedHexString: (typedCall: PROTO.TypedCall, data: string, chunkSize: number, messageType: PROTO.WireInMessage, responseType?: PROTO.WireOutMessage) => Promise<void>;

package/lib/api/cardano/cardanoUtils.js

@@ -0,0 +1,100 @@
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+const CARDANO_DEFAULT_TTL_OFFSET = 7200;
+export const transformUtxos = utxos => {
+  const result = [];
+  utxos?.forEach(utxo => {
+    const foundItem = result.find(res => res.txHash === utxo.txid && res.outputIndex === utxo.vout);
+    if (utxo.cardanoSpecific) {
+      if (!foundItem) {
+        result.push({
+          address: utxo.address,
+          txHash: utxo.txid,
+          outputIndex: utxo.vout,
+          amount: [{
+            quantity: utxo.amount,
+            unit: utxo.cardanoSpecific.unit
+          }]
+        });
+      } else {
+        foundItem.amount.push({
+          quantity: utxo.amount,
+          unit: utxo.cardanoSpecific.unit
+        });
+      }
+    }
+  });
+  return result;
+};
+export const prepareCertificates = certs => {
+  const convertedCerts = [];
+  certs.forEach(cert => {
+    switch (cert.type) {
+      case PROTO.CardanoCertificateType.STAKE_DELEGATION:
+        convertedCerts.push({
+          type: cert.type,
+          pool: cert.pool
+        });
+        break;
+      case PROTO.CardanoCertificateType.STAKE_REGISTRATION:
+      case PROTO.CardanoCertificateType.STAKE_DEREGISTRATION:
+        convertedCerts.push({
+          type: cert.type
+        });
+        break;
+      case PROTO.CardanoCertificateType.VOTE_DELEGATION:
+        if (cert.dRep?.type === PROTO.CardanoDRepType.ABSTAIN || cert.dRep?.type === PROTO.CardanoDRepType.NO_CONFIDENCE) {
+          convertedCerts.push({
+            type: cert.type,
+            dRep: {
+              type: cert.dRep.type
+            }
+          });
+        } else if (cert.dRep?.type === PROTO.CardanoDRepType.KEY_HASH) {
+          convertedCerts.push({
+            type: cert.type,
+            dRep: {
+              type: cert.dRep.type,
+              keyHash: cert.dRep.keyHash
+            }
+          });
+        } else if (cert.dRep?.type === PROTO.CardanoDRepType.SCRIPT_HASH) {
+          convertedCerts.push({
+            type: cert.type,
+            dRep: {
+              type: cert.dRep.type,
+              scriptHash: cert.dRep.scriptHash
+            }
+          });
+        }
+        break;
+    }
+  });
+  return convertedCerts;
+};
+export const getTtl = testnet => {
+  const shelleySlot = testnet ? 6192449 : 4924800;
+  const shelleyTimestamp = testnet ? 1672848449 : 1596491091;
+  const currentTimestamp = Math.floor(new Date().getTime() / 1000);
+  const currentSlot = shelleySlot + currentTimestamp - shelleyTimestamp;
+  return currentSlot + CARDANO_DEFAULT_TTL_OFFSET;
+};
+export const getCoinSelectionParams = (descriptor, utxo, outputs, certificates, withdrawals, changeAddress, isTestnet) => ({
+  utxos: transformUtxos(utxo),
+  outputs,
+  changeAddress,
+  certificates: prepareCertificates(certificates),
+  withdrawals,
+  accountPubKey: descriptor,
+  ttl: getTtl(isTestnet)
+});
+export const hexStringByteLength = s => s.length / 2;
+export const sendChunkedHexString = async (typedCall, data, chunkSize, messageType, responseType = 'CardanoTxItemAck') => {
+  let processedSize = 0;
+  while (processedSize < data.length) {
+    const chunk = data.slice(processedSize, processedSize + chunkSize);
+    await typedCall(messageType, responseType, {
+      data: chunk
+    });
+    processedSize += chunkSize;
+  }
+};

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

@@ -0,0 +1,4 @@
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { CertificateWithPoolOwnersAndRelays } from "./cardanoCertificate.js";
+import type { CollateralInputWithPath, InputWithPath, Path } from "./cardanoInputs.js";
+export declare const gatherWitnessPaths: (inputsWithPath: InputWithPath[], certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[], withdrawals: PROTO.CardanoTxWithdrawal[], collateralInputsWithPath: CollateralInputWithPath[], requiredSigners: PROTO.CardanoTxRequiredSigner[], additionalWitnessRequests: Path[], signingMode: PROTO.CardanoTxSigningMode) => Path[];

package/lib/api/changeLanguage.d.ts

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

package/lib/api/changeLanguage.js

@@ -0,0 +1,49 @@
+import { ChangeLanguage as ChangeLanguageSchema, UI_REQUEST } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { changeLanguage } from "../device/workflow/changeLanguage.js";
+export default class ChangeLanguage extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(ChangeLanguageSchema, payload);
+    super(message, payload);
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
+    this.useEmptyPassphrase = true;
+    this.skipFinalReload = false;
+    this.useDeviceState = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
+  }
+  get confirmation() {
+    return {
+      view: 'device-management',
+      customConfirmButton: {
+        className: 'confirm',
+        label: 'Proceed'
+      },
+      label: 'Do you want to change language?'
+    };
+  }
+  run() {
+    const {
+      language,
+      binary
+    } = this.params;
+    if (binary) {
+      return changeLanguage({
+        device: this.getDevice(),
+        binary
+      });
+    } else {
+      return changeLanguage({
+        device: this.getDevice(),
+        language
+      });
+    }
+  }
+}

package/lib/api/changePin.d.ts

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

package/lib/api/changePin.js

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

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

package/lib/api/changeWipeCode.js

@@ -0,0 +1,29 @@
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validateParams } from "./common/paramsValidator.js";
+export default class ChangeWipeCode extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    validateParams(payload, [{
+      name: 'remove',
+      type: 'boolean'
+    }]);
+    const params = {
+      remove: payload.remove
+    };
+    super(message, params);
+    this.skipFinalReload = false;
+    this.useDeviceState = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('ChangeWipeCode', 'Success', this.params);
+    return response.message;
+  }
+}

package/lib/api/cipherKeyValue.d.ts

@@ -0,0 +1,17 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class CipherKeyValue extends AbstractMethod<'cipherKeyValue', PROTO.CipherKeyValue[]> {
+  hasBundle?: boolean;
+  constructor(message: MethodMessage<'cipherKeyValue'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    value: string;
+  } | {
+    value: string;
+  }[]>;
+}