@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/blockchainSubscribe.mjs

@@ -0,0 +1,68 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { validateParams } from "./common/paramsValidator.mjs";
+import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
+import { getCoinInfo } from "../data/coinInfo.mjs";
+export default class BlockchainSubscribe extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    validateParams(payload, [{
+      name: 'accounts',
+      type: 'array',
+      allowEmpty: true
+    }, {
+      name: 'blocks',
+      type: 'boolean'
+    }, {
+      name: 'coin',
+      type: 'string',
+      required: true
+    }, {
+      name: 'identity',
+      type: 'string'
+    }]);
+    if (payload.accounts) {
+      payload.accounts.forEach(account => {
+        validateParams(account, [{
+          name: 'descriptor',
+          type: 'string',
+          required: true
+        }]);
+      });
+    }
+    const coinInfo = getCoinInfo(payload.coin);
+    if (!coinInfo) {
+      throw ERRORS.TypedError('Method_UnknownCoin');
+    }
+    isBackendSupported(coinInfo);
+    const params = {
+      accounts: payload.accounts,
+      blocks: payload.blocks ?? true,
+      coinInfo,
+      identity: payload.identity
+    };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
+    const {
+      blocks,
+      accounts
+    } = this.params;
+    let result = {
+      subscribed: false
+    };
+    if (blocks) result = await backend.subscribeBlocks();
+    if (accounts) result = await backend.subscribeAccounts(accounts);
+    return result;
+  }
+}

package/libESM/api/blockchainSubscribeFiatRates.d.mts

@@ -0,0 +1,17 @@
+import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage, Payload } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+type Params = {
+    currency: Payload<'blockchainSubscribeFiatRates'>['currency'];
+    coinInfo: CoinInfo;
+    identity?: string;
+};
+export default class BlockchainSubscribeFiatRates extends AbstractMethod<'blockchainSubscribeFiatRates', Params> {
+    constructor(message: MethodMessage<'blockchainSubscribeFiatRates'>);
+    get requiredPermissions(): MethodPermission[];
+    init(): void;
+    run({ sendCoreMessage }: MethodContext): Promise<{
+        subscribed: boolean;
+    }>;
+}
+export {};

package/libESM/api/blockchainSubscribeFiatRates.mjs

@@ -0,0 +1,47 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { validateParams } from "./common/paramsValidator.mjs";
+import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
+import { getCoinInfo } from "../data/coinInfo.mjs";
+export default class BlockchainSubscribeFiatRates extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    validateParams(payload, [{
+      name: 'currency',
+      type: 'string',
+      required: false
+    }, {
+      name: 'coin',
+      type: 'string',
+      required: true
+    }, {
+      name: 'identity',
+      type: 'string'
+    }]);
+    const coinInfo = getCoinInfo(payload.coin);
+    if (!coinInfo) {
+      throw ERRORS.TypedError('Method_UnknownCoin');
+    }
+    isBackendSupported(coinInfo);
+    const params = {
+      currency: payload.currency,
+      coinInfo,
+      identity: payload.identity
+    };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  init() {}
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
+    return backend.subscribeFiatRates(this.params.currency);
+  }
+}

package/libESM/api/blockchainUnsubscribe.d.mts

@@ -0,0 +1,17 @@
+import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage, Payload } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+type Params = {
+    accounts: Payload<'blockchainUnsubscribe'>['accounts'];
+    coinInfo: CoinInfo;
+    identity?: string;
+    blocks: boolean;
+};
+export default class BlockchainUnsubscribe extends AbstractMethod<'blockchainUnsubscribe', Params> {
+    constructor(message: MethodMessage<'blockchainUnsubscribe'>);
+    get requiredPermissions(): MethodPermission[];
+    run({ sendCoreMessage }: MethodContext): Promise<{
+        subscribed: boolean;
+    }>;
+}
+export {};

package/libESM/api/blockchainUnsubscribe.mjs

@@ -0,0 +1,68 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { validateParams } from "./common/paramsValidator.mjs";
+import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
+import { getCoinInfo } from "../data/coinInfo.mjs";
+export default class BlockchainUnsubscribe extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    validateParams(payload, [{
+      name: 'accounts',
+      type: 'array',
+      allowEmpty: true
+    }, {
+      name: 'blocks',
+      type: 'boolean'
+    }, {
+      name: 'coin',
+      type: 'string',
+      required: true
+    }, {
+      name: 'identity',
+      type: 'string'
+    }]);
+    if (payload.accounts) {
+      payload.accounts.forEach(account => {
+        validateParams(account, [{
+          name: 'descriptor',
+          type: 'string',
+          required: true
+        }]);
+      });
+    }
+    const coinInfo = getCoinInfo(payload.coin);
+    if (!coinInfo) {
+      throw ERRORS.TypedError('Method_UnknownCoin');
+    }
+    isBackendSupported(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 [];
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
+    const {
+      accounts
+    } = this.params;
+    if (this.params.blocks) {
+      return backend.unsubscribeBlocks();
+    }
+    if (accounts) {
+      return backend.unsubscribeAccounts(accounts);
+    }
+    return backend.unsubscribeAll();
+  }
+}

package/libESM/api/blockchainUnsubscribeFiatRates.d.mts

@@ -0,0 +1,15 @@
+import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+type Params = {
+    coinInfo: CoinInfo;
+    identity?: string;
+};
+export default class BlockchainUnsubscribeFiatRates extends AbstractMethod<'blockchainUnsubscribeFiatRates', Params> {
+    constructor(message: MethodMessage<'blockchainUnsubscribeFiatRates'>);
+    get requiredPermissions(): MethodPermission[];
+    run({ sendCoreMessage }: MethodContext): Promise<{
+        subscribed: boolean;
+    }>;
+}
+export {};

package/libESM/api/blockchainUnsubscribeFiatRates.mjs

@@ -0,0 +1,41 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { validateParams } from "./common/paramsValidator.mjs";
+import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
+import { getCoinInfo } from "../data/coinInfo.mjs";
+export default class BlockchainUnsubscribeFiatRates extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    validateParams(payload, [{
+      name: 'coin',
+      type: 'string',
+      required: true
+    }, {
+      name: 'identity',
+      type: 'string'
+    }]);
+    const coinInfo = getCoinInfo(payload.coin);
+    if (!coinInfo) {
+      throw ERRORS.TypedError('Method_UnknownCoin');
+    }
+    isBackendSupported(coinInfo);
+    const params = {
+      coinInfo,
+      identity: payload.identity
+    };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
+    return backend.unsubscribeFiatRates();
+  }
+}

package/libESM/api/blockchainValidateEvmRpcUrl.d.mts

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

package/libESM/api/blockchainValidateEvmRpcUrl.mjs

@@ -0,0 +1,54 @@
+import { BlockchainLink } from "@trezor/blockchain-link";
+import { MESSAGES } from "@trezor/blockchain-link-types";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { EvmRpcWorker } from "../workers/workers.mjs";
+import { validateParams } from "./common/paramsValidator.mjs";
+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/libESM/api/cancelCoinjoinAuthorization.d.mts

@@ -0,0 +1,11 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class CancelCoinjoinAuthorization extends AbstractMethod<'cancelCoinjoinAuthorization'> {
+    constructor(message: MethodMessage<'cancelCoinjoinAuthorization'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    run(): Promise<{
+        message: string;
+    }>;
+}

package/libESM/api/cancelCoinjoinAuthorization.mjs

@@ -0,0 +1,31 @@
+import { CancelCoinjoinAuthorization as CancelCoinjoinAuthorizationSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class CancelCoinjoinAuthorization extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(CancelCoinjoinAuthorizationSchema, payload);
+    super(message, undefined);
+    this.preauthorized = typeof payload.preauthorized === 'boolean' ? payload.preauthorized : true;
+  }
+  get requiredPermissions() {
+    return ['management'];
+  }
+  get info() {
+    return 'Cancel Coinjoin Authorization';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    if (!this.preauthorized) {
+      if (!(await cmd.preauthorize(false))) {
+        return {
+          message: 'Not authorized'
+        };
+      }
+    }
+    const response = await cmd.typedCall('CancelAuthorization', 'Success');
+    return response.message;
+  }
+}

package/libESM/api/cardano/api/cardanoComposeTransaction.d.mts

@@ -0,0 +1,10 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import { type CardanoComposeTransactionParams, type PrecomposedTransactionCardano } from '@trezor/connect-common/libESM/types/api/cardanoComposeTransaction';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+export default class CardanoComposeTransaction extends AbstractMethod<'cardanoComposeTransaction', CardanoComposeTransactionParams> {
+    constructor(message: MethodMessage<'cardanoComposeTransaction'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    run(): Promise<PrecomposedTransactionCardano[]>;
+}

package/libESM/api/cardano/api/cardanoComposeTransaction.mjs

@@ -0,0 +1,79 @@
+import { CoinSelectionError, trezorUtils } from "@fivebinaries/coin-selection";
+import { CardanoComposeTransactionParamsSchema } from "@trezor/connect-common/libESM/types/api/cardanoComposeTransaction.mjs";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { composeTxPlan } from "../cardanoUtils.mjs";
+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;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  get info() {
+    return 'Compose Cardano transaction';
+  }
+  run() {
+    const {
+      feeLevels = [{}],
+      account,
+      outputs = [],
+      certificates = [],
+      withdrawals = [],
+      changeAddress,
+      addressParameters,
+      testnet
+    } = this.params;
+    const result = feeLevels.map(({
+      feePerUnit
+    }) => {
+      try {
+        const txPlan = composeTxPlan(account.descriptor, account.utxo, outputs, certificates, withdrawals, changeAddress.address, !!testnet, {
+          feeParams: feePerUnit ? {
+            a: feePerUnit
+          } : undefined
+        });
+        return {
+          fee: txPlan.fee,
+          feePerByte: feePerUnit ?? '0',
+          deposit: txPlan.deposit,
+          totalSpent: txPlan.totalSpent,
+          max: txPlan.max,
+          ...(txPlan.type === 'nonfinal' ? {
+            type: txPlan.type,
+            bytes: 0
+          } : {
+            type: txPlan.type,
+            bytes: txPlan.tx.size,
+            ttl: txPlan.ttl,
+            inputs: trezorUtils.transformToTrezorInputs(txPlan.inputs, account.utxo),
+            outputs: trezorUtils.transformToTrezorOutputs(txPlan.outputs, addressParameters),
+            unsignedTx: txPlan.tx
+          })
+        };
+      } catch (error) {
+        if (error instanceof CoinSelectionError && error.code === 'UTXO_BALANCE_INSUFFICIENT') {
+          return {
+            type: 'error',
+            error: 'UTXO_BALANCE_INSUFFICIENT'
+          };
+        }
+        if (error instanceof CoinSelectionError && error.code === 'UTXO_VALUE_TOO_SMALL') {
+          return {
+            type: 'error',
+            error: 'UTXO_VALUE_TOO_SMALL'
+          };
+        }
+        return {
+          type: 'error',
+          error: error.message
+        };
+      }
+    });
+    return Promise.resolve(result);
+  }
+}

package/libESM/api/cardano/api/cardanoGetAddress.d.mts

@@ -0,0 +1,30 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+type Params = {
+    proto: PROTO.CardanoGetAddress;
+    address?: string;
+};
+export default class CardanoGetAddress extends AbstractMethod<'cardanoGetAddress', Params[]> {
+    hasBundle?: boolean;
+    progress: number;
+    constructor(message: MethodMessage<'cardanoGetAddress'>);
+    get requiredPermissions(): MethodPermission[];
+    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 {};

package/libESM/api/cardano/api/cardanoGetAddress.mjs

@@ -0,0 +1,116 @@
+import { Bundle, CardanoGetAddress as CardanoGetAddressSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { fromHardened, getSerializedPath } from "../../../utils/pathUtils.mjs";
+import { bundlify } from "../../common/paramsValidator.mjs";
+import { addressParametersFromProto, addressParametersToProto, modifyAddressParametersForBackwardsCompatibility, validateAddressParameters } from "../cardanoAddressParameters.mjs";
+export default class CardanoGetAddress extends AbstractMethod {
+  hasBundle;
+  progress = 0;
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(CardanoGetAddressSchema), payload);
+    const params = payload.bundle.map(batch => {
+      validateAddressParameters(batch.addressParameters);
+      const proto = {
+        address_parameters: addressParametersToProto(batch.addressParameters),
+        protocol_magic: batch.protocolMagic,
+        network_id: batch.networkId,
+        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+        chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
+      };
+      return {
+        proto,
+        address: batch.address
+      };
+    });
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.useUi = this.getUseUi(this.params, payload.useEventListener);
+    this.confirmMissingBackup = true;
+    this.requiredDeviceCapabilities = ['Capability_Cardano'];
+    this.requiredFirmwareCoins = [getMiscNetwork('Cardano')];
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    if (this.params.length === 1) {
+      return `Export Cardano address for account #${fromHardened(this.params[0].proto.address_parameters.address_n[2]) + 1}`;
+    }
+    return 'Export multiple Cardano addresses';
+  }
+  getButtonRequestData(code) {
+    if (code === 'ButtonRequest_Address') {
+      return {
+        type: 'address',
+        serializedPath: getSerializedPath(this.params[this.progress].proto.address_parameters.address_n),
+        address: this.params[this.progress].address || 'not-set'
+      };
+    }
+  }
+  get confirmation() {
+    return !this.useUi ? undefined : {
+      view: 'export-address',
+      label: this.info
+    };
+  }
+  async _call({
+    proto
+  }) {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('CardanoGetAddress', 'CardanoAddress', proto);
+    return response.message;
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    for (let i = 0; i < this.params.length; i++) {
+      const batch = this.params[i];
+      batch.proto.address_parameters = modifyAddressParametersForBackwardsCompatibility(batch.proto.address_parameters);
+      if (batch.proto.show_display) {
+        const silent = await this._call({
+          ...batch,
+          proto: {
+            ...batch.proto,
+            show_display: false
+          }
+        });
+        if (typeof batch.address === 'string') {
+          if (batch.address !== silent.address) {
+            throw ERRORS.TypedError('Method_AddressNotMatch');
+          }
+        } else {
+          batch.address = silent.address;
+        }
+      }
+      const response = await this._call(batch);
+      responses.push({
+        addressParameters: addressParametersFromProto(batch.proto.address_parameters),
+        protocolMagic: batch.proto.protocol_magic,
+        networkId: batch.proto.network_id,
+        serializedPath: getSerializedPath(batch.proto.address_parameters.address_n),
+        serializedStakingPath: getSerializedPath(batch.proto.address_parameters.address_n_staking),
+        address: response.address,
+        mac: response.mac
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response
+        }));
+      }
+      this.progress++;
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/libESM/api/cardano/api/cardanoGetNativeScriptHash.d.mts

@@ -0,0 +1,12 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+export default class CardanoGetNativeScriptHash extends AbstractMethod<'cardanoGetNativeScriptHash', PROTO.CardanoGetNativeScriptHash> {
+    constructor(message: MethodMessage<'cardanoGetNativeScriptHash'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    run(): Promise<{
+        scriptHash: string;
+    }>;
+}