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

package/lib/api/tezos/tezosSignTx.js

@@ -1,204 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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 {};