@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/ethereum/api/ethereumGetPublicKey.d.ts

@@ -1,44 +1,52 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-import type { EthereumNetworkInfo } from '../../../types';
-type Params = PROTO.EthereumGetPublicKey & {
-    network?: EthereumNetworkInfo;
+import { type EthereumNetworkInfo, type PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodContext, MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  proto: PROTO.EthereumGetPublicKey;
+  network?: EthereumNetworkInfo;
 };
 export default class EthereumGetPublicKey extends AbstractMethod<'ethereumGetPublicKey', Params[]> {
-    hasBundle?: boolean;
-    init(): void;
-    get info(): string;
-    get confirmation(): {
-        view: "export-xpub";
-        label: string;
-    };
-    run(): Promise<({
-        path: number[];
-        publicKey: string;
-        serializedPath: string;
-    } & {
-        descriptor?: string | undefined;
-        xpubSegwit?: string | undefined;
-        descriptorChecksum?: string | undefined;
-        depth: number;
-        fingerprint: number;
-        xpub: string;
-        childNum: number;
-        chainCode: string;
-    }) | ({
-        path: number[];
-        publicKey: string;
-        serializedPath: string;
-    } & {
-        descriptor?: string | undefined;
-        xpubSegwit?: string | undefined;
-        descriptorChecksum?: string | undefined;
-        depth: number;
-        fingerprint: number;
-        xpub: string;
-        childNum: number;
-        chainCode: string;
-    })[]>;
+  hasBundle?: boolean;
+  constructor(message: MethodMessage<'ethereumGetPublicKey'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  get confirmation(): {
+    view: "export-xpub";
+    label: string;
+  };
+  run({
+    sendCoreMessage
+  }: MethodContext): 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;
+  }) | ({
+    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;
+  })[]>;
 }
-export {};
-//# sourceMappingURL=ethereumGetPublicKey.d.ts.map
+export {};

package/lib/api/ethereum/api/ethereumGetPublicKey.js

@@ -1,46 +1,52 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const events_1 = require("../../../events");
-const types_1 = require("../../../types");
-const ethereumUtils_1 = require("../../../utils/ethereumUtils");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-class EthereumGetPublicKey extends AbstractMethod_1.AbstractMethod {
+import { Bundle, GetPublicKey as GetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getEthereumNetwork, getUniqueNetworks } from "../../../data/coinInfo.js";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.js";
+import { getSerializedPath, validatePath } from "../../../utils/pathUtils.js";
+import { bundlify } from "../../common/paramsValidator.js";
+export default class EthereumGetPublicKey extends AbstractMethod {
   hasBundle;
-  init() {
-    this.requiredPermissions = ['read'];
-    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
-    this.hasBundle = !!this.payload.bundle;
-    const payload = !this.payload.bundle ? {
-      ...this.payload,
-      bundle: [this.payload]
-    } : this.payload;
-    (0, schema_utils_1.Assert)((0, types_1.Bundle)(types_1.GetPublicKey), payload);
-    this.params = payload.bundle.map(batch => {
-      const path = (0, pathUtils_1.validatePath)(batch.path, 3);
-      const network = (0, coinInfo_1.getEthereumNetwork)(path);
-      this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, network, this.firmwareRange);
-      return {
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetPublicKeySchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 3);
+      const network = getEthereumNetwork(path);
+      const proto = {
         address_n: path,
-        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false
+      };
+      return {
+        proto,
         network
       };
     });
+    super(message, params);
+    this.requiredFirmwareCoins = params.map(({
+      network
+    }) => network);
+    this.hasBundle = hasBundle;
+    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_xpub', this.requiredFirmwareCoins);
   }
   get info() {
     if (this.params.length === 1) {
-      return (0, ethereumUtils_1.getNetworkLabel)('Export #NETWORK public key', this.params[0].network);
+      const {
+        params
+      } = this;
+      const first = params[0];
+      return getNetworkLabel('Export #NETWORK public key', first.network);
     }
     const requestedNetworks = this.params.map(b => b.network);
-    const uniqNetworks = (0, coinInfo_1.getUniqueNetworks)(requestedNetworks);
+    const uniqNetworks = getUniqueNetworks(requestedNetworks);
     if (uniqNetworks.length === 1 && uniqNetworks[0]) {
-      return (0, ethereumUtils_1.getNetworkLabel)('Export multiple #NETWORK public keys', uniqNetworks[0]);
+      return getNetworkLabel('Export multiple #NETWORK public keys', uniqNetworks[0]);
     }
     return 'Export multiple public keys';
   }
@@ -50,39 +56,45 @@ class EthereumGetPublicKey extends AbstractMethod_1.AbstractMethod {
       label: this.info
     };
   }
-  async run() {
+  async run({
+    sendCoreMessage
+  }) {
     const responses = [];
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     for (let i = 0; i < this.params.length; i++) {
+      const {
+        params
+      } = this;
+      const batch = params[i];
       const {
         address_n,
         show_display
-      } = this.params[i];
+      } = batch.proto;
       const publicKey = await cmd.ethereumGetPublicKey({
         address_n,
         show_display
       });
       const response = {
         path: address_n,
-        serializedPath: (0, pathUtils_1.getSerializedPath)(address_n),
+        serializedPath: getSerializedPath(address_n),
         childNum: publicKey.node.child_num,
         xpub: publicKey.xpub,
         chainCode: publicKey.node.chain_code,
         publicKey: publicKey.node.public_key,
         fingerprint: publicKey.node.fingerprint,
-        depth: publicKey.node.depth
+        depth: publicKey.node.depth,
+        displayablePublicKey: publicKey.xpub
       };
       responses.push(response);
       if (this.hasBundle) {
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
           total: this.params.length,
           progress: i,
           response
         }));
       }
     }
-    return this.hasBundle ? responses : responses[0];
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
   }
-}
-exports.default = EthereumGetPublicKey;
-//# sourceMappingURL=ethereumGetPublicKey.js.map
+}

package/lib/api/ethereum/api/ethereumSignMessage.d.ts

@@ -1,24 +1,27 @@
-import { MessagesSchema, MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-import { EthereumNetworkInfo } from '../../../types';
-type Params = PROTO.EthereumSignMessage & {
-    network?: EthereumNetworkInfo;
-    definitions?: MessagesSchema.EthereumDefinitions;
+import type { EthereumNetworkInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema, MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  proto: PROTO.EthereumSignMessage;
+  readableMessage: string;
+  network?: EthereumNetworkInfo;
+  definitions?: MessagesSchema.EthereumDefinitions;
 };
 export default class EthereumSignMessage extends AbstractMethod<'ethereumSignMessage', Params> {
-    init(): void;
-    initAsync(): Promise<void>;
-    get info(): string;
-    getButtonRequestData(code: string, name?: string): {
-        type: "message";
-        coin: string;
-        serializedPath: string;
-        message: string;
-    } | undefined;
-    run(): Promise<{
-        address: string;
-        signature: string;
-    }>;
+  constructor(message: MethodMessage<'ethereumSignMessage'>);
+  get requiredPermissions(): PermissionRequest[];
+  initAsync(): Promise<void>;
+  get info(): string;
+  getButtonRequestData(code: string, name?: string): {
+    type: "message";
+    coin: string;
+    serializedPath: string;
+    message: string;
+  } | undefined;
+  run(): Promise<{
+    address: string;
+    signature: string;
+  }>;
 }
-export {};
-//# sourceMappingURL=ethereumSignMessage.d.ts.map
+export {};

package/lib/api/ethereum/api/ethereumSignMessage.js

@@ -1,70 +1,64 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const types_1 = require("../../../types");
-const ethereumUtils_1 = require("../../../utils/ethereumUtils");
-const formatUtils_1 = require("../../../utils/formatUtils");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-const ethereumDefinitions_1 = require("../ethereumDefinitions");
-class EthereumSignMessage extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
+import { EthereumSignMessage as EthereumSignMessageSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getEthereumNetwork } from "../../../data/coinInfo.js";
+import { validateModelOneMessageSize } from "../../../device/validateMessageSize.js";
+import { getNetworkLabel } from "../../../utils/ethereumUtils.js";
+import { hexToText, messageToHex } from "../../../utils/formatUtils.js";
+import { getSerializedPath, getSlip44ByPath, validatePath } from "../../../utils/pathUtils.js";
+import { getEthereumDefinitions } from "../ethereumDefinitions.js";
+export default class EthereumSignMessage extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(types_1.EthereumSignMessage, payload);
-    const path = (0, pathUtils_1.validatePath)(payload.path, 3);
-    const network = (0, coinInfo_1.getEthereumNetwork)(path);
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, network, this.firmwareRange);
-    const messageHex = payload.hex ? (0, formatUtils_1.messageToHex)(payload.message) : Buffer.from(payload.message, 'utf8').toString('hex');
-    this.params = {
-      address_n: path,
-      message: messageHex
+    } = message;
+    Assert(EthereumSignMessageSchema, payload);
+    const address_n = validatePath(payload.path, 3);
+    const network = getEthereumNetwork(address_n);
+    const messageHex = payload.hex ? messageToHex(payload.message) : Buffer.from(payload.message, 'utf8').toString('hex');
+    const readableMessage = payload.hex ? hexToText(payload.message) : payload.message;
+    const params = {
+      proto: {
+        address_n,
+        message: messageHex
+      },
+      readableMessage
     };
+    super(message, params);
+    this.requiredFirmwareCoins = [network];
+    this.requiredDeviceCapabilities = ['Capability_Ethereum'];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
   }
   async initAsync() {
     if (this.params.network) return;
     const {
       address_n
-    } = this.params;
-    const slip44 = (0, pathUtils_1.getSlip44ByPath)(address_n);
-    this.params.definitions = await (0, ethereumDefinitions_1.getEthereumDefinitions)({
+    } = this.params.proto;
+    const slip44 = getSlip44ByPath(address_n);
+    const definitions = await getEthereumDefinitions({
       slip44
     });
+    this.params.proto.encoded_network = definitions.encoded_network;
   }
   get info() {
-    return (0, ethereumUtils_1.getNetworkLabel)('Sign #NETWORK message', (0, coinInfo_1.getEthereumNetwork)(this.params.address_n));
+    return getNetworkLabel('Sign #NETWORK message', getEthereumNetwork(this.params.proto.address_n));
   }
   getButtonRequestData(code, name) {
     if (code === 'ButtonRequest_Other' && name === 'sign_message') {
       return {
         type: 'message',
         coin: this.params.network?.shortcut ?? 'ETH',
-        serializedPath: (0, pathUtils_1.getSerializedPath)(this.params.address_n),
-        message: this.payload.hex ? (0, formatUtils_1.hexToText)(this.payload.message) : this.payload.message
+        serializedPath: getSerializedPath(this.params.proto.address_n),
+        message: this.params.readableMessage
       };
     }
   }
   async run() {
-    const cmd = this.device.getCommands();
-    const {
-      address_n,
-      message
-    } = this.params;
-    const response = await cmd.typedCall('EthereumSignMessage', 'EthereumMessageSignature', {
-      encoded_network: this.params.definitions?.encoded_network,
-      address_n,
-      message
-    });
+    validateModelOneMessageSize(this.getDevice(), this.params.proto.message);
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('EthereumSignMessage', 'EthereumMessageSignature', this.params.proto);
     return response.message;
   }
-}
-exports.default = EthereumSignMessage;
-//# sourceMappingURL=ethereumSignMessage.js.map
+}

package/lib/api/ethereum/api/ethereumSignTransaction.d.ts

@@ -1,82 +1,83 @@
-import { MessagesSchema } from '@trezor/protobuf';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-import { EthereumNetworkInfoDefinitionValues, TokenInfo } from '../../../types';
-import type { EthereumTransaction, EthereumTransactionEIP1559 } from '../../../types/api/ethereum';
+import type { EthereumNetworkInfoDefinitionValues, EthereumTransaction, EthereumTransactionEIP1559, PermissionRequest, TokenInfo } from '@trezor/connect-common';
+import type { MessagesSchema } from '@trezor/protobuf';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
 type Params = {
-    path: number[];
-    network?: EthereumNetworkInfoDefinitionValues;
-    definitions?: MessagesSchema.EthereumDefinitions;
-    chunkify: boolean;
+  path: number[];
+  network?: EthereumNetworkInfoDefinitionValues;
+  definitions?: MessagesSchema.EthereumDefinitions;
+  chunkify: boolean;
 } & ({
-    type: 'legacy';
-    tx: EthereumTransaction;
+  type: 'legacy';
+  tx: EthereumTransaction;
+  originalTx: EthereumTransaction;
 } | {
-    type: 'eip1559';
-    tx: EthereumTransactionEIP1559;
+  type: 'eip1559';
+  tx: EthereumTransactionEIP1559;
+  originalTx: EthereumTransactionEIP1559;
 });
 export default class EthereumSignTransaction extends AbstractMethod<'ethereumSignTransaction', Params> {
-    init(): void;
-    initAsync(): Promise<void>;
-    get info(): string;
-    payloadToPrecomposed(): Promise<{
-        type: "final";
-        inputs: never[];
-        outputsPermutation: number[];
-        outputs: {
-            address: string;
-            amount: string;
-            script_type: "PAYTOADDRESS";
-        }[];
-        totalSpent: string;
-        fee: string;
-        feePerByte: string;
-        maxFeePerGas: string | undefined;
-        maxPriorityFeePerGas: string | undefined;
-        feeLimit: string;
-        bytes: number;
-        max: undefined;
-        isTokenKnown: boolean;
-        token: TokenInfo | undefined;
-        nativeToken: {
-            type: string;
-            standard: string;
-            contract: string;
-            name: string;
-            symbol: string;
-            decimals: number;
-        } | undefined;
-        network: ({
-            blockchainLink?: {
-                type: string;
-                url: string[];
-            } | undefined;
-            label: string;
-            name: string;
-            shortcut: string;
-            slip44: number;
-            support: {
-                T1B1: string | false;
-                T2T1: string | false;
-                T2B1: string | false;
-                T3B1: string | false;
-                T3T1: string | false;
-                T3W1: string | false;
-                UNKNOWN: string | false;
-                connect: boolean;
-            };
-            decimals: number;
-        } & {
-            network?: undefined;
-            type: "ethereum";
-            chainId: number;
-        }) | undefined;
-    } | undefined>;
-    run(): Promise<{
-        serializedTx: string;
-        v: `0x${string}`;
-        r: `0x${string}`;
-        s: `0x${string}`;
-    }>;
+  constructor(message: MethodMessage<'ethereumSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  initAsync(): Promise<void>;
+  get info(): string;
+  payloadToPrecomposed(): Promise<undefined> | Promise<{
+    type: "final";
+    inputs: never[];
+    outputsPermutation: number[];
+    outputs: {
+      address: string;
+      amount: string;
+      script_type: "PAYTOADDRESS";
+    }[];
+    totalSpent: string;
+    fee: string;
+    feePerByte: string;
+    maxFeePerGas: string | undefined;
+    maxPriorityFeePerGas: string | undefined;
+    feeLimit: string;
+    bytes: number;
+    max: undefined;
+    isTokenKnown: boolean;
+    token: TokenInfo | undefined;
+    nativeToken: {
+      type: string;
+      standard: string;
+      contract: string;
+      name: string;
+      symbol: string;
+      decimals: number;
+    } | undefined;
+    network: ({
+      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;
+    } & {
+      network?: undefined;
+      type: "ethereum";
+      chainId: number;
+    }) | undefined;
+  }>;
+  run(): Promise<{
+    serializedTx: `0x02${string}` | import("viem").TransactionSerializedLegacy;
+    v: `0x${string}`;
+    r: `0x${string}`;
+    s: `0x${string}`;
+  }>;
 }
-export {};
-//# sourceMappingURL=ethereumSignTransaction.d.ts.map
+export {};