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

package/lib/api/cardano/cardanoInputs.js

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

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

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

@@ -1,12 +0,0 @@
-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/cardanoTokenBundle.js

@@ -1,21 +0,0 @@
-import { CardanoAssetGroup } from "@trezor/connect-common";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert, Type } from "@trezor/schema-utils";
-export const AssetGroupWithTokens = Type.Object({
-  policyId: Type.String(),
-  tokens: Type.Array(PROTO.CardanoToken, {
-    minItems: 1
-  })
-});
-const tokenAmountsToProto = tokenAmounts => tokenAmounts.map(tokenAmount => ({
-  asset_name_bytes: tokenAmount.assetNameBytes,
-  amount: tokenAmount.amount,
-  mint_amount: tokenAmount.mintAmount
-}));
-export const tokenBundleToProto = tokenBundle => {
-  Assert(Type.Array(CardanoAssetGroup), tokenBundle);
-  return tokenBundle.map(tokenGroup => ({
-    policyId: tokenGroup.policyId,
-    tokens: tokenAmountsToProto(tokenGroup.tokenAmounts)
-  }));
-};

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

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

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

@@ -1,4 +0,0 @@
-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/cardano/cardanoWitnesses.js

@@ -1,47 +0,0 @@
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-export const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, signingMode) => {
-  const witnessPaths = new Map();
-  function _insert(path) {
-    const pathKey = JSON.stringify(path);
-    witnessPaths.set(pathKey, path);
-  }
-  if (signingMode !== PROTO.CardanoTxSigningMode.MULTISIG_TRANSACTION) {
-    inputsWithPath.forEach(({
-      path
-    }) => {
-      if (path) _insert(path);
-    });
-    certificatesWithPoolOwnersAndRelays.forEach(({
-      certificate,
-      poolOwners
-    }) => {
-      if (certificate.path && (certificate.type === PROTO.CardanoCertificateType.STAKE_DELEGATION || certificate.type === PROTO.CardanoCertificateType.STAKE_DEREGISTRATION || certificate.type === PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY || certificate.type === PROTO.CardanoCertificateType.VOTE_DELEGATION)) {
-        _insert(certificate.path);
-      }
-      poolOwners.forEach(poolOwner => {
-        if (poolOwner.staking_key_path) _insert(poolOwner.staking_key_path);
-      });
-    });
-    withdrawals.forEach(({
-      path
-    }) => {
-      if (path) _insert(path);
-    });
-  }
-  if (signingMode === PROTO.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
-    collateralInputsWithPath.forEach(({
-      path
-    }) => {
-      if (path) _insert(path);
-    });
-  }
-  requiredSigners.forEach(({
-    key_path
-  }) => {
-    if (key_path) _insert(key_path);
-  });
-  additionalWitnessRequests.forEach(path => {
-    _insert(path);
-  });
-  return Array.from(witnessPaths.values());
-};

package/lib/api/changeLanguage.d.ts

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

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

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

package/lib/api/changePin.js

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

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

package/lib/api/changeWipeCode.js

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

@@ -1,17 +0,0 @@
-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;
-  }[]>;
-}

package/lib/api/cipherKeyValue.js

@@ -1,58 +0,0 @@
-import { CipherKeyValue as CipherKeyValueSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
-import { Bundle } from "@trezor/connect-common/lib/types/params.js";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { bundlify } from "./common/paramsValidator.js";
-import { validatePath } from "../utils/pathUtils.js";
-export default class CipherKeyValue extends AbstractMethod {
-  hasBundle;
-  constructor(message) {
-    const {
-      hasBundle,
-      payload
-    } = bundlify(message.payload);
-    Assert(Bundle(CipherKeyValueSchema), payload);
-    const params = payload.bundle.map(batch => ({
-      address_n: validatePath(batch.path),
-      key: batch.key,
-      value: batch.value instanceof Buffer ? batch.value.toString('hex') : batch.value,
-      encrypt: batch.encrypt,
-      ask_on_encrypt: batch.askOnEncrypt,
-      ask_on_decrypt: batch.askOnDecrypt,
-      iv: batch.iv instanceof Buffer ? batch.iv.toString('hex') : batch.iv
-    }));
-    super(message, params);
-    this.hasBundle = hasBundle;
-  }
-  get requiredPermissions() {
-    return [{
-      permission: 'sign'
-    }];
-  }
-  get info() {
-    return 'Cipher key value';
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const responses = [];
-    const cmd = this.getDevice().getCommands();
-    for (let i = 0; i < this.params.length; i++) {
-      const {
-        params
-      } = this;
-      const batch = params[i];
-      const response = await cmd.typedCall('CipherKeyValue', 'CipheredKeyValue', batch);
-      responses.push(response.message);
-      if (this.hasBundle) {
-        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
-          total: this.params.length,
-          progress: i,
-          response
-        }));
-      }
-    }
-    const first = responses[0];
-    return this.hasBundle ? responses : first;
-  }
-}

package/lib/api/common/AbstractMiscGetAddress.d.ts

@@ -1,37 +0,0 @@
-import { type PermissionRequest } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, MethodReturnType } from "../../core/AbstractMethod.js";
-import { AbstractMethod } from "../../core/AbstractMethod.js";
-export type MiscGetAddressMethodName = 'rippleGetAddress' | 'stellarGetAddress' | 'tezosGetAddress' | 'solanaGetAddress' | 'tronGetAddress';
-type MiscProto = {
-  address_n: number[];
-  show_display: boolean;
-  chunkify: boolean;
-};
-export type MiscGetAddressParams = {
-  proto: MiscProto;
-  address?: string;
-};
-export declare abstract class AbstractMiscGetAddress<Name extends MiscGetAddressMethodName> extends AbstractMethod<Name, MiscGetAddressParams[]> {
-  hasBundle?: boolean;
-  progress: number;
-  constructor(message: MethodMessage<Name>, pathDepth: number);
-  get requiredPermissions(): PermissionRequest[];
-  protected getInfo(coinName: string, showAccountInInfo: boolean): string;
-  getButtonRequestData(code: string): {
-    type: "address";
-    serializedPath: string;
-    address: string;
-  } | undefined;
-  protected getConfirmation(coinName: string): {
-    view: "export-address";
-    label: string;
-  };
-  protected abstract _call(params: MiscGetAddressParams): Promise<{
-    address: string;
-    mac?: string;
-  }>;
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<MethodReturnType<Name>>;
-}
-export {};