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

package/lib/api/blockchainGetCurrentFiatRates.js

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

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

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

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

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

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

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

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

package/lib/api/blockchainSetCustomBackend.js

@@ -0,0 +1,43 @@
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validateParams } from "./common/paramsValidator.js";
+import { reconnectAllBackends, setCustomBackend } from "../backend/BlockchainLink.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+export default class BlockchainSetCustomBackend extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    validateParams(payload, [{
+      name: 'coin',
+      type: 'string',
+      required: true
+    }, {
+      name: 'blockchainLink',
+      type: 'object'
+    }]);
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    const {
+      blockchainLink
+    } = payload;
+    const params = {
+      coinInfo,
+      blockchainLink
+    };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'internal'
+    }];
+  }
+  get info() {
+    return '';
+  }
+  async run() {
+    setCustomBackend(this.params.coinInfo, this.params.blockchainLink);
+    await reconnectAllBackends(this.params.coinInfo);
+    return true;
+  }
+}

package/lib/api/blockchainSubscribe.d.ts

@@ -0,0 +1,19 @@
+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 = {
+  accounts: Payload<'blockchainSubscribe'>['accounts'];
+  blocks: boolean;
+  coinInfo: CoinInfo;
+  identity?: string;
+};
+export default class BlockchainSubscribe extends AbstractMethod<'blockchainSubscribe', Params> {
+  constructor(message: MethodMessage<'blockchainSubscribe'>);
+  get requiredPermissions(): PermissionRequest[];
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    subscribed: boolean;
+  }>;
+}
+export {};

package/lib/api/blockchainSubscribe.js

@@ -0,0 +1,66 @@
+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 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 = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(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 [{
+      permission: 'internal'
+    }];
+  }
+  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/lib/api/blockchainSubscribeFiatRates.d.ts

@@ -0,0 +1,19 @@
+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 = {
+  currency: Payload<'blockchainSubscribeFiatRates'>['currency'];
+  coinInfo: CoinInfo;
+  identity?: string;
+};
+export default class BlockchainSubscribeFiatRates extends AbstractMethod<'blockchainSubscribeFiatRates', Params> {
+  constructor(message: MethodMessage<'blockchainSubscribeFiatRates'>);
+  get requiredPermissions(): PermissionRequest[];
+  init(): void;
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    subscribed: boolean;
+  }>;
+}
+export {};

package/lib/api/blockchainSubscribeFiatRates.js

@@ -0,0 +1,43 @@
+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 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 = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(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/lib/api/blockchainUnsubscribe.d.ts

@@ -0,0 +1,19 @@
+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 = {
+  accounts: Payload<'blockchainUnsubscribe'>['accounts'];
+  coinInfo: CoinInfo;
+  identity?: string;
+  blocks: boolean;
+};
+export default class BlockchainUnsubscribe extends AbstractMethod<'blockchainUnsubscribe', Params> {
+  constructor(message: MethodMessage<'blockchainUnsubscribe'>);
+  get requiredPermissions(): PermissionRequest[];
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    subscribed: boolean;
+  }>;
+}
+export {};

package/lib/api/blockchainUnsubscribe.js

@@ -0,0 +1,66 @@
+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
+    } = 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 = 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({
+    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/lib/api/blockchainUnsubscribeFiatRates.d.ts

@@ -0,0 +1,17 @@
+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 BlockchainUnsubscribeFiatRates extends AbstractMethod<'blockchainUnsubscribeFiatRates', Params> {
+  constructor(message: MethodMessage<'blockchainUnsubscribeFiatRates'>);
+  get requiredPermissions(): PermissionRequest[];
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    subscribed: boolean;
+  }>;
+}
+export {};

package/lib/api/blockchainUnsubscribeFiatRates.js

@@ -0,0 +1,37 @@
+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
+    } = 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.unsubscribeFiatRates();
+  }
+}

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();
+    }
+  }
+}