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

package/lib/api/stellar/stellarSignTx.js

@@ -0,0 +1,183 @@
+import { StellarOperation } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { isNotUndefined, throwError } from "@trezor/utils";
+const transformSignMessage = (tx, base) => {
+  if (!tx.timebounds) {
+    throw ERRORS.TypedError('Runtime', 'transformSignMessage: Unspecified timebounds are not supported');
+  }
+  return {
+    ...base,
+    source_account: tx.source,
+    fee: tx.fee,
+    sequence_number: tx.sequence,
+    timebounds_start: tx.timebounds.minTime,
+    timebounds_end: tx.timebounds.maxTime,
+    memo_type: PROTO.StellarMemoType.NONE,
+    num_operations: tx.operations.length,
+    ...(tx.memo && {
+      memo_type: tx.memo.type,
+      memo_text: tx.memo.text,
+      memo_id: tx.memo.id,
+      memo_hash: tx.memo.hash
+    })
+  };
+};
+const transformOperation = op => {
+  Assert(StellarOperation, op);
+  switch (op.type) {
+    case 'createAccount':
+      return {
+        type: 'StellarCreateAccountOp',
+        source_account: op.source,
+        new_account: op.destination,
+        starting_balance: op.startingBalance
+      };
+    case 'payment':
+      return {
+        type: 'StellarPaymentOp',
+        source_account: op.source,
+        destination_account: op.destination,
+        asset: op.asset,
+        amount: op.amount
+      };
+    case 'pathPaymentStrictReceive':
+      return {
+        type: 'StellarPathPaymentStrictReceiveOp',
+        source_account: op.source,
+        send_asset: op.sendAsset,
+        send_max: op.sendMax,
+        destination_account: op.destination,
+        destination_asset: op.destAsset,
+        destination_amount: op.destAmount,
+        paths: op.path
+      };
+    case 'pathPaymentStrictSend':
+      return {
+        type: 'StellarPathPaymentStrictSendOp',
+        source_account: op.source,
+        send_asset: op.sendAsset,
+        send_amount: op.sendAmount,
+        destination_account: op.destination,
+        destination_asset: op.destAsset,
+        destination_min: op.destMin,
+        paths: op.path
+      };
+    case 'createPassiveSellOffer':
+      return {
+        type: 'StellarCreatePassiveSellOfferOp',
+        source_account: op.source,
+        buying_asset: op.buying,
+        selling_asset: op.selling,
+        amount: op.amount,
+        price_n: op.price.n,
+        price_d: op.price.d
+      };
+    case 'manageSellOffer':
+      return {
+        type: 'StellarManageSellOfferOp',
+        source_account: op.source,
+        buying_asset: op.buying,
+        selling_asset: op.selling,
+        amount: op.amount,
+        offer_id: op.offerId || 0,
+        price_n: op.price.n,
+        price_d: op.price.d
+      };
+    case 'manageBuyOffer':
+      return {
+        type: 'StellarManageBuyOfferOp',
+        source_account: op.source,
+        buying_asset: op.buying,
+        selling_asset: op.selling,
+        amount: op.amount,
+        offer_id: op.offerId || 0,
+        price_n: op.price.n,
+        price_d: op.price.d
+      };
+    case 'setOptions':
+      {
+        const signer = op.signer ? {
+          signer_type: op.signer.type,
+          signer_key: op.signer.key,
+          signer_weight: op.signer.weight
+        } : undefined;
+        return {
+          type: 'StellarSetOptionsOp',
+          source_account: op.source,
+          clear_flags: op.clearFlags,
+          set_flags: op.setFlags,
+          master_weight: op.masterWeight,
+          low_threshold: op.lowThreshold,
+          medium_threshold: op.medThreshold,
+          high_threshold: op.highThreshold,
+          home_domain: op.homeDomain,
+          inflation_destination_account: op.inflationDest,
+          ...signer
+        };
+      }
+    case 'changeTrust':
+      return {
+        type: 'StellarChangeTrustOp',
+        source_account: op.source,
+        asset: op.line,
+        limit: op.limit
+      };
+    case 'allowTrust':
+      return {
+        type: 'StellarAllowTrustOp',
+        source_account: op.source,
+        trusted_account: op.trustor,
+        asset_type: op.assetType,
+        asset_code: op.assetCode,
+        is_authorized: !!op.authorize
+      };
+    case 'accountMerge':
+      return {
+        type: 'StellarAccountMergeOp',
+        source_account: op.source,
+        destination_account: op.destination
+      };
+    case 'manageData':
+      return {
+        type: 'StellarManageDataOp',
+        source_account: op.source,
+        key: op.name,
+        value: op.value
+      };
+    case 'bumpSequence':
+      return {
+        type: 'StellarBumpSequenceOp',
+        source_account: op.source,
+        bump_to: op.bumpTo
+      };
+    case 'claimClaimableBalance':
+      return {
+        type: 'StellarClaimClaimableBalanceOp',
+        source_account: op.source,
+        balance_id: op.balanceId
+      };
+  }
+};
+export const stellarSignTx = async (typedCall, address_n, network_passphrase, tx, payment_req) => {
+  const message = transformSignMessage(tx, {
+    address_n,
+    network_passphrase,
+    payment_req
+  });
+  const operations = tx.operations.map(transformOperation).filter(isNotUndefined);
+  await typedCall('StellarSignTx', 'StellarTxOpRequest', message);
+  for (const {
+    type,
+    ...op
+  } of operations.slice(0, -1)) {
+    await typedCall(type, 'StellarTxOpRequest', op);
+  }
+  const {
+    type,
+    ...op
+  } = operations.at(-1) ?? throwError(ERRORS.TypedError('Method_InvalidParameter', `Stellar transaction doesn't include any valid operation.`));
+  const response = await typedCall(type, 'StellarSignedTx', op);
+  return response.message;
+};

package/lib/api/telemetryGet.d.ts

@@ -0,0 +1,14 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class TelemetryGet extends AbstractMethod<'telemetryGet', PROTO.TelemetryGet> {
+  constructor(message: MethodMessage<'telemetryGet'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    min_temp_c?: number | undefined;
+    max_temp_c?: number | undefined;
+    battery_errors?: number | undefined;
+    battery_cycles?: number | undefined;
+  }>;
+}

package/lib/api/telemetryGet.js

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

package/lib/api/tezos/api/index.d.ts

@@ -0,0 +1,3 @@
+export { default as tezosGetAddress } from "./tezosGetAddress.js";
+export { default as tezosGetPublicKey } from "./tezosGetPublicKey.js";
+export { default as tezosSignTransaction } from "./tezosSignTransaction.js";

package/lib/api/tezos/api/index.js

@@ -0,0 +1,3 @@
+export { default as tezosGetAddress } from "./tezosGetAddress.js";
+export { default as tezosGetPublicKey } from "./tezosGetPublicKey.js";
+export { default as tezosSignTransaction } from "./tezosSignTransaction.js";

package/lib/api/tezos/api/tezosGetAddress.d.ts

@@ -0,0 +1,17 @@
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
+import type { MiscGetAddressParams } from "../../common/AbstractMiscGetAddress.js";
+export default class TezosGetAddress extends AbstractMiscGetAddress<'tezosGetAddress'> {
+  constructor(message: MethodMessage<'tezosGetAddress'>);
+  get info(): string;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  };
+  _call({
+    proto
+  }: MiscGetAddressParams): Promise<{
+    mac?: string | undefined;
+    address: string;
+  }>;
+}

package/lib/api/tezos/api/tezosGetAddress.js

@@ -0,0 +1,22 @@
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
+export default class TezosGetAddress extends AbstractMiscGetAddress {
+  constructor(message) {
+    super(message, 3);
+    this.requiredDeviceCapabilities = ['Capability_Tezos'];
+    this.requiredFirmwareCoins = [getMiscNetwork('xtz')];
+  }
+  get info() {
+    return this.getInfo('Tezos', true);
+  }
+  get confirmation() {
+    return this.getConfirmation('Tezos');
+  }
+  async _call({
+    proto
+  }) {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('TezosGetAddress', 'TezosAddress', proto);
+    return response.message;
+  }
+}

package/lib/api/tezos/api/tezosGetPublicKey.d.ts

@@ -0,0 +1,28 @@
+import { 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";
+export default class TezosGetPublicKey extends AbstractMethod<'tezosGetPublicKey', PROTO.TezosGetPublicKey[]> {
+  hasBundle?: boolean;
+  constructor(message: MethodMessage<'tezosGetPublicKey'>);
+  get requiredPermissions(): PermissionRequest[];
+  init(): void;
+  get info(): string;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  };
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    publicKey: string;
+    path: number[];
+    serializedPath: string;
+    displayablePublicKey: string;
+  } | {
+    publicKey: string;
+    path: number[];
+    serializedPath: string;
+    displayablePublicKey: string;
+  }[]>;
+}

package/lib/api/tezos/api/tezosGetPublicKey.js

@@ -0,0 +1,84 @@
+import { Bundle, GetPublicKey as GetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { getSerializedPath, validatePath } from "../../../utils/pathUtils.js";
+import { bundlify } from "../../common/paramsValidator.js";
+export default class TezosGetPublicKey extends AbstractMethod {
+  hasBundle;
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetPublicKeySchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 3);
+      return {
+        address_n: path,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false,
+        chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
+      };
+    });
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.requiredDeviceCapabilities = ['Capability_Tezos'];
+    this.requiredFirmwareCoins = [getMiscNetwork('xtz')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('read_xpub', this.requiredFirmwareCoins);
+  }
+  init() {}
+  get info() {
+    return 'Export Tezos public key';
+  }
+  get confirmation() {
+    if (this.params.length > 1) {
+      return {
+        view: 'export-address',
+        label: 'Export multiple Tezos public keys'
+      };
+    }
+    const {
+      params
+    } = this;
+    const first = params[0];
+    const addressN = first.address_n;
+    const accountIndex = addressN[2];
+    return {
+      view: 'export-address',
+      label: `Export Tezos public key for account #${fromHardenedPathPart(accountIndex) + 1}`
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const {
+        params
+      } = this;
+      const batch = params[i];
+      const {
+        message
+      } = await cmd.typedCall('TezosGetPublicKey', 'TezosPublicKey', batch);
+      responses.push({
+        path: batch.address_n,
+        serializedPath: getSerializedPath(batch.address_n),
+        publicKey: message.public_key,
+        displayablePublicKey: message.public_key
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response: message
+        }));
+      }
+    }
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
+  }
+}

package/lib/api/tezos/api/tezosSignTransaction.d.ts

@@ -0,0 +1,14 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+export default class TezosSignTransaction extends AbstractMethod<'tezosSignTransaction', PROTO.TezosSignTx> {
+  constructor(message: MethodMessage<'tezosSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    signature: string;
+    sig_op_contents: string;
+    operation_hash: string;
+  }>;
+}

package/lib/api/tezos/api/tezosSignTransaction.js

@@ -0,0 +1,30 @@
+import { TezosSignTransaction as TezosSignTransactionSchema } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+import * as helper from "../tezosSignTx.js";
+export default class TezosSignTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(TezosSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 3);
+    const params = helper.createTx(path, payload.branch, payload.operation);
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Tezos'];
+    this.requiredFirmwareCoins = [getMiscNetwork('xtz')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Sign Tezos transaction';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('TezosSignTx', 'TezosSignedTx', this.params);
+    return response.message;
+  }
+}

package/lib/api/tezos/tezosSignTx.d.ts

@@ -0,0 +1,71 @@
+import { TezosOperation } from '@trezor/connect-common';
+import type { PROTO } from '@trezor/connect-common';
+export declare const createTx: (address_n: number[], branch: string, operation: TezosOperation, chunkify?: boolean) => {
+  chunkify?: boolean | undefined;
+  reveal?: {
+    public_key: Uint8Array<ArrayBufferLike>;
+    fee: string | number;
+    gas_limit: number;
+    source: Uint8Array<ArrayBufferLike>;
+    counter: number;
+    storage_limit: number;
+  } | undefined;
+  transaction?: {
+    parameters?: number[] | undefined;
+    parameters_manager?: {
+      transfer?: {
+        amount: string | number;
+        destination: {
+          hash: Uint8Array<ArrayBufferLike>;
+          tag: number;
+        };
+      } | undefined;
+      set_delegate?: Uint8Array<ArrayBufferLike> | undefined;
+      cancel_delegate?: boolean | undefined;
+    } | undefined;
+    amount: string | number;
+    fee: string | number;
+    gas_limit: number;
+    destination: {
+      hash: Uint8Array<ArrayBufferLike>;
+      tag: number;
+    };
+    source: Uint8Array<ArrayBufferLike>;
+    counter: number;
+    storage_limit: number;
+  } | undefined;
+  origination?: {
+    delegate?: Uint8Array<ArrayBufferLike> | undefined;
+    manager_pubkey?: string | undefined;
+    spendable?: boolean | undefined;
+    delegatable?: boolean | undefined;
+    script: string | number[];
+    fee: string | number;
+    gas_limit: number;
+    balance: number;
+    source: Uint8Array<ArrayBufferLike>;
+    counter: number;
+    storage_limit: number;
+  } | undefined;
+  delegation?: {
+    fee: string | number;
+    delegate: Uint8Array<ArrayBufferLike>;
+    gas_limit: number;
+    source: Uint8Array<ArrayBufferLike>;
+    counter: number;
+    storage_limit: number;
+  } | undefined;
+  proposal?: {
+    source: string;
+    period: number;
+    proposals: string[];
+  } | undefined;
+  ballot?: {
+    proposal: string;
+    ballot: PROTO.TezosBallotType;
+    source: string;
+    period: number;
+  } | undefined;
+  address_n: number[];
+  branch: Uint8Array<ArrayBufferLike>;
+};