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

package/lib/api/blockchainDisconnect.js

@@ -1,37 +0,0 @@
-import { CoinObj } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { assertBackendSupported, findBackend } from "../backend/BlockchainLink.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { getCoinInfoOrThrow } from "../data/coinInfo.js";
-export default class BlockchainDisconnect extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(CoinObj, payload);
-    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 [{
-      permission: 'internal'
-    }];
-  }
-  get info() {
-    return '';
-  }
-  run() {
-    const backend = findBackend(this.params.coinInfo.shortcut, this.params.identity);
-    backend?.disconnect();
-    return Promise.resolve({
-      disconnected: true
-    });
-  }
-}

package/lib/api/blockchainEstimateFee.d.ts

@@ -1,16 +0,0 @@
-import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, MethodReturnType, Payload } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-type Params = {
-  coinInfo: CoinInfo;
-  identity?: string;
-  request: Payload<'blockchainEstimateFee'>['request'];
-};
-export default class BlockchainEstimateFee extends AbstractMethod<'blockchainEstimateFee', Params> {
-  constructor(message: MethodMessage<'blockchainEstimateFee'>);
-  get requiredPermissions(): PermissionRequest[];
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<MethodReturnType<"blockchainEstimateFee">>;
-}
-export {};

package/lib/api/blockchainEstimateFee.js

@@ -1,102 +0,0 @@
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { validateParams } from "./common/paramsValidator.js";
-import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
-import { getOrInitFeeLevels } from "../backend/fees/index.js";
-import { getCoinInfoOrThrow } from "../data/coinInfo.js";
-export default class BlockchainEstimateFee extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }, {
-      name: 'request',
-      type: 'object'
-    }]);
-    const {
-      request,
-      identity
-    } = payload;
-    if (request) {
-      validateParams(request, [{
-        name: 'blocks',
-        type: 'array'
-      }, {
-        name: 'specific',
-        type: 'object'
-      }, {
-        name: 'feeLevels',
-        type: 'string'
-      }]);
-      if (request.specific) {
-        validateParams(request.specific, [{
-          name: 'conservative',
-          type: 'boolean'
-        }, {
-          name: 'data',
-          type: 'string'
-        }, {
-          name: 'from',
-          type: 'string'
-        }, {
-          name: 'to',
-          type: 'string'
-        }, {
-          name: 'txsize',
-          type: 'number'
-        }, {
-          name: 'newAccountProgramName',
-          type: 'string'
-        }]);
-      }
-    }
-    const coinInfo = getCoinInfoOrThrow(payload.coin);
-    assertBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      identity,
-      request
-    };
-    super(message, params);
-    this.useDevice = false;
-    this.useUi = false;
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const {
-      coinInfo,
-      identity,
-      request
-    } = this.params;
-    const feeInfo = {
-      blockTime: coinInfo.blockTime,
-      minFee: coinInfo.minFee,
-      maxFee: coinInfo.maxFee,
-      minPriorityFee: coinInfo.minPriorityFee,
-      dustLimit: coinInfo.type === 'bitcoin' ? coinInfo.dustLimit : undefined,
-      levels: []
-    };
-    if (request?.feeLevels) {
-      const feeLevelsInstance = getOrInitFeeLevels(coinInfo);
-      if (request.feeLevels === 'smart') {
-        const backend = await initBlockchain(coinInfo, sendCoreMessage, identity);
-        await feeLevelsInstance.load(backend, request);
-      }
-      feeInfo.levels = feeLevelsInstance.levels;
-    } else {
-      const backend = await initBlockchain(coinInfo, sendCoreMessage, identity);
-      feeInfo.levels = await backend.estimateFee(request || {});
-    }
-    return feeInfo;
-  }
-}

package/lib/api/blockchainEvmRpcCall.d.ts

@@ -1,19 +0,0 @@
-import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-type Params = {
-  coinInfo: CoinInfo;
-  identity?: string;
-  request: Omit<Payload<'blockchainEvmRpcCall'>, 'method' | 'coin'>;
-};
-export default class BlockchainEvmRpcCall extends AbstractMethod<'blockchainEvmRpcCall', Params> {
-  constructor(message: MethodMessage<'blockchainEvmRpcCall'>);
-  get requiredPermissions(): PermissionRequest[];
-  get info(): string;
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<{
-    data: string;
-  }>;
-}
-export {};

package/lib/api/blockchainEvmRpcCall.js

@@ -1,57 +0,0 @@
-import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { validateParams } from "./common/paramsValidator.js";
-import { getCoinInfoOrThrow } from "../data/coinInfo.js";
-export default class BlockchainEvmRpcCall extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }, {
-      name: 'from',
-      type: 'string'
-    }, {
-      name: 'to',
-      type: 'string',
-      required: true
-    }, {
-      name: 'data',
-      type: 'string',
-      required: true
-    }]);
-    const coinInfo = getCoinInfoOrThrow(payload.coin);
-    assertBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      identity: payload.identity,
-      request: {
-        from: payload.from,
-        to: payload.to,
-        data: payload.data
-      }
-    };
-    super(message, params);
-    this.useDevice = false;
-    this.useUi = false;
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  get info() {
-    return 'Blockchain Evm Rpc Call';
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
-    const response = await backend.rpcCall(this.params.request);
-    return response;
-  }
-}

package/lib/api/blockchainGetAccountBalanceHistory.d.ts

@@ -1,16 +0,0 @@
-import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-type Params = {
-  coinInfo: CoinInfo;
-  identity?: string;
-  request: Omit<Payload<'blockchainGetAccountBalanceHistory'>, 'method' | 'coin'>;
-};
-export default class BlockchainGetAccountBalanceHistory extends AbstractMethod<'blockchainGetAccountBalanceHistory', Params> {
-  constructor(message: MethodMessage<'blockchainGetAccountBalanceHistory'>);
-  get requiredPermissions(): PermissionRequest[];
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<import("@trezor/blockchain-link-types").AccountBalanceHistory[]>;
-}
-export {};

package/lib/api/blockchainGetAccountBalanceHistory.js

@@ -1,60 +0,0 @@
-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 BlockchainGetAccountBalanceHistory extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }, {
-      name: 'descriptor',
-      type: 'string',
-      required: true
-    }, {
-      name: 'from',
-      type: 'number'
-    }, {
-      name: 'to',
-      type: 'number'
-    }, {
-      name: 'groupBy',
-      type: 'number'
-    }, {
-      name: 'currencies',
-      type: 'array'
-    }]);
-    const coinInfo = getCoinInfoOrThrow(payload.coin);
-    assertBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      identity: payload.identity,
-      request: {
-        descriptor: payload.descriptor,
-        from: payload.from,
-        to: payload.to,
-        groupBy: payload.groupBy,
-        currencies: payload.currencies
-      }
-    };
-    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.getAccountBalanceHistory(this.params.request);
-  }
-}

package/lib/api/blockchainGetContractInfo.d.ts

@@ -1,16 +0,0 @@
-import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-type Params = {
-  coinInfo: CoinInfo;
-  identity?: string;
-  request: Pick<Payload<'blockchainGetContractInfo'>, 'contract' | 'currency' | 'protocols'>;
-};
-export default class BlockchainGetContractInfo extends AbstractMethod<'blockchainGetContractInfo', Params> {
-  constructor(message: MethodMessage<'blockchainGetContractInfo'>);
-  get requiredPermissions(): PermissionRequest[];
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<import("@trezor/blockchain-link-types/lib/blockbook-api").ContractInfoResult>;
-}
-export {};

package/lib/api/blockchainGetContractInfo.js

@@ -1,46 +0,0 @@
-import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { getCoinInfoOrThrow } from "../data/coinInfo.js";
-import { validateParams } from "./common/paramsValidator.js";
-export default class BlockchainGetContractInfo extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'contract',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }]);
-    const coinInfo = getCoinInfoOrThrow(payload.coin);
-    assertBackendSupported(coinInfo);
-    const request = {
-      contract: payload.contract,
-      currency: payload.currency,
-      protocols: payload.protocols
-    };
-    super(message, {
-      coinInfo,
-      identity: payload.identity,
-      request
-    });
-    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.getContractInfo(this.params.request);
-  }
-}

package/lib/api/blockchainGetCurrentFiatRates.d.ts

@@ -1,20 +0,0 @@
-import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-type Params = {
-  coinInfo: CoinInfo;
-  identity?: string;
-  currencies: Payload<'blockchainGetCurrentFiatRates'>['currencies'];
-  token: Payload<'blockchainGetCurrentFiatRates'>['token'];
-};
-export default class BlockchainGetCurrentFiatRates extends AbstractMethod<'blockchainGetCurrentFiatRates', Params> {
-  constructor(message: MethodMessage<'blockchainGetCurrentFiatRates'>);
-  get requiredPermissions(): PermissionRequest[];
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<{
-    ts: number;
-    rates: import("@trezor/blockchain-link-types").FiatRatesBySymbol;
-  }>;
-}
-export {};

package/lib/api/blockchainGetCurrentFiatRates.js

@@ -1,49 +0,0 @@
-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 BlockchainGetCurrentFiatRates extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'currencies',
-      type: 'array',
-      required: false
-    }, {
-      name: 'token',
-      type: 'string'
-    }, {
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }]);
-    const coinInfo = getCoinInfoOrThrow(payload.coin);
-    assertBackendSupported(coinInfo);
-    const params = {
-      currencies: payload.currencies,
-      token: payload.token,
-      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.getCurrentFiatRates({
-      currencies: this.params.currencies,
-      token: this.params.token
-    });
-  }
-}

package/lib/api/blockchainGetFiatRatesForTimestamps.d.ts

@@ -1,23 +0,0 @@
-import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-type Params = {
-  coinInfo: CoinInfo;
-  identity?: string;
-  currencies: Payload<'blockchainGetFiatRatesForTimestamps'>['currencies'];
-  timestamps: Payload<'blockchainGetFiatRatesForTimestamps'>['timestamps'];
-  token: Payload<'blockchainGetFiatRatesForTimestamps'>['token'];
-};
-export default class BlockchainGetFiatRatesForTimestamps extends AbstractMethod<'blockchainGetFiatRatesForTimestamps', Params> {
-  constructor(message: MethodMessage<'blockchainGetFiatRatesForTimestamps'>);
-  get requiredPermissions(): PermissionRequest[];
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<{
-    tickers: {
-      ts: number;
-      rates: import("@trezor/blockchain-link-types").FiatRatesBySymbol;
-    }[];
-  }>;
-}
-export {};

package/lib/api/blockchainGetFiatRatesForTimestamps.js

@@ -1,55 +0,0 @@
-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 BlockchainGetFiatRatesForTimestamps extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'currencies',
-      type: 'array',
-      required: false
-    }, {
-      name: 'timestamps',
-      type: 'array',
-      required: true
-    }, {
-      name: 'token',
-      type: 'string'
-    }, {
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }]);
-    const coinInfo = getCoinInfoOrThrow(payload.coin);
-    assertBackendSupported(coinInfo);
-    const params = {
-      currencies: payload.currencies,
-      timestamps: payload.timestamps,
-      token: payload.token,
-      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.getFiatRatesForTimestamps({
-      currencies: this.params.currencies,
-      timestamps: this.params.timestamps,
-      token: this.params.token
-    });
-  }
-}

package/lib/api/blockchainGetInfo.d.ts

@@ -1,15 +0,0 @@
-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;
-};
-export default class BlockchainGetInfo extends AbstractMethod<'blockchainGetInfo', Params> {
-  constructor(message: MethodMessage<'blockchainGetInfo'>);
-  get requiredPermissions(): PermissionRequest[];
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<import("@trezor/blockchain-link-types").ServerInfo>;
-}
-export {};

package/lib/api/blockchainGetInfo.js

@@ -1,37 +0,0 @@
-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 BlockchainGetInfo extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }]);
-    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({
-    sendCoreMessage
-  }) {
-    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
-    return backend.getNetworkInfo();
-  }
-}

package/lib/api/blockchainGetTransactions.d.ts

@@ -1,18 +0,0 @@
-import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-type Params = {
-  txs: string[];
-  coinInfo: CoinInfo;
-  identity?: string;
-  descriptor?: string;
-};
-export default class BlockchainGetTransactions extends AbstractMethod<'blockchainGetTransactions', Params> {
-  constructor(message: MethodMessage<'blockchainGetTransactions'>);
-  get requiredPermissions(): PermissionRequest[];
-  init(): void;
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<import("@trezor/blockchain-link-types").Transaction[]>;
-}
-export {};

package/lib/api/blockchainGetTransactions.js

@@ -1,47 +0,0 @@
-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 BlockchainGetTransactions extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'txs',
-      type: 'array',
-      required: true
-    }, {
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }, {
-      name: 'descriptor',
-      type: 'string'
-    }]);
-    const coinInfo = getCoinInfoOrThrow(payload.coin);
-    assertBackendSupported(coinInfo);
-    const params = {
-      txs: payload.txs,
-      coinInfo,
-      identity: payload.identity,
-      descriptor: payload.descriptor
-    };
-    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.getTransactions(this.params.txs, this.params.descriptor);
-  }
-}

package/lib/api/blockchainSetCustomBackend.d.ts

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