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

package/lib/device/DeviceCommands.d.ts

@@ -0,0 +1,87 @@
+import type { BitcoinNetworkInfo, CoinInfo } from '@trezor/connect-common/lib/types/coinInfo';
+import type { MessagesSchema as Messages } from '@trezor/protobuf';
+import type { TypedCallProvider } from "../types/typed-call-provider.js";
+type TypedCall = Messages.TypedCall;
+export type { TypedCall };
+export type AccountDescriptor = {
+  descriptor: string;
+  legacyXpub?: string;
+  address_n: number[];
+  descriptorChecksum?: string;
+  fingerprint?: number;
+  rootFingerprint?: number;
+  outputDescriptorBip380?: string;
+};
+export declare const DeviceCommands: (deviceTypedCall: TypedCallProvider) => {
+  unlockPath: (params?: Messages.UnlockPath) => Promise<{
+    type: "UnlockedPathRequest";
+    message: {
+      mac: string;
+    };
+  }>;
+  getPublicKey: (params: Messages.GetPublicKey, unlock?: Messages.UnlockPath) => Promise<{
+    descriptor?: string | undefined;
+    root_fingerprint?: number | undefined;
+    xpub: string;
+    node: {
+      private_key?: string | undefined;
+      fingerprint: number;
+      depth: number;
+      child_num: number;
+      chain_code: string;
+      public_key: string;
+    };
+  }>;
+  getAddress: ({
+    address_n,
+    show_display,
+    multisig,
+    script_type,
+    chunkify
+  }: Messages.GetAddress, coinInfo: BitcoinNetworkInfo) => Promise<{
+    mac?: string | undefined;
+    address: string;
+  }>;
+  ethereumGetPublicKey: ({
+    address_n,
+    show_display
+  }: Messages.EthereumGetPublicKey) => Promise<{
+    xpub: string;
+    node: {
+      private_key?: string | undefined;
+      fingerprint: number;
+      depth: number;
+      child_num: number;
+      chain_code: string;
+      public_key: string;
+    };
+  }>;
+  ethereumGetAddress: (params: Messages.EthereumGetAddress) => Promise<{
+    mac?: string | undefined;
+    _old_address?: string | undefined;
+    address: string;
+  }>;
+  getHDNode: (params: Messages.GetPublicKey, options: {
+    coinInfo: BitcoinNetworkInfo;
+    validation?: boolean;
+    unlockPath?: Messages.UnlockPath;
+  }) => Promise<{
+    publicKey: string;
+    path: number[];
+    serializedPath: string;
+    displayablePublicKey: string;
+  } & {
+    xpubSegwit?: string | undefined;
+    descriptorChecksum?: string | undefined;
+    rootFingerprint?: number | undefined;
+    descriptor?: string | undefined;
+    childNum: number;
+    xpub: string;
+    chainCode: string;
+    fingerprint: number;
+    depth: number;
+  }>;
+  preauthorize: (throwError: boolean) => Promise<boolean>;
+  getAccountDescriptor: (coinInfo: CoinInfo, address_n: number[], derivationType?: Messages.CardanoDerivationType) => Promise<AccountDescriptor>;
+  typedCall: Messages.TypedCall;
+};

package/lib/device/DeviceCommands.js

@@ -0,0 +1,248 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { getBech32Network, getSegwitNetwork } from "../data/coinInfo.js";
+import { resolveDescriptorForTaproot } from "../device/resolveDescriptorForTaproot.js";
+import * as hdnodeUtils from "../utils/hdnodeUtils.js";
+import { getScriptType, getSerializedPath, isTaprootPath } from "../utils/pathUtils.js";
+export const DeviceCommands = deviceTypedCall => {
+  const typedCall = deviceTypedCall.typedCall.bind(deviceTypedCall);
+  const unlockPath = params => typedCall('UnlockPath', 'UnlockedPathRequest', params);
+  const getPublicKey = async (params, unlock) => {
+    if (unlock) {
+      await unlockPath(unlock);
+    }
+    const response = await typedCall('GetPublicKey', 'PublicKey', {
+      address_n: params.address_n,
+      coin_name: params.coin_name || 'Bitcoin',
+      script_type: params.script_type,
+      show_display: params.show_display,
+      ignore_xpub_magic: params.ignore_xpub_magic,
+      ecdsa_curve_name: params.ecdsa_curve_name
+    });
+    return response.message;
+  };
+  const getHDNode = async (params, options) => {
+    const path = params.address_n;
+    const {
+      coinInfo,
+      unlockPath: unlock
+    } = options;
+    const validation = typeof options.validation === 'boolean' ? options.validation : true;
+    let network = null;
+    if (!params.script_type) {
+      params.script_type = getScriptType(path);
+    }
+    if (params.script_type === 'SPENDP2SHWITNESS') {
+      network = getSegwitNetwork(coinInfo);
+    } else if (params.script_type === 'SPENDWITNESS') {
+      network = getBech32Network(coinInfo);
+    }
+    if (!network) {
+      network = coinInfo.network;
+    }
+    if (!params.coin_name) {
+      params.coin_name = coinInfo.name;
+    }
+    let publicKey;
+    if (params.show_display || !validation) {
+      publicKey = await getPublicKey(params, unlock);
+    } else {
+      const suffix = 0;
+      const childPath = path.concat([suffix]);
+      const resKey = await getPublicKey(params, unlock);
+      const childKey = await getPublicKey({
+        ...params,
+        address_n: childPath
+      }, unlock);
+      publicKey = hdnodeUtils.xpubDerive(resKey, childKey, suffix, network, coinInfo.network);
+    }
+    const xpub = network !== coinInfo.network ? hdnodeUtils.convertXpub(publicKey.xpub, network, coinInfo.network) : publicKey.xpub;
+    const xpubSegwit = network !== coinInfo.network ? publicKey.xpub : undefined;
+    const response = {
+      path,
+      serializedPath: getSerializedPath(path),
+      childNum: publicKey.node.child_num,
+      xpub,
+      chainCode: publicKey.node.chain_code,
+      publicKey: publicKey.node.public_key,
+      fingerprint: publicKey.node.fingerprint,
+      rootFingerprint: publicKey.root_fingerprint,
+      depth: publicKey.node.depth,
+      descriptor: publicKey.descriptor,
+      displayablePublicKey: xpubSegwit ?? xpub,
+      ...(xpubSegwit !== undefined && {
+        xpubSegwit
+      })
+    };
+    if (isTaprootPath(path)) {
+      const {
+        checksum,
+        xpub: taprootXpubSegwit
+      } = resolveDescriptorForTaproot({
+        response,
+        publicKey
+      });
+      response.xpubSegwit = taprootXpubSegwit;
+      response.descriptorChecksum = checksum;
+      response.displayablePublicKey = taprootXpubSegwit;
+    }
+    return response;
+  };
+  const getAddress = async ({
+    address_n,
+    show_display,
+    multisig,
+    script_type,
+    chunkify
+  }, coinInfo) => {
+    if (!script_type) {
+      script_type = getScriptType(address_n);
+      if (script_type === 'SPENDMULTISIG' && !multisig) {
+        script_type = 'SPENDADDRESS';
+      }
+    }
+    if (multisig?.pubkeys) {
+      multisig.pubkeys.forEach(pk => {
+        if (typeof pk.node === 'string') {
+          pk.node = hdnodeUtils.xpubToHDNodeType(pk.node, coinInfo.network);
+        }
+      });
+    }
+    const response = await typedCall('GetAddress', 'Address', {
+      address_n,
+      coin_name: coinInfo.name,
+      show_display,
+      multisig,
+      script_type: script_type || 'SPENDADDRESS',
+      chunkify
+    });
+    return response.message;
+  };
+  const ethereumGetAddress = async params => {
+    const response = await typedCall('EthereumGetAddress', 'EthereumAddress', params);
+    return response.message;
+  };
+  const ethereumGetPublicKey = async ({
+    address_n,
+    show_display
+  }) => {
+    const suffix = 0;
+    const childPath = address_n.concat([suffix]);
+    const resKey = await typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
+      address_n,
+      show_display
+    });
+    const childKey = await typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
+      address_n: childPath,
+      show_display: false
+    });
+    return hdnodeUtils.xpubDerive(resKey.message, childKey.message, suffix);
+  };
+  const preauthorize = async throwError => {
+    try {
+      await typedCall('DoPreauthorized', 'PreauthorizedRequest', {});
+      return true;
+    } catch (error) {
+      if (throwError) throw error;
+      return false;
+    }
+  };
+  const getAccountDescriptor = async (coinInfo, address_n, derivationType = PROTO.CardanoDerivationType.ICARUS_TREZOR) => {
+    if (coinInfo.type === 'bitcoin') {
+      const resp = await getHDNode({
+        address_n
+      }, {
+        coinInfo,
+        validation: false
+      });
+      return {
+        descriptor: resp.xpubSegwit || resp.xpub,
+        legacyXpub: resp.xpub,
+        address_n,
+        descriptorChecksum: resp.descriptorChecksum,
+        fingerprint: resp.fingerprint,
+        rootFingerprint: resp.rootFingerprint,
+        outputDescriptorBip380: resp.descriptor
+      };
+    }
+    if (coinInfo.type === 'ethereum') {
+      const {
+        message
+      } = await typedCall('EthereumGetAddress', 'EthereumAddress', {
+        address_n
+      });
+      return {
+        descriptor: message.address,
+        address_n
+      };
+    }
+    if (coinInfo.shortcut === 'ADA' || coinInfo.shortcut === 'tADA') {
+      const {
+        message
+      } = await typedCall('CardanoGetPublicKey', 'CardanoPublicKey', {
+        address_n,
+        derivation_type: derivationType
+      });
+      return {
+        descriptor: message.xpub,
+        address_n
+      };
+    }
+    if (coinInfo.shortcut === 'XRP' || coinInfo.shortcut === 'tXRP') {
+      const {
+        message
+      } = await typedCall('RippleGetAddress', 'RippleAddress', {
+        address_n
+      });
+      return {
+        descriptor: message.address,
+        address_n
+      };
+    }
+    if (coinInfo.shortcut === 'SOL' || coinInfo.shortcut === 'DSOL') {
+      const {
+        message
+      } = await typedCall('SolanaGetAddress', 'SolanaAddress', {
+        address_n
+      });
+      return {
+        descriptor: message.address,
+        address_n
+      };
+    }
+    if (coinInfo.shortcut === 'XLM' || coinInfo.shortcut === 'tXLM') {
+      const {
+        message
+      } = await typedCall('StellarGetAddress', 'StellarAddress', {
+        address_n
+      });
+      return {
+        descriptor: message.address,
+        address_n
+      };
+    }
+    if (coinInfo.shortcut === 'TRX' || coinInfo.shortcut === 'tTRX') {
+      const {
+        message
+      } = await typedCall('TronGetAddress', 'TronAddress', {
+        address_n
+      });
+      return {
+        descriptor: message.address,
+        address_n
+      };
+    }
+    throw ERRORS.TypedError('Runtime', 'DeviceCommands.getAccountDescriptor: unsupported coinInfo.type');
+  };
+  return {
+    unlockPath,
+    getPublicKey,
+    getAddress,
+    ethereumGetPublicKey,
+    ethereumGetAddress,
+    getHDNode,
+    preauthorize,
+    getAccountDescriptor,
+    typedCall
+  };
+};