@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/blockchainUnsubscribe.js

@@ -1,21 +1,13 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const coinInfo_1 = require("../data/coinInfo");
-class BlockchainUnsubscribe extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.useDevice = false;
-    this.useUi = false;
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validateParams } from "./common/paramsValidator.js";
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+export default class BlockchainUnsubscribe extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
+    } = message;
+    validateParams(payload, [{
       name: 'accounts',
       type: 'array',
       allowEmpty: true
@@ -32,27 +24,34 @@ class BlockchainUnsubscribe extends AbstractMethod_1.AbstractMethod {
     }]);
     if (payload.accounts) {
       payload.accounts.forEach(account => {
-        (0, paramsValidator_1.validateParams)(account, [{
+        validateParams(account, [{
           name: 'descriptor',
           type: 'string',
           required: true
         }]);
       });
     }
-    const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
-    if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-    }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-    this.params = {
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(coinInfo);
+    const params = {
       accounts: payload.accounts,
       coinInfo,
       identity: payload.identity,
       blocks: payload.blocks ?? false
     };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'internal'
+    }];
   }
-  async run() {
-    const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
     const {
       accounts
     } = this.params;
@@ -64,6 +63,4 @@ class BlockchainUnsubscribe extends AbstractMethod_1.AbstractMethod {
     }
     return backend.unsubscribeAll();
   }
-}
-exports.default = BlockchainUnsubscribe;
-//# sourceMappingURL=blockchainUnsubscribe.js.map
+}

package/lib/api/blockchainUnsubscribeFiatRates.d.ts

@@ -1,14 +1,17 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import type { CoinInfo } from '../types';
+import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
+  coinInfo: CoinInfo;
+  identity?: string;
 };
 export default class BlockchainUnsubscribeFiatRates extends AbstractMethod<'blockchainUnsubscribeFiatRates', Params> {
-    init(): void;
-    run(): Promise<{
-        subscribed: boolean;
-    }>;
+  constructor(message: MethodMessage<'blockchainUnsubscribeFiatRates'>);
+  get requiredPermissions(): PermissionRequest[];
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    subscribed: boolean;
+  }>;
 }
-export {};
-//# sourceMappingURL=blockchainUnsubscribeFiatRates.d.ts.map
+export {};

package/lib/api/blockchainUnsubscribeFiatRates.js

@@ -1,21 +1,13 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const coinInfo_1 = require("../data/coinInfo");
-class BlockchainUnsubscribeFiatRates extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.useDevice = false;
-    this.useUi = false;
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validateParams } from "./common/paramsValidator.js";
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+export default class BlockchainUnsubscribeFiatRates extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
+    } = message;
+    validateParams(payload, [{
       name: 'coin',
       type: 'string',
       required: true
@@ -23,20 +15,23 @@ class BlockchainUnsubscribeFiatRates extends AbstractMethod_1.AbstractMethod {
       name: 'identity',
       type: 'string'
     }]);
-    const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
-    if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-    }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-    this.params = {
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(coinInfo);
+    const params = {
       coinInfo,
       identity: payload.identity
     };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
   }
-  async run() {
-    const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
     return backend.unsubscribeFiatRates();
   }
-}
-exports.default = BlockchainUnsubscribeFiatRates;
-//# sourceMappingURL=blockchainUnsubscribeFiatRates.js.map
+}

package/lib/api/blockchainValidateEvmRpcUrl.d.ts

@@ -0,0 +1,17 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+type Params = {
+  url: string;
+  chainId: number;
+};
+export default class BlockchainValidateEvmRpcUrl extends AbstractMethod<'blockchainValidateEvmRpcUrl', Params> {
+  constructor(message: MethodMessage<'blockchainValidateEvmRpcUrl'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    valid: boolean;
+    actualChainId?: number;
+  }>;
+}
+export {};

package/lib/api/blockchainValidateEvmRpcUrl.js

@@ -0,0 +1,54 @@
+import { BlockchainLink } from "@trezor/blockchain-link";
+import { MESSAGES } from "@trezor/blockchain-link-types";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { EvmRpcWorker } from "../workers/workers.js";
+import { validateParams } from "./common/paramsValidator.js";
+export default class BlockchainValidateEvmRpcUrl extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    validateParams(payload, [{
+      name: 'url',
+      type: 'string',
+      required: true
+    }, {
+      name: 'chainId',
+      type: 'number',
+      required: true
+    }]);
+    const params = {
+      url: payload.url,
+      chainId: payload.chainId
+    };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  get info() {
+    return 'Validate EVM RPC URL';
+  }
+  async run() {
+    const link = new BlockchainLink({
+      name: 'evm-rpc-validator',
+      worker: EvmRpcWorker,
+      server: [],
+      debug: false
+    });
+    try {
+      const response = await link.sendMessage({
+        type: MESSAGES.VALIDATE_EVM_RPC,
+        payload: {
+          url: this.params.url,
+          chainId: this.params.chainId
+        }
+      });
+      return response;
+    } finally {
+      link.dispose();
+    }
+  }
+}

package/lib/api/cancelCoinjoinAuthorization.d.ts

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

package/lib/api/cancelCoinjoinAuthorization.js

@@ -1,26 +1,25 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const cancelCoinjoinAuthorization_1 = require("../types/api/cancelCoinjoinAuthorization");
-class CancelCoinjoinAuthorization extends AbstractMethod_1.AbstractMethod {
-  init() {
+import { CancelCoinjoinAuthorization as CancelCoinjoinAuthorizationSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class CancelCoinjoinAuthorization extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(cancelCoinjoinAuthorization_1.CancelCoinjoinAuthorization, payload);
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+    } = message;
+    Assert(CancelCoinjoinAuthorizationSchema, payload);
+    super(message, undefined);
     this.preauthorized = typeof payload.preauthorized === 'boolean' ? payload.preauthorized : true;
   }
+  get requiredPermissions() {
+    return [{
+      permission: 'internal'
+    }];
+  }
   get info() {
     return 'Cancel Coinjoin Authorization';
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     if (!this.preauthorized) {
       if (!(await cmd.preauthorize(false))) {
         return {
@@ -31,6 +30,4 @@ class CancelCoinjoinAuthorization extends AbstractMethod_1.AbstractMethod {
     const response = await cmd.typedCall('CancelAuthorization', 'Success');
     return response.message;
   }
-}
-exports.default = CancelCoinjoinAuthorization;
-//# sourceMappingURL=cancelCoinjoinAuthorization.js.map
+}

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

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

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

@@ -1,28 +1,23 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const coin_selection_1 = require("@fivebinaries/coin-selection");
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const cardanoComposeTransaction_1 = require("../../../types/api/cardanoComposeTransaction");
-const cardanoUtils_1 = require("../cardanoUtils");
-class CardanoComposeTransaction extends AbstractMethod_1.AbstractMethod {
-  init() {
-    const {
-      payload
-    } = this;
-    (0, schema_utils_1.AssertWeak)(cardanoComposeTransaction_1.CardanoComposeTransactionParamsSchema, payload);
+import { CardanoComposeTransactionParamsSchema } from "@trezor/connect-common/lib/types/api/cardano/cardanoComposeTransaction.js";
+import cardano from "@trezor/network-cardano/runtime";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getCoinSelectionParams } from "../cardanoUtils.js";
+export default class CardanoComposeTransaction extends AbstractMethod {
+  constructor(message) {
+    Assert(CardanoComposeTransactionParamsSchema, message.payload);
+    super(message, message.payload);
     this.useDevice = false;
     this.useDeviceState = false;
     this.useUi = false;
-    this.params = payload;
+  }
+  get requiredPermissions() {
+    return [];
   }
   get info() {
     return 'Compose Cardano transaction';
   }
-  run() {
+  async run() {
     const {
       feeLevels = [{}],
       account,
@@ -33,11 +28,16 @@ class CardanoComposeTransaction extends AbstractMethod_1.AbstractMethod {
       addressParameters,
       testnet
     } = this.params;
+    const {
+      trezorUtils,
+      asCoinSelectionError,
+      coinSelection
+    } = await cardano();
     const result = feeLevels.map(({
       feePerUnit
     }) => {
       try {
-        const txPlan = (0, cardanoUtils_1.composeTxPlan)(account.descriptor, account.utxo, outputs, certificates, withdrawals, changeAddress.address, !!testnet, {
+        const txPlan = coinSelection(getCoinSelectionParams(account.descriptor, account.utxo, outputs, certificates, withdrawals, changeAddress.address, !!testnet), {
           feeParams: feePerUnit ? {
             a: feePerUnit
           } : undefined
@@ -55,19 +55,19 @@ class CardanoComposeTransaction extends AbstractMethod_1.AbstractMethod {
             type: txPlan.type,
             bytes: txPlan.tx.size,
             ttl: txPlan.ttl,
-            inputs: coin_selection_1.trezorUtils.transformToTrezorInputs(txPlan.inputs, account.utxo),
-            outputs: coin_selection_1.trezorUtils.transformToTrezorOutputs(txPlan.outputs, addressParameters),
+            inputs: trezorUtils.transformToTrezorInputs(txPlan.inputs, account.utxo),
+            outputs: trezorUtils.transformToTrezorOutputs(txPlan.outputs, addressParameters),
             unsignedTx: txPlan.tx
           })
         };
       } catch (error) {
-        if (error instanceof coin_selection_1.CoinSelectionError && error.code === 'UTXO_BALANCE_INSUFFICIENT') {
+        if (asCoinSelectionError(error)?.code === 'UTXO_BALANCE_INSUFFICIENT') {
           return {
             type: 'error',
             error: 'UTXO_BALANCE_INSUFFICIENT'
           };
         }
-        if (error instanceof coin_selection_1.CoinSelectionError && error.code === 'UTXO_VALUE_TOO_SMALL') {
+        if (asCoinSelectionError(error)?.code === 'UTXO_VALUE_TOO_SMALL') {
           return {
             type: 'error',
             error: 'UTXO_VALUE_TOO_SMALL'
@@ -79,8 +79,6 @@ class CardanoComposeTransaction extends AbstractMethod_1.AbstractMethod {
         };
       }
     });
-    return Promise.resolve(result);
+    return result;
   }
-}
-exports.default = CardanoComposeTransaction;
-//# sourceMappingURL=cardanoComposeTransaction.js.map
+}

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

@@ -1,27 +1,34 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-type Params = PROTO.CardanoGetAddress & {
-    address?: string;
+import { type PermissionRequest } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  proto: PROTO.CardanoGetAddress;
+  address?: string;
 };
 export default class CardanoGetAddress extends AbstractMethod<'cardanoGetAddress', Params[]> {
-    hasBundle?: boolean;
-    progress: number;
-    init(): void;
-    get info(): string;
-    getButtonRequestData(code: string): {
-        type: "address";
-        serializedPath: string;
-        address: string;
-    } | undefined;
-    get confirmation(): {
-        view: "export-address";
-        label: string;
-    } | undefined;
-    _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, chunkify, }: Params): Promise<{
-        mac?: string | undefined;
-        address: string;
-    }>;
-    run(): Promise<import("../../../types").CardanoAddress | import("../../../types").CardanoAddress[]>;
+  hasBundle?: boolean;
+  progress: number;
+  constructor(message: MethodMessage<'cardanoGetAddress'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  getButtonRequestData(code: string): {
+    type: "address";
+    serializedPath: string;
+    address: string;
+  } | undefined;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  } | undefined;
+  _call({
+    proto
+  }: Params): Promise<{
+    mac?: string | undefined;
+    address: string;
+  }>;
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<import("@trezor/connect-common").CardanoAddress | import("@trezor/connect-common").CardanoAddress[]>;
 }
-export {};
-//# sourceMappingURL=cardanoGetAddress.d.ts.map
+export {};