@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/ripple/api/rippleSignTransaction.mjs

@@ -0,0 +1,52 @@
+import { RippleSignTransaction as RippleSignTransactionSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { validatePath } from "../../../utils/pathUtils.mjs";
+import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.mjs";
+export default class RippleSignTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(RippleSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 5);
+    const {
+      transaction,
+      chunkify
+    } = payload;
+    const params = {
+      address_n: path,
+      fee: transaction.fee,
+      flags: transaction.flags,
+      sequence: transaction.sequence,
+      last_ledger_sequence: transaction.maxLedgerVersion,
+      payment: {
+        amount: transaction.payment.amount,
+        destination: transaction.payment.destination,
+        destination_tag: transaction.payment.destinationTag
+      },
+      payment_req: payload.payment_req ? encodePaymentRequestAmount(payload.payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT) : undefined,
+      chunkify: typeof chunkify === 'boolean' ? chunkify : false
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Ripple'];
+    this.requiredFirmwareCoins = [getMiscNetwork('Ripple')];
+  }
+  get requiredPermissions() {
+    return ['read', 'write'];
+  }
+  get info() {
+    return 'Sign Ripple transaction';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const {
+      message
+    } = await cmd.typedCall('RippleSignTx', 'RippleSignedTx', this.params);
+    return {
+      serializedTx: message.serialized_tx,
+      signature: message.signature
+    };
+  }
+}

package/libESM/api/setBrightness.d.mts

@@ -0,0 +1,12 @@
+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 SetBrightness extends AbstractMethod<'setBrightness', PROTO.SetBrightness> {
+    constructor(message: MethodMessage<'setBrightness'>);
+    get requiredPermissions(): MethodPermission[];
+    init(): void;
+    run(): Promise<{
+        message: string;
+    }>;
+}

package/libESM/api/setBrightness.mjs

@@ -0,0 +1,26 @@
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class SetBrightness extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(PROTO.SetBrightness, payload);
+    const params = {
+      value: payload.value
+    };
+    super(message, params);
+    this.skipFinalReload = false;
+    this.useDeviceState = false;
+  }
+  get requiredPermissions() {
+    return ['management'];
+  }
+  init() {}
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('SetBrightness', 'Success', this.params);
+    return response.message;
+  }
+}

package/libESM/api/setBusy.d.mts

@@ -0,0 +1,11 @@
+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 SetBusy extends AbstractMethod<'setBusy', PROTO.SetBusy> {
+    constructor(message: MethodMessage<'setBusy'>);
+    get requiredPermissions(): MethodPermission[];
+    run({ sendCoreMessage }: MethodContext): Promise<{
+        message: string;
+    }>;
+}

package/libESM/api/setBusy.mjs

@@ -0,0 +1,32 @@
+import { DEVICE, createDeviceMessage } from "@trezor/connect-common";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class SetBusy extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    const params = {
+      expiry_ms: payload.expiry_ms
+    };
+    super(message, params);
+    this.useDeviceState = false;
+    this.skipFinalReload = false;
+    this.overridePreviousCall = true;
+  }
+  get requiredPermissions() {
+    return ['management'];
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const cmd = this.getDevice().getCommands();
+    const {
+      message
+    } = await cmd.typedCall('SetBusy', 'Success', this.params);
+    if (this.keepSession && !!this.params.expiry_ms) {
+      this.getDevice().features.busy = true;
+      sendCoreMessage(createDeviceMessage(DEVICE.CHANGED, this.getDevice().toMessageObject()));
+    }
+    return message;
+  }
+}

package/libESM/api/showDeviceTutorial.d.mts

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

package/libESM/api/showDeviceTutorial.mjs

@@ -0,0 +1,21 @@
+import { UI_REQUEST } from "@trezor/connect-common";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class ShowDeviceTutorial extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.useEmptyPassphrase = true;
+    this.useDeviceState = false;
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE];
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  get info() {
+    return 'Show device tutorial';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('ShowDeviceTutorial', 'Success');
+    return response.message;
+  }
+}

package/libESM/api/signMessage.d.mts

@@ -0,0 +1,25 @@
+import type { BitcoinNetworkInfo, MethodPermission } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+type Params = {
+    proto: PROTO.SignMessage;
+    readableMessage: string;
+};
+export default class SignMessage extends AbstractMethod<'signMessage', Params> {
+    constructor(message: MethodMessage<'signMessage'>);
+    coinInfo: BitcoinNetworkInfo | undefined;
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    getButtonRequestData(code: string, name?: string): {
+        type: "message";
+        serializedPath: string;
+        coin: string;
+        message: string;
+    } | undefined;
+    run(): Promise<{
+        address: string;
+        signature: string;
+    }>;
+}
+export {};

package/libESM/api/signMessage.mjs

@@ -0,0 +1,71 @@
+import { SignMessage as SignMessageSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { validateCoinPath } from "./common/paramsValidator.mjs";
+import { getBitcoinNetwork } from "../data/coinInfo.mjs";
+import { validateModelOneMessageSize } from "../device/validateMessageSize.mjs";
+import { hexToText, messageToHex } from "../utils/formatUtils.mjs";
+import { getLabel, getScriptType, getSerializedPath, validatePath } from "../utils/pathUtils.mjs";
+export default class SignMessage extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(SignMessageSchema, payload);
+    const path = validatePath(payload.path);
+    let coinInfo;
+    if (payload.coin) {
+      coinInfo = getBitcoinNetwork(payload.coin);
+      validateCoinPath(path, coinInfo);
+    } else {
+      coinInfo = getBitcoinNetwork(path);
+    }
+    const messageHex = payload.hex ? messageToHex(payload.message) : Buffer.from(payload.message, 'utf8').toString('hex');
+    const readableMessage = payload.hex ? hexToText(payload.message) : payload.message;
+    const scriptType = getScriptType(path);
+    const proto = {
+      address_n: path,
+      message: messageHex,
+      coin_name: coinInfo ? coinInfo.name : undefined,
+      script_type: scriptType && scriptType !== 'SPENDMULTISIG' ? scriptType : 'SPENDADDRESS',
+      no_script_type: payload.no_script_type
+    };
+    const params = {
+      proto,
+      readableMessage
+    };
+    super(message, params);
+    this.coinInfo = coinInfo;
+    this.requiredFirmwareCoins = [coinInfo];
+    if (payload.no_script_type) {
+      this.requiredFirmwareCapabilities = ['signMessageNoScriptType'];
+    }
+  }
+  coinInfo;
+  get requiredPermissions() {
+    return ['read', 'write'];
+  }
+  get info() {
+    return getLabel('Sign #NETWORK message', this.coinInfo);
+  }
+  getButtonRequestData(code, name) {
+    if (code === 'ButtonRequest_Other' && name === 'sign_message') {
+      return {
+        type: 'message',
+        serializedPath: getSerializedPath(this.params.proto.address_n),
+        coin: this.coinInfo?.shortcut ?? 'BTC',
+        message: this.params.readableMessage
+      };
+    }
+  }
+  async run() {
+    validateModelOneMessageSize(this.getDevice(), this.params.proto.message);
+    const cmd = this.getDevice().getCommands();
+    const {
+      message
+    } = await cmd.typedCall('SignMessage', 'MessageSignature', this.params.proto);
+    const signatureBuffer = Buffer.from(message.signature, 'hex');
+    message.signature = signatureBuffer.toString('base64');
+    return message;
+  }
+}

package/libESM/api/signTransaction.d.mts

@@ -0,0 +1,197 @@
+import type { AccountAddresses, BitcoinNetworkInfo, MethodPermission, PROTO, RefTransaction, TransactionOptions } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+type Params = {
+    inputs: PROTO.TxInputType[];
+    outputs: PROTO.TxOutputType[];
+    paymentRequests: PROTO.PaymentRequest[];
+    coinjoinRequest?: PROTO.CoinJoinRequest;
+    refTxs?: RefTransaction[];
+    addresses?: AccountAddresses;
+    options: TransactionOptions;
+    coinInfo: BitcoinNetworkInfo;
+    identity?: string;
+    push: boolean;
+    unlockPath?: PROTO.UnlockPath;
+};
+export default class SignTransaction extends AbstractMethod<'signTransaction', Params> {
+    constructor(message: MethodMessage<'signTransaction'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    payloadToPrecomposed(): Promise<undefined> | Promise<{
+        type: "final";
+        inputs: (({
+            sequence?: number | undefined;
+            multisig?: {
+                address_n?: number[] | undefined;
+                nodes?: {
+                    private_key?: string | undefined;
+                    fingerprint: number;
+                    depth: number;
+                    child_num: number;
+                    chain_code: string;
+                    public_key: string;
+                }[] | undefined;
+                pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
+                m: number;
+                pubkeys: {
+                    address_n: number[];
+                    node: string | {
+                        private_key?: string | undefined;
+                        fingerprint: number;
+                        depth: number;
+                        child_num: number;
+                        chain_code: string;
+                        public_key: string;
+                    };
+                }[];
+                signatures: string[];
+            } | undefined;
+            decred_tree?: number | undefined;
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            decred_staking_spend?: PROTO.DecredStakingSpendType | undefined;
+            script_pubkey?: string | undefined;
+            coinjoin_flags?: number | undefined;
+            script_sig?: string | undefined;
+            witness?: string | undefined;
+            ownership_proof?: string | undefined;
+            commitment_data?: string | undefined;
+            prev_hash: string;
+            prev_index: number;
+            amount: string | number;
+        } & {
+            script_type?: "SPENDADDRESS" | "SPENDMULTISIG" | "SPENDWITNESS" | "SPENDP2SHWITNESS" | "SPENDTAPROOT" | undefined;
+            address_n: number[];
+        }) | ({
+            sequence?: number | undefined;
+            multisig?: {
+                address_n?: number[] | undefined;
+                nodes?: {
+                    private_key?: string | undefined;
+                    fingerprint: number;
+                    depth: number;
+                    child_num: number;
+                    chain_code: string;
+                    public_key: string;
+                }[] | undefined;
+                pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
+                m: number;
+                pubkeys: {
+                    address_n: number[];
+                    node: string | {
+                        private_key?: string | undefined;
+                        fingerprint: number;
+                        depth: number;
+                        child_num: number;
+                        chain_code: string;
+                        public_key: string;
+                    };
+                }[];
+                signatures: string[];
+            } | undefined;
+            decred_tree?: number | undefined;
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            decred_staking_spend?: PROTO.DecredStakingSpendType | undefined;
+            script_pubkey?: string | undefined;
+            coinjoin_flags?: number | undefined;
+            script_sig?: string | undefined;
+            witness?: string | undefined;
+            ownership_proof?: string | undefined;
+            commitment_data?: string | undefined;
+            prev_hash: string;
+            prev_index: number;
+            amount: string | number;
+        } & {
+            address_n?: undefined;
+            script_pubkey: string;
+            script_type: "EXTERNAL";
+        }))[];
+        outputs: ({
+            multisig?: {
+                address_n?: number[] | undefined;
+                nodes?: {
+                    private_key?: string | undefined;
+                    fingerprint: number;
+                    depth: number;
+                    child_num: number;
+                    chain_code: string;
+                    public_key: string;
+                }[] | undefined;
+                pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
+                m: number;
+                pubkeys: {
+                    address_n: number[];
+                    node: string | {
+                        private_key?: string | undefined;
+                        fingerprint: number;
+                        depth: number;
+                        child_num: number;
+                        chain_code: string;
+                        public_key: string;
+                    };
+                }[];
+                signatures: string[];
+            } | undefined;
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            address_n?: undefined;
+            script_type?: "PAYTOADDRESS" | undefined;
+            payment_req_index?: number | undefined;
+            amount: string | number;
+            address: string;
+        } | {
+            multisig?: {
+                address_n?: number[] | undefined;
+                nodes?: {
+                    private_key?: string | undefined;
+                    fingerprint: number;
+                    depth: number;
+                    child_num: number;
+                    chain_code: string;
+                    public_key: string;
+                }[] | undefined;
+                pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
+                m: number;
+                pubkeys: {
+                    address_n: number[];
+                    node: string | {
+                        private_key?: string | undefined;
+                        fingerprint: number;
+                        depth: number;
+                        child_num: number;
+                        chain_code: string;
+                        public_key: string;
+                    };
+                }[];
+                signatures: string[];
+            } | undefined;
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            script_type?: "PAYTOADDRESS" | "PAYTOSCRIPTHASH" | "PAYTOMULTISIG" | "PAYTOWITNESS" | "PAYTOP2SHWITNESS" | "PAYTOTAPROOT" | undefined;
+            address?: undefined;
+            payment_req_index?: number | undefined;
+            amount: string | number;
+            address_n: number[];
+        } | {
+            orig_hash?: string | undefined;
+            orig_index?: number | undefined;
+            address_n?: undefined;
+            address?: undefined;
+            payment_req_index?: number | undefined;
+            amount: 0 | "0";
+            script_type: "PAYTOOPRETURN";
+            op_return_data: string;
+        })[];
+        outputsPermutation: number[];
+        totalSpent: string;
+        fee: string;
+        feePerByte: string;
+        bytes: number;
+    }>;
+    private fetchAddresses;
+    private fetchRefTxs;
+    run({ sendCoreMessage }: MethodContext): Promise<import("@trezor/connect-common").SignedTransaction>;
+}
+export {};