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

package/lib/api/tezos/tezosSignTx.js

@@ -0,0 +1,204 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+import { base58check as createBase58check } from "@scure/base";
+import { TezosOperation } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { Assert } from "@trezor/schema-utils";
+const bs58check = createBase58check(sha256);
+const PREFIX = {
+  B: new Uint8Array([1, 52]),
+  tz1: new Uint8Array([6, 161, 159]),
+  tz2: new Uint8Array([6, 161, 161]),
+  tz3: new Uint8Array([6, 161, 164]),
+  KT1: new Uint8Array([2, 90, 121]),
+  edpk: new Uint8Array([13, 15, 37, 217]),
+  sppk: new Uint8Array([3, 254, 226, 86]),
+  p2pk: new Uint8Array([3, 178, 139, 127])
+};
+const bs58checkDecode = (prefix, enc) => bs58check.decode(enc).slice(prefix.length);
+const concatArray = (first, second) => {
+  const result = new Uint8Array(first.length + second.length);
+  result.set(first);
+  result.set(second, first.length);
+  return result;
+};
+const publicKeyHash2buffer = publicKeyHash => {
+  switch (publicKeyHash.substring(0, 3)) {
+    case 'tz1':
+      return {
+        originated: 0,
+        hash: concatArray(new Uint8Array([0]), bs58checkDecode(PREFIX.tz1, publicKeyHash))
+      };
+    case 'tz2':
+      return {
+        originated: 0,
+        hash: concatArray(new Uint8Array([1]), bs58checkDecode(PREFIX.tz2, publicKeyHash))
+      };
+    case 'tz3':
+      return {
+        originated: 0,
+        hash: concatArray(new Uint8Array([2]), bs58checkDecode(PREFIX.tz3, publicKeyHash))
+      };
+    case 'KT1':
+      return {
+        originated: 1,
+        hash: concatArray(bs58checkDecode(PREFIX.KT1, publicKeyHash), new Uint8Array([0]))
+      };
+    default:
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Wrong Tezos publicKeyHash address');
+  }
+};
+const publicKey2buffer = publicKey => {
+  switch (publicKey.substring(0, 4)) {
+    case 'edpk':
+      return concatArray(new Uint8Array([0]), bs58checkDecode(PREFIX.edpk, publicKey));
+    case 'sppk':
+      return concatArray(new Uint8Array([1]), bs58checkDecode(PREFIX.sppk, publicKey));
+    case 'p2pk':
+      return concatArray(new Uint8Array([2]), bs58checkDecode(PREFIX.p2pk, publicKey));
+    default:
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Wrong Tezos publicKey');
+  }
+};
+export const createTx = (address_n, branch, operation, chunkify) => {
+  let message = {
+    address_n,
+    branch: bs58checkDecode(PREFIX.B, branch),
+    chunkify: typeof chunkify === 'boolean' ? chunkify : false
+  };
+  Assert(TezosOperation, operation);
+  if (operation.reveal) {
+    const {
+      reveal
+    } = operation;
+    message = {
+      ...message,
+      reveal: {
+        source: publicKeyHash2buffer(reveal.source).hash,
+        public_key: publicKey2buffer(reveal.public_key),
+        fee: reveal.fee,
+        counter: reveal.counter,
+        gas_limit: reveal.gas_limit,
+        storage_limit: reveal.storage_limit
+      }
+    };
+  }
+  if (operation.transaction) {
+    const {
+      transaction
+    } = operation;
+    message = {
+      ...message,
+      transaction: {
+        source: publicKeyHash2buffer(transaction.source).hash,
+        destination: {
+          tag: publicKeyHash2buffer(transaction.destination).originated,
+          hash: publicKeyHash2buffer(transaction.destination).hash
+        },
+        amount: transaction.amount,
+        counter: transaction.counter,
+        fee: transaction.fee,
+        gas_limit: transaction.gas_limit,
+        storage_limit: transaction.storage_limit
+      }
+    };
+    if (Object.prototype.hasOwnProperty.call(transaction, 'parameters')) {
+      message = {
+        ...message,
+        transaction: {
+          ...message.transaction,
+          parameters: transaction.parameters
+        }
+      };
+    }
+    if (transaction.parameters_manager) {
+      const {
+        parameters_manager
+      } = transaction;
+      if (parameters_manager.set_delegate) {
+        message = {
+          ...message,
+          transaction: {
+            ...message.transaction,
+            parameters_manager: {
+              set_delegate: publicKeyHash2buffer(parameters_manager.set_delegate).hash
+            }
+          }
+        };
+      }
+      if (Object.prototype.hasOwnProperty.call(parameters_manager, 'cancel_delegate')) {
+        message = {
+          ...message,
+          transaction: {
+            ...message.transaction,
+            parameters_manager: {
+              cancel_delegate: true
+            }
+          }
+        };
+      }
+      if (parameters_manager.transfer) {
+        const {
+          transfer
+        } = parameters_manager;
+        message = {
+          ...message,
+          transaction: {
+            ...message.transaction,
+            parameters_manager: {
+              transfer: {
+                destination: {
+                  tag: publicKeyHash2buffer(transfer.destination).originated,
+                  hash: publicKeyHash2buffer(transfer.destination).hash
+                },
+                amount: transfer.amount
+              }
+            }
+          }
+        };
+      }
+    }
+  }
+  if (operation.origination) {
+    const {
+      origination
+    } = operation;
+    message = {
+      ...message,
+      origination: {
+        source: publicKeyHash2buffer(origination.source).hash,
+        balance: origination.balance,
+        fee: origination.fee,
+        counter: origination.counter,
+        gas_limit: origination.gas_limit,
+        storage_limit: origination.storage_limit,
+        script: origination.script
+      }
+    };
+    if (origination.delegate) {
+      message = {
+        ...message,
+        origination: {
+          ...message.origination,
+          delegate: publicKeyHash2buffer(origination.delegate).hash
+        }
+      };
+    }
+  }
+  if (operation.delegation) {
+    const {
+      delegation
+    } = operation;
+    message = {
+      ...message,
+      delegation: {
+        source: publicKeyHash2buffer(delegation.source).hash,
+        delegate: publicKeyHash2buffer(delegation.delegate).hash,
+        fee: delegation.fee,
+        counter: delegation.counter,
+        gas_limit: delegation.gas_limit,
+        storage_limit: delegation.storage_limit
+      }
+    };
+  }
+  return message;
+};

package/lib/api/thpGetCredentials.d.ts

@@ -0,0 +1,13 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+export default class ThpGetCredentials extends AbstractMethod<'thpGetCredentials'> {
+  constructor(message: MethodMessage<'thpGetCredentials'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    autoconnect: boolean;
+    host_static_key: string;
+    trezor_static_public_key: string;
+    credential: string;
+  }>;
+}

package/lib/api/thpGetCredentials.js

@@ -0,0 +1,30 @@
+import { DEVICE, UI_REQUEST } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import * as settingsStore from "../data/settingsStore.js";
+import { getThpCredentials } from "../device/thp/index.js";
+export default class ThpGetCredentials extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
+    this.useDeviceState = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
+  }
+  async run() {
+    const thpState = this.getDevice().getThpState();
+    if (!thpState?.handshakeCredentials) {
+      throw ERRORS.TypedError('Device_ThpStateMissing');
+    }
+    const credentials = await getThpCredentials(this.getDevice(), true);
+    thpState.setPairingCredentials([credentials]);
+    settingsStore.get('thp')?.knownCredentials?.push(credentials);
+    this.getDevice().emit(DEVICE.THP_CREDENTIALS_CHANGED, {
+      credentials
+    });
+    return credentials;
+  }
+}

package/lib/api/thpRemoveCredentials.d.ts

@@ -0,0 +1,15 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { ThpCredentials } from '@trezor/protocol';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+type Params = {
+  credentials: ThpCredentials[];
+};
+export default class ThpRemoveCredentials extends AbstractMethod<'thpRemoveCredentials', Params> {
+  constructor(message: MethodMessage<'thpRemoveCredentials'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    message: string;
+  }>;
+}
+export {};

package/lib/api/thpRemoveCredentials.js

@@ -0,0 +1,44 @@
+import { UI_REQUEST } from "@trezor/connect-common";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import * as settingsStore from "../data/settingsStore.js";
+export default class ThpRemoveCredentials extends AbstractMethod {
+  constructor(message) {
+    const params = {
+      credentials: message.payload.credentials || []
+    };
+    super(message, params);
+    this.useDevice = message.payload.device !== undefined;
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
+    this.useDeviceState = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
+  }
+  run() {
+    const requestedCredentials = this.params.credentials;
+    if (this.useDevice) {
+      const thpState = this.getDevice().getThpState();
+      if (thpState) {
+        requestedCredentials.push(...thpState.pairingCredentials);
+        thpState.resetState();
+      }
+    }
+    const credentialsMap = new Map(requestedCredentials.map(c => [c.credential, c]));
+    const knownCredentials = settingsStore.get('thp')?.knownCredentials;
+    if (knownCredentials && knownCredentials.length > 0) {
+      credentialsMap.forEach(c => {
+        let index;
+        while ((index = knownCredentials.findIndex(({
+          credential
+        }) => c.credential === credential)) >= 0) {
+          knownCredentials.splice(index, 1);
+        }
+      });
+    }
+    return Promise.resolve({
+      message: 'Success'
+    });
+  }
+}

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

@@ -0,0 +1,3 @@
+export { default as tronComposeTransaction } from "./tronComposeTransaction.js";
+export { default as tronGetAddress } from "./tronGetAddress.js";
+export { default as tronSignTransaction } from "./tronSignTransaction.js";

package/lib/api/tron/api/index.js

@@ -0,0 +1,3 @@
+export { default as tronComposeTransaction } from "./tronComposeTransaction.js";
+export { default as tronGetAddress } from "./tronGetAddress.js";
+export { default as tronSignTransaction } from "./tronSignTransaction.js";

package/lib/api/tron/api/tronComposeTransaction.d.ts

@@ -0,0 +1,17 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import { TronComposeTransaction as TronComposeTransactionSchema } from '@trezor/connect-common';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+export default class TronComposeTransaction extends AbstractMethod<'tronComposeTransaction', TronComposeTransactionSchema> {
+  constructor(message: MethodMessage<'tronComposeTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    rawDataHex: string;
+    ref_block_bytes: string;
+    ref_block_hash: string;
+    expiration: number;
+    timestamp: number;
+    bandwidth: number;
+  }>;
+}

package/lib/api/tron/api/tronComposeTransaction.js

@@ -0,0 +1,52 @@
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { TronComposeTransaction as TronComposeTransactionSchema } from "@trezor/connect-common";
+import { TRON_BANDWIDTH_FORMULA_OVERHEAD } from "@trezor/network-tron/constants";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { encodeTronContractRawData } from "../tronEncode.js";
+export default class TronComposeTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(TronComposeTransactionSchema, payload);
+    super(message, payload);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  get info() {
+    return 'Compose Tron transaction';
+  }
+  async run() {
+    const {
+      contract,
+      blockHash,
+      blockHeight,
+      fee_limit,
+      data
+    } = this.params;
+    const ref_block_bytes = blockHeight.toString(16).padStart(16, '0').slice(12, 16);
+    const ref_block_hash = blockHash.replace(/^0x/, '').slice(16, 32);
+    const timestamp = Date.now();
+    const expiration = timestamp + 60 * 60 * 1000;
+    const rawData = encodeTronContractRawData(contract, {
+      ref_block_bytes,
+      ref_block_hash,
+      expiration,
+      timestamp,
+      fee_limit,
+      data
+    });
+    return {
+      rawDataHex: bytesToHex(rawData),
+      ref_block_bytes,
+      ref_block_hash,
+      expiration,
+      timestamp,
+      bandwidth: rawData.length + TRON_BANDWIDTH_FORMULA_OVERHEAD
+    };
+  }
+}

package/lib/api/tron/api/tronGetAddress.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 TronGetAddress extends AbstractMiscGetAddress<'tronGetAddress'> {
+  constructor(message: MethodMessage<'tronGetAddress'>);
+  get info(): string;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  };
+  _call({
+    proto
+  }: MiscGetAddressParams): Promise<{
+    mac?: string | undefined;
+    address: string;
+  }>;
+}

package/lib/api/tron/api/tronGetAddress.js

@@ -0,0 +1,22 @@
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
+export default class TronGetAddress extends AbstractMiscGetAddress {
+  constructor(message) {
+    super(message, 2);
+    this.requiredDeviceCapabilities = ['Capability_Tron'];
+    this.requiredFirmwareCoins = [getMiscNetwork('trx')];
+  }
+  get info() {
+    return this.getInfo('Tron', false);
+  }
+  get confirmation() {
+    return this.getConfirmation('Tron');
+  }
+  async _call({
+    proto
+  }) {
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('TronGetAddress', 'TronAddress', proto);
+    return response.message;
+  }
+}

package/lib/api/tron/api/tronSignTransaction.d.ts

@@ -0,0 +1,20 @@
+import type { PROTO, PermissionRequest, TronContracts } from '@trezor/connect-common';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+type Params = {
+  tx: PROTO.TronSignTx;
+  contract: TronContracts;
+};
+export default class TronSignTransaction extends AbstractMethod<'tronSignTransaction', Params> {
+  hasBundle?: boolean;
+  progress: number;
+  constructor(message: MethodMessage<'tronSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    signature: string;
+    serializedTx: string | undefined;
+    rawDataHex: string | undefined;
+  }>;
+}
+export {};

package/lib/api/tron/api/tronSignTransaction.js

@@ -0,0 +1,137 @@
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { TronSignTransaction as TronSignTransactionSchema } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+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 { encodeTronContractRawData } from "../tronEncode.js";
+import { encodeBroadcastTransaction } from "../tronProtobuf.js";
+const transformContract = input => {
+  switch (input.type) {
+    case 'FreezeBalanceV2Contract':
+      {
+        const {
+          value
+        } = input.parameter;
+        return {
+          type: 'FreezeBalanceV2Contract',
+          parameter: {
+            value: {
+              owner_address: value.owner_address,
+              balance: 'frozen_balance' in value ? value.frozen_balance : value.balance,
+              resource: value.resource
+            }
+          }
+        };
+      }
+    case 'UnfreezeBalanceV2Contract':
+      {
+        const {
+          value
+        } = input.parameter;
+        return {
+          type: 'UnfreezeBalanceV2Contract',
+          parameter: {
+            value: {
+              owner_address: value.owner_address,
+              balance: 'unfreeze_balance' in value ? value.unfreeze_balance : value.balance,
+              resource: value.resource
+            }
+          }
+        };
+      }
+    case 'VoteWitnessContract':
+      {
+        const {
+          value
+        } = input.parameter;
+        return {
+          type: 'VoteWitnessContract',
+          parameter: {
+            value: {
+              owner_address: value.owner_address,
+              votes: value.votes.map(vote => ({
+                address: 'vote_address' in vote ? vote.vote_address : vote.address,
+                count: 'vote_count' in vote ? vote.vote_count : vote.count
+              }))
+            }
+          }
+        };
+      }
+    case 'TransferContract':
+    case 'TriggerSmartContract':
+    case 'WithdrawExpireUnfreezeContract':
+    case 'WithdrawBalanceContract':
+      return input;
+  }
+};
+const contractMapping = {
+  TransferContract: 'TronTransferContract',
+  TriggerSmartContract: 'TronTriggerSmartContract',
+  FreezeBalanceV2Contract: 'TronFreezeBalanceV2Contract',
+  UnfreezeBalanceV2Contract: 'TronUnfreezeBalanceV2Contract',
+  WithdrawExpireUnfreezeContract: 'TronWithdrawUnfreeze',
+  WithdrawBalanceContract: 'TronWithdrawBalance',
+  VoteWitnessContract: 'TronVoteWitnessContract'
+};
+export default class TronSignTransaction extends AbstractMethod {
+  hasBundle;
+  progress = 0;
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    const contractType = payload.contract?.[0]?.type;
+    if (!contractType || !(contractType in contractMapping)) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Unsupported Tron contract type: ${contractType ?? 'undefined'}`);
+    }
+    Assert(TronSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 3);
+    const payloadContracts = payload.contract;
+    const firstContract = payloadContracts[0];
+    const contract = transformContract(firstContract);
+    const params = {
+      tx: {
+        address_n: path,
+        ref_block_bytes: payload.ref_block_bytes,
+        ref_block_hash: payload.ref_block_hash,
+        expiration: payload.expiration,
+        timestamp: payload.timestamp,
+        fee_limit: payload.fee_limit,
+        data: payload.data
+      },
+      contract
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Tron'];
+    this.requiredFirmwareCoins = [getMiscNetwork('trx')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
+  }
+  get info() {
+    return 'Sign Tron transaction';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    await cmd.typedCall('TronSignTx', 'TronContractRequest', this.params.tx);
+    const {
+      message
+    } = await cmd.typedCall(contractMapping[this.params.contract.type], 'TronSignature', this.params.contract.parameter.value);
+    const {
+      signature
+    } = message;
+    let serializedTx;
+    let rawDataHex;
+    try {
+      rawDataHex = bytesToHex(encodeTronContractRawData(this.params.contract, this.params.tx));
+      serializedTx = encodeBroadcastTransaction(rawDataHex, signature);
+    } catch {}
+    return {
+      signature,
+      serializedTx,
+      rawDataHex
+    };
+  }
+}

package/lib/api/tron/tronEncode.d.ts

@@ -0,0 +1,11 @@
+import type { TronContracts } from '@trezor/connect-common';
+type BlockParams = {
+  ref_block_bytes: string;
+  ref_block_hash: string;
+  expiration: number;
+  timestamp: number;
+  fee_limit?: number;
+  data?: string;
+};
+export declare const encodeTronContractRawData: (contract: TronContracts, blockParams: BlockParams) => Uint8Array;
+export {};