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

package/libESM/api/tezos/api/tezosGetPublicKey.d.mts

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

package/libESM/api/tezos/api/tezosGetPublicKey.mjs

@@ -1,66 +0,0 @@
-import { Bundle, GetPublicKey as GetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
-import { getMiscNetwork } from "../../../data/coinInfo.mjs";
-import { fromHardened, getSerializedPath, validatePath } from "../../../utils/pathUtils.mjs";
-import { bundlify } from "../../common/paramsValidator.mjs";
-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('Tezos')];
-  }
-  get requiredPermissions() {
-    return ['read'];
-  }
-  init() {}
-  get info() {
-    return 'Export Tezos public key';
-  }
-  get confirmation() {
-    return {
-      view: 'export-address',
-      label: this.params.length > 1 ? 'Export multiple Tezos public keys' : `Export Tezos public key for account #${fromHardened(this.params[0].address_n[2]) + 1}`
-    };
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const responses = [];
-    const cmd = this.getDevice().getCommands();
-    for (let i = 0; i < this.params.length; i++) {
-      const batch = this.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
-      });
-      if (this.hasBundle) {
-        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
-          total: this.params.length,
-          progress: i,
-          response: message
-        }));
-      }
-    }
-    return this.hasBundle ? responses : responses[0];
-  }
-}

package/libESM/api/tezos/api/tezosSignTransaction.d.mts

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

package/libESM/api/tezos/api/tezosSignTransaction.mjs

@@ -1,30 +0,0 @@
-import { TezosSignTransaction as TezosSignTransactionSchema } from "@trezor/connect-common/libESM/types/api/tezos/index.mjs";
-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 * as helper from "../tezosSignTx.mjs";
-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('Tezos')];
-  }
-  get requiredPermissions() {
-    return ['read', 'write'];
-  }
-  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/libESM/api/tezos/tezosSignTx.d.mts

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

package/libESM/api/tezos/tezosSignTx.mjs

@@ -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/libESM/constants/index.mjs";
-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/libESM/api/thpGetCredentials.d.mts

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

package/libESM/api/thpGetCredentials.mjs

@@ -1,28 +0,0 @@
-import { DEVICE, UI_REQUEST } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import * as settingsStore from "../data/settingsStore.mjs";
-import { getThpCredentials } from "../device/thp/index.mjs";
-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 ['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/libESM/api/thpRemoveCredentials.d.mts

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

package/libESM/api/thpRemoveCredentials.mjs

@@ -1,42 +0,0 @@
-import { UI_REQUEST } from "@trezor/connect-common";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import * as settingsStore from "../data/settingsStore.mjs";
-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 ['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/libESM/api/tron/api/index.d.mts

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

package/libESM/api/tron/api/index.mjs

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

package/libESM/api/tron/api/tronComposeTransaction.d.mts

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

package/libESM/api/tron/api/tronComposeTransaction.mjs

@@ -1,51 +0,0 @@
-import { bytesToHex } from "@noble/hashes/utils.js";
-import { TronComposeTransaction as TronComposeTransactionSchema } from "@trezor/connect-common/libESM/types/api/tron/index.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
-import { TRON_BANDWIDTH_FORMULA_OVERHEAD, encodeTronContractRawData } from "../tronEncode.mjs";
-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/libESM/api/tron/api/tronGetAddress.d.mts

@@ -1,15 +0,0 @@
-import type { MethodMessage } from '../../../core/AbstractMethod';
-import { AbstractMiscGetAddress } from '../../common/AbstractMiscGetAddress';
-import type { MiscGetAddressParams } from '../../common/AbstractMiscGetAddress';
-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/libESM/api/tron/api/tronGetAddress.mjs

@@ -1,20 +0,0 @@
-import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.mjs";
-export default class TronGetAddress extends AbstractMiscGetAddress {
-  constructor(message) {
-    super(message, 2);
-    this.requiredDeviceCapabilities = ['Capability_Tron'];
-  }
-  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/libESM/api/tron/api/tronSignTransaction.d.mts

@@ -1,19 +0,0 @@
-import type { MethodPermission, PROTO, TronContracts } from '@trezor/connect-common';
-import type { MethodMessage } from '../../../core/AbstractMethod';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-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(): MethodPermission[];
-    get info(): string;
-    run(): Promise<{
-        signature: string;
-        serializedTx: string | undefined;
-    }>;
-}
-export {};