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

package/libESM/api/blockchainSubscribe.mjs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,12 +0,0 @@
-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;
-    }>;
-}