@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/getCoinInfo.d.mts

@@ -0,0 +1,148 @@
+import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+type Params = {
+    coinInfo: CoinInfo;
+};
+export default class GetCoinInfo extends AbstractMethod<'getCoinInfo', Params> {
+    constructor(message: MethodMessage<'getCoinInfo'>);
+    get requiredPermissions(): MethodPermission[];
+    run(): Promise<({
+        blockchainLink?: {
+            type: string;
+            url: string[];
+        } | undefined;
+        label: string;
+        name: string;
+        shortcut: string;
+        slip44: number;
+        support: {
+            T1B1: string | false;
+            T2T1: string | false;
+            T3T1: string | false;
+            T2B1: string | false;
+            T3B1: string | false;
+            T3W1: string | false;
+            UNKNOWN: string | false;
+        };
+        decimals: number;
+        blockTime: number;
+        minFee: number;
+        maxFee: number;
+        minPriorityFee: number;
+        defaultFees: {
+            feePerTx?: string | undefined;
+            feeLimit?: string | undefined;
+            baseFeePerGas?: string | undefined;
+            maxFeePerGas?: string | undefined;
+            maxPriorityFeePerGas?: string | undefined;
+            label: "high" | "normal" | "economy" | "low" | "custom";
+            blocks: number;
+            feePerUnit: string;
+        }[];
+    } & {
+        taproot?: boolean | undefined;
+        cashAddrPrefix?: string | undefined;
+        xPubMagicSegwitNative?: number | undefined;
+        xPubMagicSegwit?: number | undefined;
+        type: "bitcoin";
+        curveName: string;
+        dustLimit: number;
+        forceBip143: boolean;
+        hashGenesisBlock: string;
+        maxAddressLength: number;
+        maxFeeSatoshiKb: number;
+        minAddressLength: number;
+        minFeeSatoshiKb: number;
+        segwit: boolean;
+        xPubMagic: number;
+        network: {
+            forkId?: number | undefined;
+            messagePrefix: string;
+            bech32: string;
+            bip32: {
+                public: number;
+                private: number;
+            };
+            pubKeyHash: number;
+            scriptHash: number;
+            wif: number;
+        };
+        isBitcoin: boolean;
+    }) | ({
+        blockchainLink?: {
+            type: string;
+            url: string[];
+        } | undefined;
+        label: string;
+        name: string;
+        shortcut: string;
+        slip44: number;
+        support: {
+            T1B1: string | false;
+            T2T1: string | false;
+            T3T1: string | false;
+            T2B1: string | false;
+            T3B1: string | false;
+            T3W1: string | false;
+            UNKNOWN: string | false;
+        };
+        decimals: number;
+        blockTime: number;
+        minFee: number;
+        maxFee: number;
+        minPriorityFee: number;
+        defaultFees: {
+            feePerTx?: string | undefined;
+            feeLimit?: string | undefined;
+            baseFeePerGas?: string | undefined;
+            maxFeePerGas?: string | undefined;
+            maxPriorityFeePerGas?: string | undefined;
+            label: "high" | "normal" | "economy" | "low" | "custom";
+            blocks: number;
+            feePerUnit: string;
+        }[];
+    } & {
+        network?: undefined;
+        type: "ethereum";
+        chainId: number;
+    }) | ({
+        blockchainLink?: {
+            type: string;
+            url: string[];
+        } | undefined;
+        label: string;
+        name: string;
+        shortcut: string;
+        slip44: number;
+        support: {
+            T1B1: string | false;
+            T2T1: string | false;
+            T3T1: string | false;
+            T2B1: string | false;
+            T3B1: string | false;
+            T3W1: string | false;
+            UNKNOWN: string | false;
+        };
+        decimals: number;
+        blockTime: number;
+        minFee: number;
+        maxFee: number;
+        minPriorityFee: number;
+        defaultFees: {
+            feePerTx?: string | undefined;
+            feeLimit?: string | undefined;
+            baseFeePerGas?: string | undefined;
+            maxFeePerGas?: string | undefined;
+            maxPriorityFeePerGas?: string | undefined;
+            label: "high" | "normal" | "economy" | "low" | "custom";
+            blocks: number;
+            feePerUnit: string;
+        }[];
+    } & {
+        network?: undefined;
+        type: "misc";
+        curve: string;
+    })>;
+}
+export {};

package/libESM/api/getCoinInfo.mjs

@@ -0,0 +1,29 @@
+import { CoinObj } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { getCoinInfo } from "../data/coinInfo.mjs";
+export default class GetCoinInfo extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(CoinObj, payload);
+    const coinInfo = getCoinInfo(payload.coin);
+    if (!coinInfo) {
+      throw ERRORS.TypedError('Method_UnknownCoin');
+    }
+    const params = {
+      coinInfo
+    };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  run() {
+    return Promise.resolve(this.params.coinInfo);
+  }
+}

package/libESM/api/getDeviceState.d.mts

@@ -0,0 +1,8 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class GetDeviceState extends AbstractMethod<'getDeviceState'> {
+    get requiredPermissions(): MethodPermission[];
+    run(): Promise<{
+        state: import("@trezor/connect-common").DeviceState;
+    }>;
+}

package/libESM/api/getDeviceState.mjs

@@ -0,0 +1,16 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class GetDeviceState extends AbstractMethod {
+  get requiredPermissions() {
+    return ['read'];
+  }
+  run() {
+    const state = this.getDevice().getState();
+    if (!state?.staticSessionId) {
+      throw ERRORS.TypedError('Runtime', 'Device state not set');
+    }
+    return Promise.resolve({
+      state
+    });
+  }
+}

package/libESM/api/getFeatures.d.mts

@@ -0,0 +1,70 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class GetFeatures extends AbstractMethod<'getFeatures'> {
+    constructor(message: MethodMessage<'getFeatures'>);
+    get requiredPermissions(): MethodPermission[];
+    checkFirmwareRange(): undefined;
+    run(): Promise<{
+        build_version?: number | undefined;
+        _passphrase_cached?: boolean | undefined;
+        fw_build?: number | undefined;
+        busy?: boolean | undefined;
+        homescreen_format?: "Toif" | "Jpeg" | "ToiG" | undefined;
+        hide_passphrase_from_host?: boolean | undefined;
+        unit_color?: number | undefined;
+        unit_btconly?: boolean | undefined;
+        homescreen_width?: number | undefined;
+        homescreen_height?: number | undefined;
+        bootloader_locked?: boolean | undefined;
+        language_version_matches?: boolean | undefined;
+        unit_packaging?: number | undefined;
+        haptic_feedback?: boolean | undefined;
+        recovery_type?: "NormalRecovery" | "DryRun" | "UnlockRepeatedBackup" | undefined;
+        optiga_sec?: number | undefined;
+        soc?: number | undefined;
+        firmware_corrupted?: boolean | undefined;
+        auto_lock_delay_battery_ms?: number | undefined;
+        led?: boolean | undefined;
+        usb_connected?: boolean | undefined;
+        wireless_connected?: boolean | undefined;
+        capabilities: ("Capability_Bitcoin" | "Capability_Bitcoin_like" | "Capability_Binance" | "Capability_Cardano" | "Capability_Crypto" | "Capability_EOS" | "Capability_Ethereum" | "Capability_Lisk" | "Capability_Monero" | "Capability_NEM" | "Capability_Ripple" | "Capability_Stellar" | "Capability_Tezos" | "Capability_U2F" | "Capability_Shamir" | "Capability_ShamirGroups" | "Capability_PassphraseEntry" | "Capability_Solana" | "Capability_Translations" | "Capability_Brightness" | "Capability_Haptic" | "Capability_BLE" | "Capability_NFC" | "Capability_Tron" | "Capability_N4W1")[];
+        label: string | null;
+        session_id: string | null;
+        vendor: string;
+        major_version: number;
+        minor_version: number;
+        patch_version: number;
+        bootloader_mode: boolean | null;
+        device_id: string | null;
+        pin_protection: boolean | null;
+        passphrase_protection: boolean | null;
+        language: string | null;
+        initialized: boolean | null;
+        revision: string | null;
+        bootloader_hash: string | null;
+        imported: boolean | null;
+        unlocked: boolean | null;
+        firmware_present: boolean | null;
+        backup_availability: "NotAvailable" | "Required" | "Available" | null;
+        flags: number | null;
+        model: string;
+        fw_major: number | null;
+        fw_minor: number | null;
+        fw_patch: number | null;
+        fw_vendor: string | null;
+        unfinished_backup: boolean | null;
+        no_backup: boolean | null;
+        recovery_status: "Nothing" | "Recovery" | "Backup" | null;
+        backup_type: "Bip39" | "Slip39_Basic" | "Slip39_Advanced" | "Slip39_Single_Extendable" | "Slip39_Basic_Extendable" | "Slip39_Advanced_Extendable" | null;
+        sd_card_present: boolean | null;
+        sd_protection: boolean | null;
+        wipe_code_protection: boolean | null;
+        passphrase_always_on_device: boolean | null;
+        safety_checks: "Strict" | "PromptAlways" | "PromptTemporarily" | null;
+        auto_lock_delay_ms: number | null;
+        display_rotation: "North" | "East" | "South" | "West" | null;
+        experimental_features: boolean | null;
+        internal_model: import("@trezor/protobuf/libESM/definitions").DeviceModelInternal;
+    }>;
+}

package/libESM/api/getFeatures.mjs

@@ -0,0 +1,20 @@
+import { UI_REQUEST } from "@trezor/connect-common";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class GetFeatures extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.useUi = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE, UI_REQUEST.BOOTLOADER];
+    this.useDeviceState = false;
+    this.useEmptyPassphrase = true;
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  checkFirmwareRange() {
+    return undefined;
+  }
+  run() {
+    return Promise.resolve(this.getDevice().features);
+  }
+}

package/libESM/api/getFirmwareHash.d.mts

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

package/libESM/api/getFirmwareHash.mjs

@@ -0,0 +1,27 @@
+import { UI_REQUEST } from "@trezor/connect-common";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class GetFirmwareHash extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(PROTO.GetFirmwareHash, payload);
+    const params = {
+      challenge: payload.challenge
+    };
+    super(message, params);
+    this.useEmptyPassphrase = true;
+    this.useDeviceState = false;
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE];
+  }
+  get requiredPermissions() {
+    return ['management'];
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('GetFirmwareHash', 'FirmwareHash', this.params);
+    return response.message;
+  }
+}

package/libESM/api/getNonce.d.mts

@@ -0,0 +1,10 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class GetNonce extends AbstractMethod<'getNonce'> {
+    constructor(message: MethodMessage<'getNonce'>);
+    get requiredPermissions(): MethodPermission[];
+    run(): Promise<{
+        nonce: string;
+    }>;
+}

package/libESM/api/getNonce.mjs

@@ -0,0 +1,16 @@
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class GetNonce extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.useDeviceState = false;
+    this.useEmptyPassphrase = true;
+  }
+  get requiredPermissions() {
+    return ['management'];
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('GetNonce', 'Nonce');
+    return response.message;
+  }
+}

package/libESM/api/getOwnershipId.d.mts

@@ -0,0 +1,15 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class GetOwnershipId extends AbstractMethod<'getOwnershipId', PROTO.GetOwnershipId[]> {
+    constructor(message: MethodMessage<'getOwnershipId'>);
+    hasBundle?: boolean;
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    get confirmation(): {
+        view: "export-address";
+        label: string;
+    };
+    run({ sendCoreMessage }: MethodContext): Promise<import("@trezor/connect-common/libESM/types/api/getOwnershipId").OwnershipId | import("@trezor/connect-common/libESM/types/api/getOwnershipId").OwnershipId[]>;
+}

package/libESM/api/getOwnershipId.mjs

@@ -0,0 +1,79 @@
+import { Bundle, GetOwnershipId as GetOwnershipIdSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { bundlify } from "./common/paramsValidator.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { getBitcoinNetwork } from "../data/coinInfo.mjs";
+import { getScriptType, getSerializedPath, validatePath } from "../utils/pathUtils.mjs";
+export default class GetOwnershipId extends AbstractMethod {
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetOwnershipIdSchema), payload);
+    const preprocessed = payload.bundle.map(batch => {
+      const address_n = validatePath(batch.path, 1);
+      return {
+        batch,
+        address_n,
+        coinInfo: getBitcoinNetwork(batch.coin || address_n)
+      };
+    });
+    const params = preprocessed.map(({
+      batch,
+      address_n,
+      coinInfo
+    }) => {
+      const script_type = batch.scriptType || getScriptType(address_n);
+      return {
+        address_n,
+        coin_name: coinInfo ? coinInfo.name : undefined,
+        multisig: batch.multisig,
+        script_type
+      };
+    });
+    super(message, params);
+    this.requiredFirmwareCoins = preprocessed.map(({
+      coinInfo
+    }) => coinInfo);
+    this.hasBundle = hasBundle;
+  }
+  hasBundle;
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Export ownership id';
+  }
+  get confirmation() {
+    return {
+      view: 'export-address',
+      label: this.params.length > 1 ? 'Export multiple ownership proof ids' : this.info
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const batch = this.params[i];
+      const {
+        message
+      } = await cmd.typedCall('GetOwnershipId', 'OwnershipId', batch);
+      responses.push({
+        ...message,
+        path: batch.address_n,
+        serializedPath: getSerializedPath(batch.address_n)
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response: message
+        }));
+      }
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/libESM/api/getOwnershipProof.d.mts

@@ -0,0 +1,15 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class GetOwnershipProof extends AbstractMethod<'getOwnershipProof', PROTO.GetOwnershipProof[]> {
+    constructor(message: MethodMessage<'getOwnershipProof'>);
+    hasBundle?: boolean;
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    get confirmation(): {
+        view: "export-address";
+        label: string;
+    };
+    run({ sendCoreMessage }: MethodContext): Promise<import("@trezor/connect-common/libESM/types/api/getOwnershipProof").OwnershipProof | import("@trezor/connect-common/libESM/types/api/getOwnershipProof").OwnershipProof[]>;
+}

package/libESM/api/getOwnershipProof.mjs

@@ -0,0 +1,86 @@
+import { Bundle, GetOwnershipProof as GetOwnershipProofSchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { bundlify } from "./common/paramsValidator.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { getBitcoinNetwork } from "../data/coinInfo.mjs";
+import { getScriptType, getSerializedPath, validatePath } from "../utils/pathUtils.mjs";
+export default class GetOwnershipProof extends AbstractMethod {
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetOwnershipProofSchema), payload);
+    const preprocessed = payload.bundle.map(batch => {
+      const address_n = validatePath(batch.path, 1);
+      return {
+        batch,
+        address_n,
+        coinInfo: getBitcoinNetwork(batch.coin || address_n)
+      };
+    });
+    const params = preprocessed.map(({
+      batch,
+      address_n,
+      coinInfo
+    }) => {
+      const script_type = batch.scriptType || getScriptType(address_n);
+      return {
+        address_n,
+        coin_name: coinInfo ? coinInfo.name : undefined,
+        multisig: batch.multisig,
+        script_type,
+        user_confirmation: batch.userConfirmation,
+        ownership_ids: batch.ownershipIds,
+        commitment_data: batch.commitmentData
+      };
+    });
+    super(message, params);
+    this.requiredFirmwareCoins = preprocessed.map(({
+      coinInfo
+    }) => coinInfo);
+    this.preauthorized = payload.bundle.some(batch => batch.preauthorized);
+    this.hasBundle = hasBundle;
+  }
+  hasBundle;
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Export ownership proof';
+  }
+  get confirmation() {
+    return {
+      view: 'export-address',
+      label: this.params.length > 1 ? 'Export multiple ownership proofs' : this.info
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const batch = this.params[i];
+      if (this.preauthorized) {
+        await cmd.preauthorize(true);
+      }
+      const {
+        message
+      } = await cmd.typedCall('GetOwnershipProof', 'OwnershipProof', batch);
+      responses.push({
+        ...message,
+        path: batch.address_n,
+        serializedPath: getSerializedPath(batch.address_n)
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response: message
+        }));
+      }
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/libESM/api/getPublicKey.d.mts

@@ -0,0 +1,50 @@
+import type { BitcoinNetworkInfo, MethodPermission } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+type Params = {
+    proto: PROTO.GetPublicKey;
+    coinInfo?: BitcoinNetworkInfo;
+    suppressBackupWarning?: boolean;
+    unlockPath?: PROTO.UnlockPath;
+};
+export default class GetPublicKey extends AbstractMethod<'getPublicKey', Params[]> {
+    constructor(message: MethodMessage<'getPublicKey'>);
+    hasBundle?: boolean;
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    get confirmation(): {
+        view: "export-xpub";
+        label: string;
+    };
+    run({ sendCoreMessage }: MethodContext): 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;
+    }) | ({
+        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;
+    })[]>;
+}
+export {};