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

package/lib/api/bitcoin/signtxVerify.d.ts

@@ -0,0 +1,12 @@
+import type { Network, PROTO } from '@trezor/connect-common';
+import { Transaction as BitcoinJsTransaction } from '@trezor/utxo-lib';
+import type { DeviceCommands } from "../../device/DeviceCommands.js";
+type GetHDNode = (address_n: number[]) => ReturnType<ReturnType<typeof DeviceCommands>['getHDNode']>;
+export declare const deriveOutputScript: (getHDNode: GetHDNode, output: PROTO.TxOutputType, network: Network) => Promise<Buffer<ArrayBufferLike> | undefined>;
+export declare const verifyTx: (serializedTx: string, params: {
+  inputs: PROTO.TxInputType[];
+  outputs: PROTO.TxOutputType[];
+  outputScripts: Awaited<ReturnType<typeof deriveOutputScript>>[];
+  network: Network;
+}) => BitcoinJsTransaction;
+export {};

package/lib/api/bitcoin/signtxVerify.js

@@ -0,0 +1,95 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { address as BitcoinJsAddress, payments as BitcoinJsPayments, Transaction as BitcoinJsTransaction, bip32 } from "@trezor/utxo-lib";
+const derivePubKeyHash = async (getHDNode, address_n, network) => {
+  if (address_n.length === 5) {
+    const response = await getHDNode(address_n.slice(0, 4));
+    const node = bip32.fromBase58(response.xpub, network);
+    const lastComponent = address_n[address_n.length - 1];
+    return node.derive(lastComponent);
+  }
+  const response = await getHDNode(address_n);
+  return bip32.fromBase58(response.xpub, network);
+};
+export const deriveOutputScript = async (getHDNode, output, network) => {
+  if ('multisig' in output) return;
+  if ('op_return_data' in output) {
+    return BitcoinJsPayments.embed({
+      data: [Buffer.from(output.op_return_data, 'hex')]
+    }).output;
+  }
+  if (output.address) {
+    return BitcoinJsAddress.toOutputScript(output.address, network);
+  }
+  if (!output.address_n) {
+    throw ERRORS.TypedError('Runtime', 'deriveOutputScript: Neither address or address_n is set');
+  }
+  const node = await derivePubKeyHash(getHDNode, output.address_n, network);
+  const payment = {
+    hash: node.identifier,
+    network
+  };
+  if (output.script_type === 'PAYTOADDRESS') {
+    return BitcoinJsPayments.p2pkh(payment).output;
+  }
+  if (output.script_type === 'PAYTOSCRIPTHASH') {
+    return BitcoinJsPayments.p2sh(payment).output;
+  }
+  if (output.script_type === 'PAYTOP2SHWITNESS') {
+    return BitcoinJsPayments.p2sh({
+      redeem: BitcoinJsPayments.p2wpkh(payment)
+    }).output;
+  }
+  if (output.script_type === 'PAYTOWITNESS') {
+    return BitcoinJsPayments.p2wpkh(payment).output;
+  }
+  if (output.script_type === 'PAYTOTAPROOT') {
+    return BitcoinJsPayments.p2tr({
+      pubkey: node.publicKey,
+      network
+    }).output;
+  }
+  if (output.script_type === 'PAYTOMULTISIG') {
+    throw ERRORS.TypedError('Runtime', `deriveOutputScript: script_type PAYTOMULTISIG not expected without multisig defined`);
+  }
+  throw ERRORS.TypedError('Runtime', `deriveOutputScript: Unknown script type ${output.script_type}`);
+};
+export const verifyTx = (serializedTx, params) => {
+  const {
+    inputs,
+    outputs,
+    outputScripts,
+    network
+  } = params;
+  const bitcoinTx = BitcoinJsTransaction.fromHex(serializedTx, {
+    network
+  });
+  if (inputs.length !== bitcoinTx.ins.length) {
+    throw ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction inputs invalid length');
+  }
+  if (outputs.length !== bitcoinTx.outs.length) {
+    throw ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction outputs invalid length');
+  }
+  outputs.forEach((output, i) => {
+    const {
+      outs
+    } = bitcoinTx;
+    const txOut = outs[i];
+    if (output.amount) {
+      if (output.amount.toString() !== txOut.value) {
+        throw ERRORS.TypedError('Runtime', `verifyTx: Wrong output amount at output ${i}. Requested: ${output.amount}, signed: ${txOut.value}`);
+      }
+    }
+  });
+  for (let i = 0; i < outputs.length; i++) {
+    const {
+      outs
+    } = bitcoinTx;
+    const out = outs[i];
+    const scriptB = out.script;
+    const scriptA = outputScripts[i];
+    if (scriptA && scriptA.compare(scriptB) !== 0) {
+      throw ERRORS.TypedError('Runtime', `verifyTx: Output ${i} scripts differ`);
+    }
+  }
+  return bitcoinTx;
+};

package/lib/api/bitcoin/transactionBytes.d.ts

@@ -0,0 +1,3 @@
+import type { BitcoinNetworkInfo, PROTO } from '@trezor/connect-common';
+export declare function mapOutputScriptToKey(script_type: string): "p2pkh" | "p2sh" | "p2tr" | "p2wpkh" | undefined;
+export declare const getTransactionVbytes: (inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], coinInfo: BitcoinNetworkInfo) => number | undefined;

package/lib/api/bitcoin/transactionBytes.js

@@ -0,0 +1,65 @@
+import { TxWeightCalculator, address as baddress } from "@trezor/utxo-lib";
+import { getOutputScriptType, getScriptType } from "../../utils/pathUtils.js";
+export function mapOutputScriptToKey(script_type) {
+  switch (script_type) {
+    case 'PAYTOADDRESS':
+      return 'p2pkh';
+    case 'PAYTOSCRIPTHASH':
+      return 'p2sh';
+    case 'PAYTOWITNESS':
+      return 'p2wpkh';
+    case 'PAYTOP2SHWITNESS':
+      return 'p2sh';
+    case 'PAYTOTAPROOT':
+      return 'p2tr';
+    default:
+      return undefined;
+  }
+}
+export const getTransactionVbytes = (inputs, outputs, coinInfo) => {
+  const calc = new TxWeightCalculator();
+  let cannotProcess = false;
+  inputs.forEach(input => {
+    const script_type = input.script_type ?? getScriptType(input.address_n);
+    if (script_type && !input.witness) {
+      calc.addInput({
+        script_type,
+        multisig: input.multisig,
+        ownership_proof: input.ownership_proof
+      });
+    } else {
+      cannotProcess = true;
+    }
+  });
+  outputs.forEach(out => {
+    if (out.script_type === 'PAYTOOPRETURN') {
+      if (!out.op_return_data) {
+        cannotProcess = true;
+        return;
+      }
+      calc.addOutput({
+        length: 2 + out.op_return_data.length / 2
+      });
+      return;
+    } else if (out.address) {
+      calc.addOutput({
+        length: baddress.toOutputScript(out.address, coinInfo.network).length
+      });
+      return;
+    } else if (out.address_n || out.script_type) {
+      const script_type = out.script_type ?? getOutputScriptType(out.address_n);
+      if (script_type) {
+        const script_key = mapOutputScriptToKey(script_type);
+        if (script_key) {
+          calc.addOutputByKey(script_key);
+          return;
+        }
+      }
+    }
+    cannotProcess = true;
+  });
+  if (cannotProcess) {
+    return undefined;
+  }
+  return calc.getVirtualBytes();
+};

package/lib/api/bleUnpair.d.ts

@@ -0,0 +1,11 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class BleUnpair extends AbstractMethod<'bleUnpair', PROTO.BleUnpair> {
+  constructor(message: MethodMessage<'bleUnpair'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    message: string;
+  }>;
+}

package/lib/api/bleUnpair.js

@@ -0,0 +1,37 @@
+import { UI_REQUEST } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { TRANSPORT_ERROR } from "@trezor/transport-common";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class BleUnpair extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(PROTO.BleUnpair, payload);
+    const params = {
+      all: payload.all
+    };
+    super(message, params);
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
+    this.useDeviceState = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    try {
+      const response = await cmd.typedCall('BleUnpair', 'Success', this.params);
+      return response.message;
+    } catch (error) {
+      if (this.getDevice().descriptor.apiType === 'bluetooth' && error.message === TRANSPORT_ERROR.INTERFACE_DATA_TRANSFER) {
+        throw ERRORS.TypedError('Device_Disconnected');
+      }
+      throw error;
+    }
+  }
+}

package/lib/api/blockchainDisconnect.d.ts

@@ -0,0 +1,16 @@
+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;
+  identity?: string;
+};
+export default class BlockchainDisconnect extends AbstractMethod<'blockchainDisconnect', Params> {
+  constructor(message: MethodMessage<'blockchainDisconnect'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    disconnected: boolean;
+  }>;
+}
+export {};

package/lib/api/blockchainDisconnect.js

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

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

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

@@ -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 = {
+  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

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

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

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

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

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

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