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

package/lib/device/DeviceCommands.d.ts

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

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