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

package/libESM/device/DeviceCommands.d.mts

@@ -1,77 +0,0 @@
-import type { BitcoinNetworkInfo, CoinInfo } from '@trezor/connect-common/libESM/types/coinInfo';
-import type { MessagesSchema as Messages } from '@trezor/protobuf';
-import type { TypedCallProvider } from '../types/typed-call-provider';
-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;
-    } & {
-        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/libESM/device/DeviceCommands.mjs

@@ -1,245 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { getBech32Network, getSegwitNetwork } from "../data/coinInfo.mjs";
-import { resolveDescriptorForTaproot } from "../device/resolveDescriptorForTaproot.mjs";
-import * as hdnodeUtils from "../utils/hdnodeUtils.mjs";
-import { getScriptType, getSerializedPath, isTaprootPath } from "../utils/pathUtils.mjs";
-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 response = {
-      path,
-      serializedPath: getSerializedPath(path),
-      childNum: publicKey.node.child_num,
-      xpub: publicKey.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
-    };
-    if (network !== coinInfo.network) {
-      response.xpubSegwit = response.xpub;
-      response.xpub = hdnodeUtils.convertXpub(publicKey.xpub, network, coinInfo.network);
-    }
-    if (isTaprootPath(path)) {
-      const {
-        checksum,
-        xpub: xpubSegwit
-      } = resolveDescriptorForTaproot({
-        response,
-        publicKey
-      });
-      response.xpubSegwit = xpubSegwit;
-      response.descriptorChecksum = checksum;
-    }
-    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 && 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
-  };
-};