@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/cardano/cardanoOutputs.js

@@ -1,54 +1,47 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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)
 });
-exports.sendOutput = exports.transformOutput = exports.OutputValidation = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
-const cardanoTokenBundle_1 = require("./cardanoTokenBundle");
-const cardanoUtils_1 = require("./cardanoUtils");
-const cardano_1 = require("../../types/api/cardano");
-exports.OutputValidation = schema_utils_1.Type.Object({
-  address: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  amount: schema_utils_1.Type.Uint(),
-  tokenBundle: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(cardano_1.CardanoAssetGroup)),
-  datumHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  format: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
-  inlineDatum: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  referenceScript: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  addressParameters: schema_utils_1.Type.Optional(cardano_1.CardanoAddressParameters)
-});
-const transformOutput = output => {
-  (0, schema_utils_1.Assert)(exports.OutputValidation, output);
+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 ? (0, cardanoUtils_1.hexStringByteLength)(output.inlineDatum) : undefined,
-      reference_script_size: output.referenceScript ? (0, cardanoUtils_1.hexStringByteLength)(output.referenceScript) : undefined
+      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) {
-    (0, cardanoAddressParameters_1.validateAddressParameters)(output.addressParameters);
-    result.output.address_parameters = (0, cardanoAddressParameters_1.addressParametersToProto)(output.addressParameters);
+    validateAddressParameters(output.addressParameters);
+    result.output.address_parameters = addressParametersToProto(output.addressParameters);
   } else {
     result.output.address = output.address;
   }
   if (output.tokenBundle) {
-    result.tokenBundle = (0, cardanoTokenBundle_1.tokenBundleToProto)(output.tokenBundle);
+    result.tokenBundle = tokenBundleToProto(output.tokenBundle);
     result.output.asset_groups_count = result.tokenBundle.length;
   } else {
     result.output.asset_groups_count = 0;
   }
   return result;
 };
-exports.transformOutput = transformOutput;
-const sendOutput = async (typedCall, outputWithData) => {
+export const sendOutput = async (typedCall, outputWithData) => {
   const MAX_CHUNK_SIZE = 1024 * 2;
   const {
     output,
@@ -69,11 +62,9 @@ const sendOutput = async (typedCall, outputWithData) => {
     }
   }
   if (inlineDatum) {
-    await (0, cardanoUtils_1.sendChunkedHexString)(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
+    await sendChunkedHexString(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
   }
   if (referenceScript) {
-    await (0, cardanoUtils_1.sendChunkedHexString)(typedCall, referenceScript, MAX_CHUNK_SIZE, 'CardanoTxReferenceScriptChunk');
+    await sendChunkedHexString(typedCall, referenceScript, MAX_CHUNK_SIZE, 'CardanoTxReferenceScriptChunk');
   }
-};
-exports.sendOutput = sendOutput;
-//# sourceMappingURL=cardanoOutputs.js.map
+};

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

@@ -1,13 +1,12 @@
-import { Static } from '@trezor/schema-utils';
-import { CardanoAssetGroup } from '../../types/api/cardano';
+import { CardanoAssetGroup } from '@trezor/connect-common';
+import type { Static } from '@trezor/schema-utils';
 export type AssetGroupWithTokens = Static<typeof AssetGroupWithTokens>;
-export declare const AssetGroupWithTokens: import("@trezor/schema-utils").TObject<{
-    policyId: import("@trezor/schema-utils").TString;
-    tokens: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-        asset_name_bytes: import("@trezor/schema-utils").TString;
-        amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
-        mint_amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
-    }>>;
+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[];
-//# sourceMappingURL=cardanoTokenBundle.d.ts.map
+export declare const tokenBundleToProto: (tokenBundle: CardanoAssetGroup[]) => AssetGroupWithTokens[];

package/lib/api/cardano/cardanoTokenBundle.js

@@ -1,15 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.tokenBundleToProto = exports.AssetGroupWithTokens = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../../constants");
-const cardano_1 = require("../../types/api/cardano");
-exports.AssetGroupWithTokens = schema_utils_1.Type.Object({
-  policyId: schema_utils_1.Type.String(),
-  tokens: schema_utils_1.Type.Array(constants_1.PROTO.CardanoToken, {
+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
   })
 });
@@ -18,12 +12,10 @@ const tokenAmountsToProto = tokenAmounts => tokenAmounts.map(tokenAmount => ({
   amount: tokenAmount.amount,
   mint_amount: tokenAmount.mintAmount
 }));
-const tokenBundleToProto = tokenBundle => {
-  (0, schema_utils_1.Assert)(schema_utils_1.Type.Array(cardano_1.CardanoAssetGroup), tokenBundle);
+export const tokenBundleToProto = tokenBundle => {
+  Assert(Type.Array(CardanoAssetGroup), tokenBundle);
   return tokenBundle.map(tokenGroup => ({
     policyId: tokenGroup.policyId,
     tokens: tokenAmountsToProto(tokenGroup.tokenAmounts)
   }));
-};
-exports.tokenBundleToProto = tokenBundleToProto;
-//# sourceMappingURL=cardanoTokenBundle.js.map
+};

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

@@ -1,9 +1,17 @@
-import { types } from '@fivebinaries/coin-selection';
-import { AccountUtxo, CardanoCertificate } from '../../types';
+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 composeTxPlan: (descriptor: string, utxo: AccountUtxo[], outputs: types.UserOutput[], certificates: CardanoCertificate[], withdrawals: types.Withdrawal[], changeAddress: string, isTestnet: boolean, options?: types.Options) => types.PrecomposedTransaction;
+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: any, data: string, chunkSize: number, messageType: string, responseType?: string) => Promise<void>;
-//# sourceMappingURL=cardanoUtils.d.ts.map
+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,13 +1,6 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sendChunkedHexString = exports.hexStringByteLength = exports.composeTxPlan = exports.getTtl = exports.prepareCertificates = exports.transformUtxos = void 0;
-const coin_selection_1 = require("@fivebinaries/coin-selection");
-const constants_1 = require("../../constants");
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
 const CARDANO_DEFAULT_TTL_OFFSET = 7200;
-const transformUtxos = utxos => {
+export const transformUtxos = utxos => {
   const result = [];
   utxos?.forEach(utxo => {
     const foundItem = result.find(res => res.txHash === utxo.txid && res.outputIndex === utxo.vout);
@@ -32,32 +25,31 @@ const transformUtxos = utxos => {
   });
   return result;
 };
-exports.transformUtxos = transformUtxos;
-const prepareCertificates = certs => {
+export const prepareCertificates = certs => {
   const convertedCerts = [];
   certs.forEach(cert => {
     switch (cert.type) {
-      case constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION:
+      case PROTO.CardanoCertificateType.STAKE_DELEGATION:
         convertedCerts.push({
           type: cert.type,
           pool: cert.pool
         });
         break;
-      case constants_1.PROTO.CardanoCertificateType.STAKE_REGISTRATION:
-      case constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION:
+      case PROTO.CardanoCertificateType.STAKE_REGISTRATION:
+      case PROTO.CardanoCertificateType.STAKE_DEREGISTRATION:
         convertedCerts.push({
           type: cert.type
         });
         break;
-      case constants_1.PROTO.CardanoCertificateType.VOTE_DELEGATION:
-        if (cert.dRep?.type === constants_1.PROTO.CardanoDRepType.ABSTAIN || cert.dRep?.type === constants_1.PROTO.CardanoDRepType.NO_CONFIDENCE) {
+      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 === constants_1.PROTO.CardanoDRepType.KEY_HASH) {
+        } else if (cert.dRep?.type === PROTO.CardanoDRepType.KEY_HASH) {
           convertedCerts.push({
             type: cert.type,
             dRep: {
@@ -65,7 +57,7 @@ const prepareCertificates = certs => {
               keyHash: cert.dRep.keyHash
             }
           });
-        } else if (cert.dRep?.type === constants_1.PROTO.CardanoDRepType.SCRIPT_HASH) {
+        } else if (cert.dRep?.type === PROTO.CardanoDRepType.SCRIPT_HASH) {
           convertedCerts.push({
             type: cert.type,
             dRep: {
@@ -79,28 +71,24 @@ const prepareCertificates = certs => {
   });
   return convertedCerts;
 };
-exports.prepareCertificates = prepareCertificates;
-const getTtl = testnet => {
+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;
 };
-exports.getTtl = getTtl;
-const composeTxPlan = (descriptor, utxo, outputs, certificates, withdrawals, changeAddress, isTestnet, options) => (0, coin_selection_1.coinSelection)({
-  utxos: (0, exports.transformUtxos)(utxo),
+export const getCoinSelectionParams = (descriptor, utxo, outputs, certificates, withdrawals, changeAddress, isTestnet) => ({
+  utxos: transformUtxos(utxo),
   outputs,
   changeAddress,
-  certificates: (0, exports.prepareCertificates)(certificates),
+  certificates: prepareCertificates(certificates),
   withdrawals,
   accountPubKey: descriptor,
-  ttl: (0, exports.getTtl)(isTestnet)
-}, options);
-exports.composeTxPlan = composeTxPlan;
-const hexStringByteLength = s => s.length / 2;
-exports.hexStringByteLength = hexStringByteLength;
-const sendChunkedHexString = async (typedCall, data, chunkSize, messageType, responseType = 'CardanoTxItemAck') => {
+  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);
@@ -109,6 +97,4 @@ const sendChunkedHexString = async (typedCall, data, chunkSize, messageType, res
     });
     processedSize += chunkSize;
   }
-};
-exports.sendChunkedHexString = sendChunkedHexString;
-//# sourceMappingURL=cardanoUtils.js.map
+};

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

@@ -1,5 +1,4 @@
-import type { CertificateWithPoolOwnersAndRelays } from './cardanoCertificate';
-import type { CollateralInputWithPath, InputWithPath, Path } from './cardanoInputs';
-import { PROTO } from '../../constants';
-export declare const gatherWitnessPaths: (inputsWithPath: InputWithPath[], certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[], withdrawals: PROTO.CardanoTxWithdrawal[], collateralInputsWithPath: CollateralInputWithPath[], requiredSigners: PROTO.CardanoTxRequiredSigner[], additionalWitnessRequests: Path[], signingMode: PROTO.CardanoTxSigningMode) => Path[];
-//# sourceMappingURL=cardanoWitnesses.d.ts.map
+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,17 +1,11 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.gatherWitnessPaths = void 0;
-const constants_1 = require("../../constants");
-const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, signingMode) => {
+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 !== constants_1.PROTO.CardanoTxSigningMode.MULTISIG_TRANSACTION) {
+  if (signingMode !== PROTO.CardanoTxSigningMode.MULTISIG_TRANSACTION) {
     inputsWithPath.forEach(({
       path
     }) => {
@@ -21,7 +15,7 @@ const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays,
       certificate,
       poolOwners
     }) => {
-      if (certificate.path && (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION || certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION || certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY || certificate.type === constants_1.PROTO.CardanoCertificateType.VOTE_DELEGATION)) {
+      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 => {
@@ -34,7 +28,7 @@ const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays,
       if (path) _insert(path);
     });
   }
-  if (signingMode === constants_1.PROTO.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
+  if (signingMode === PROTO.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
     collateralInputsWithPath.forEach(({
       path
     }) => {
@@ -50,6 +44,4 @@ const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays,
     _insert(path);
   });
   return Array.from(witnessPaths.values());
-};
-exports.gatherWitnessPaths = gatherWitnessPaths;
-//# sourceMappingURL=cardanoWitnesses.js.map
+};

package/lib/api/changeLanguage.d.ts

@@ -1,17 +1,18 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import { ChangeLanguage as ChangeLanguageSchema } from '../types/api/changeLanguage';
+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> {
-    init(): void;
-    get confirmation(): {
-        view: "device-management";
-        customConfirmButton: {
-            className: string;
-            label: string;
-        };
-        label: string;
+  constructor(message: MethodMessage<'changeLanguage'>);
+  get requiredPermissions(): PermissionRequest[];
+  get confirmation(): {
+    view: "device-management";
+    customConfirmButton: {
+      className: string;
+      label: string;
     };
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=changeLanguage.d.ts.map
+    label: string;
+  };
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/changeLanguage.js

@@ -1,24 +1,23 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const events_1 = require("../events");
-const changeLanguage_1 = require("../types/api/changeLanguage");
-class ChangeLanguage extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
+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.requiredPermissions = ['management'];
     this.skipFinalReload = false;
     this.useDeviceState = false;
-    const {
-      payload
-    } = this;
-    (0, schema_utils_1.Assert)(changeLanguage_1.ChangeLanguage, payload);
-    this.params = payload;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
   get confirmation() {
     return {
@@ -36,15 +35,15 @@ class ChangeLanguage extends AbstractMethod_1.AbstractMethod {
       binary
     } = this.params;
     if (binary) {
-      return this.device.changeLanguage({
+      return changeLanguage({
+        device: this.getDevice(),
         binary
       });
     } else {
-      return this.device.changeLanguage({
+      return changeLanguage({
+        device: this.getDevice(),
         language
       });
     }
   }
-}
-exports.default = ChangeLanguage;
-//# sourceMappingURL=changeLanguage.js.map
+}

package/lib/api/changePin.d.ts

@@ -1,9 +1,11 @@
+import { type PermissionRequest } from '@trezor/connect-common';
 import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../core/AbstractMethod';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 export default class ChangePin extends AbstractMethod<'changePin', PROTO.ChangePin> {
-    init(): void;
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=changePin.d.ts.map
+  constructor(message: MethodMessage<'changePin'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/changePin.js

@@ -1,29 +1,27 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const protobuf_1 = require("@trezor/protobuf");
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-class ChangePin extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['management'];
-    this.useDeviceState = false;
-    this.skipFinalReload = false;
+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
-    } = this;
-    (0, schema_utils_1.Assert)(protobuf_1.MessagesSchema.ChangePin, payload);
-    this.params = {
+    } = 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.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     const response = await cmd.typedCall('ChangePin', 'Success', this.params);
     return response.message;
   }
-}
-exports.default = ChangePin;
-//# sourceMappingURL=changePin.js.map
+}

package/lib/api/changeWipeCode.d.ts

@@ -1,9 +1,11 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../core/AbstractMethod';
+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> {
-    init(): void;
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=changeWipeCode.d.ts.map
+  constructor(message: MethodMessage<'changeWipeCode'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/changeWipeCode.js

@@ -1,31 +1,29 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-class ChangeWipeCode extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['management'];
-    this.skipFinalReload = false;
-    this.useDeviceState = false;
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validateParams } from "./common/paramsValidator.js";
+export default class ChangeWipeCode extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
+    } = message;
+    validateParams(payload, [{
       name: 'remove',
       type: 'boolean'
     }]);
-    this.params = {
+    const params = {
       remove: payload.remove
     };
+    super(message, params);
+    this.skipFinalReload = false;
+    this.useDeviceState = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     const response = await cmd.typedCall('ChangeWipeCode', 'Success', this.params);
     return response.message;
   }
-}
-exports.default = ChangeWipeCode;
-//# sourceMappingURL=changeWipeCode.js.map
+}

package/lib/api/cipherKeyValue.d.ts

@@ -1,13 +1,17 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../core/AbstractMethod';
+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;
-    init(): void;
-    get info(): string;
-    run(): Promise<{
-        value: string;
-    } | {
-        value: string;
-    }[]>;
-}
-//# sourceMappingURL=cipherKeyValue.d.ts.map
+  hasBundle?: boolean;
+  constructor(message: MethodMessage<'cipherKeyValue'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    value: string;
+  } | {
+    value: string;
+  }[]>;
+}