@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/eos/eosSignTx.d.ts

@@ -1,175 +0,0 @@
-import { PROTO } from '../../constants';
-import type { TypedCall } from '../../device/DeviceCommands';
-import type { EosSDKTransaction } from '../../types/api/eos';
-export declare const validate: (tx: EosSDKTransaction) => {
-    chain_id: string;
-    header: {
-        expiration: number;
-        ref_block_num: number;
-        ref_block_prefix: number;
-        max_net_usage_words: number;
-        max_cpu_usage_ms: number;
-        delay_sec: number;
-    };
-    ack: {
-        unknown?: {
-            data_size: number;
-            data_chunk: string;
-        } | undefined;
-        transfer?: {
-            sender: string;
-            receiver: string;
-            quantity: {
-                symbol: string;
-                amount: string | number;
-            };
-            memo: string;
-        } | undefined;
-        delegate?: {
-            sender: string;
-            receiver: string;
-            net_quantity: {
-                symbol: string;
-                amount: string | number;
-            };
-            cpu_quantity: {
-                symbol: string;
-                amount: string | number;
-            };
-            transfer: boolean;
-        } | undefined;
-        undelegate?: {
-            sender: string;
-            receiver: string;
-            net_quantity: {
-                symbol: string;
-                amount: string | number;
-            };
-            cpu_quantity: {
-                symbol: string;
-                amount: string | number;
-            };
-        } | undefined;
-        refund?: {
-            owner: string;
-        } | undefined;
-        buy_ram?: {
-            receiver: string;
-            quantity: {
-                symbol: string;
-                amount: string | number;
-            };
-            payer: string;
-        } | undefined;
-        buy_ram_bytes?: {
-            receiver: string;
-            payer: string;
-            bytes: number;
-        } | undefined;
-        sell_ram?: {
-            account: string;
-            bytes: number;
-        } | undefined;
-        vote_producer?: {
-            voter: string;
-            proxy: string;
-            producers: string[];
-        } | undefined;
-        update_auth?: {
-            permission: string;
-            account: string;
-            parent: string;
-            auth: {
-                keys: {
-                    type?: number | undefined;
-                    address_n?: number[] | undefined;
-                    weight: number;
-                    key: string;
-                }[];
-                threshold: number;
-                accounts: {
-                    weight: number;
-                    account: {
-                        actor: string;
-                        permission: string;
-                    };
-                }[];
-                waits: {
-                    weight: number;
-                    wait_sec: number;
-                }[];
-            };
-        } | undefined;
-        delete_auth?: {
-            permission: string;
-            account: string;
-        } | undefined;
-        link_auth?: {
-            code: string;
-            type: string;
-            account: string;
-            requirement: string;
-        } | undefined;
-        unlink_auth?: {
-            code: string;
-            type: string;
-            account: string;
-        } | undefined;
-        new_account?: {
-            name: string;
-            owner: {
-                keys: {
-                    type?: number | undefined;
-                    address_n?: number[] | undefined;
-                    weight: number;
-                    key: string;
-                }[];
-                threshold: number;
-                accounts: {
-                    weight: number;
-                    account: {
-                        actor: string;
-                        permission: string;
-                    };
-                }[];
-                waits: {
-                    weight: number;
-                    wait_sec: number;
-                }[];
-            };
-            creator: string;
-            active: {
-                keys: {
-                    type?: number | undefined;
-                    address_n?: number[] | undefined;
-                    weight: number;
-                    key: string;
-                }[];
-                threshold: number;
-                accounts: {
-                    weight: number;
-                    account: {
-                        actor: string;
-                        permission: string;
-                    };
-                }[];
-                waits: {
-                    weight: number;
-                    wait_sec: number;
-                }[];
-            };
-        } | undefined;
-        common: {
-            name: string;
-            account: string;
-            authorization: {
-                actor: string;
-                permission: string;
-            }[];
-        };
-    }[];
-};
-export declare const signTx: (typedCall: TypedCall, address_n: number[], chain_id: string, header: PROTO.EosTxHeader, actions: PROTO.EosTxActionAck[], chunkify: boolean) => Promise<{
-    signature: string;
-}>;
-//# sourceMappingURL=eosSignTx.d.ts.map

package/lib/api/eos/eosSignTx.js

@@ -1,344 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.signTx = exports.validate = void 0;
-const tslib_1 = require("tslib");
-const bs58_1 = tslib_1.__importDefault(require("bs58"));
-const constants_1 = require("../../constants");
-const binaryToDecimal = (bignum, minDigits = 1) => {
-  const result = Array(minDigits).fill('0'.charCodeAt(0));
-  for (let i = bignum.length - 1; i >= 0; --i) {
-    let carry = bignum[i];
-    for (let j = 0; j < result.length; ++j) {
-      const x = (result[j] - '0'.charCodeAt(0) << 8) + carry;
-      result[j] = '0'.charCodeAt(0) + x % 10;
-      carry = x / 10 | 0;
-    }
-    while (carry) {
-      result.push('0'.charCodeAt(0) + carry % 10);
-      carry = carry / 10 | 0;
-    }
-  }
-  result.reverse();
-  return String.fromCharCode(...result);
-};
-const serialize = s => {
-  if (typeof s !== 'string') {
-    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Eos serialization error, "${typeof s}" should be a string`);
-  }
-  const charToSymbol = c => {
-    if (c >= 'a'.charCodeAt(0) && c <= 'z'.charCodeAt(0)) {
-      return c - 'a'.charCodeAt(0) + 6;
-    }
-    if (c >= '1'.charCodeAt(0) && c <= '5'.charCodeAt(0)) {
-      return c - '1'.charCodeAt(0) + 1;
-    }
-    return 0;
-  };
-  const a = new Uint8Array(8);
-  let bit = 63;
-  for (let i = 0; i < s.length; ++i) {
-    let c = charToSymbol(s.charCodeAt(i));
-    if (bit < 5) {
-      c <<= 1;
-    }
-    for (let j = 4; j >= 0; --j) {
-      if (bit >= 0) {
-        a[Math.floor(bit / 8)] |= (c >> j & 1) << bit % 8;
-        --bit;
-      }
-    }
-  }
-  return binaryToDecimal(a);
-};
-const parseQuantity = s => {
-  if (typeof s !== 'string') {
-    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Eos serialization error. Expected string containing asset, got: ${typeof s}`);
-  }
-  s = s.trim();
-  let pos = 0;
-  let amount = '';
-  let precision = 0;
-  if (s[pos] === '-') {
-    amount += '-';
-    ++pos;
-  }
-  let foundDigit = false;
-  while (pos < s.length && s.charCodeAt(pos) >= '0'.charCodeAt(0) && s.charCodeAt(pos) <= '9'.charCodeAt(0)) {
-    foundDigit = true;
-    amount += s[pos];
-    ++pos;
-  }
-  if (!foundDigit) {
-    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Eos serialization error. Asset must begin with a number');
-  }
-  if (s[pos] === '.') {
-    ++pos;
-    while (pos < s.length && s.charCodeAt(pos) >= '0'.charCodeAt(0) && s.charCodeAt(pos) <= '9'.charCodeAt(0)) {
-      amount += s[pos];
-      ++precision;
-      ++pos;
-    }
-  }
-  const symbol = s.substring(pos).trim();
-  const a = [precision & 0xff];
-  for (let i = 0; i < symbol.length; ++i) {
-    a.push(symbol.charCodeAt(i));
-  }
-  while (a.length < 8) {
-    a.push(0);
-  }
-  return {
-    amount,
-    symbol: binaryToDecimal(a.slice(0, 8))
-  };
-};
-const parseAuth = a => {
-  const keyToBuffer = pk => {
-    const len = pk.indexOf('EOS') === 0 ? 3 : 7;
-    const key = Buffer.from(bs58_1.default.decode(pk.substring(len)));
-    return {
-      type: 0,
-      key: key.subarray(0, key.length - 4).toString('hex')
-    };
-  };
-  return {
-    threshold: a.threshold,
-    keys: a.keys.map(k => ({
-      weight: k.weight,
-      ...keyToBuffer(k.key)
-    })),
-    accounts: a.accounts.map(acc => ({
-      weight: acc.weight,
-      account: {
-        actor: serialize(acc.permission.actor),
-        permission: serialize(acc.permission.permission)
-      }
-    })),
-    waits: a.waits
-  };
-};
-const parseDate = d => {
-  if (typeof d !== 'string') {
-    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Eos serialization error. Header.expiration should be string or number');
-  }
-  if (d.substring(d.length - 1, d.length) !== 'Z') {
-    d += 'Z';
-  }
-  return Date.parse(d) / 1000;
-};
-const parseAck = action => {
-  switch (action.name) {
-    case 'transfer':
-      return {
-        transfer: {
-          sender: serialize(action.data.from),
-          receiver: serialize(action.data.to),
-          quantity: parseQuantity(action.data.quantity),
-          memo: action.data.memo
-        }
-      };
-    case 'delegatebw':
-      return {
-        delegate: {
-          sender: serialize(action.data.from),
-          receiver: serialize(action.data.receiver),
-          net_quantity: parseQuantity(action.data.stake_net_quantity),
-          cpu_quantity: parseQuantity(action.data.stake_cpu_quantity),
-          transfer: action.data.transfer
-        }
-      };
-    case 'undelegatebw':
-      return {
-        undelegate: {
-          sender: serialize(action.data.from),
-          receiver: serialize(action.data.receiver),
-          net_quantity: parseQuantity(action.data.unstake_net_quantity),
-          cpu_quantity: parseQuantity(action.data.unstake_cpu_quantity)
-        }
-      };
-    case 'buyram':
-      return {
-        buy_ram: {
-          payer: serialize(action.data.payer),
-          receiver: serialize(action.data.receiver),
-          quantity: parseQuantity(action.data.quant)
-        }
-      };
-    case 'buyrambytes':
-      return {
-        buy_ram_bytes: {
-          payer: serialize(action.data.payer),
-          receiver: serialize(action.data.receiver),
-          bytes: action.data.bytes
-        }
-      };
-    case 'sellram':
-      return {
-        sell_ram: {
-          account: serialize(action.data.account),
-          bytes: action.data.bytes
-        }
-      };
-    case 'voteproducer':
-      return {
-        vote_producer: {
-          voter: serialize(action.data.voter),
-          proxy: serialize(action.data.proxy),
-          producers: action.data.producers.map(p => serialize(p))
-        }
-      };
-    case 'refund':
-      return {
-        refund: {
-          owner: serialize(action.data.owner)
-        }
-      };
-    case 'updateauth':
-      return {
-        update_auth: {
-          account: serialize(action.data.account),
-          permission: serialize(action.data.permission),
-          parent: serialize(action.data.parent),
-          auth: parseAuth(action.data.auth)
-        }
-      };
-    case 'deleteauth':
-      return {
-        delete_auth: {
-          account: serialize(action.data.account),
-          permission: serialize(action.data.permission)
-        }
-      };
-    case 'linkauth':
-      return {
-        link_auth: {
-          account: serialize(action.data.account),
-          code: serialize(action.data.code),
-          type: serialize(action.data.type),
-          requirement: serialize(action.data.requirement)
-        }
-      };
-    case 'unlinkauth':
-      return {
-        unlink_auth: {
-          account: serialize(action.data.account),
-          code: serialize(action.data.code),
-          type: serialize(action.data.type)
-        }
-      };
-    case 'newaccount':
-      return {
-        new_account: {
-          creator: serialize(action.data.creator),
-          name: serialize(action.data.name),
-          owner: parseAuth(action.data.owner),
-          active: parseAuth(action.data.active)
-        }
-      };
-    default:
-      return null;
-  }
-};
-const parseUnknown = action => {
-  if (typeof action.data !== 'string') return null;
-  return {
-    unknown: {
-      data_size: action.data.length / 2,
-      data_chunk: action.data
-    }
-  };
-};
-const parseCommon = action => ({
-  account: serialize(action.account),
-  name: serialize(action.name),
-  authorization: action.authorization.map(a => ({
-    actor: serialize(a.actor),
-    permission: serialize(a.permission)
-  }))
-});
-const parseAction = action => {
-  const ack = parseAck(action) || parseUnknown(action);
-  return {
-    common: parseCommon(action),
-    ...ack
-  };
-};
-const validate = tx => {
-  const header = {
-    expiration: typeof tx.header.expiration === 'number' ? tx.header.expiration : parseDate(tx.header.expiration),
-    ref_block_num: tx.header.refBlockNum,
-    ref_block_prefix: tx.header.refBlockPrefix,
-    max_net_usage_words: tx.header.maxNetUsageWords,
-    max_cpu_usage_ms: tx.header.maxCpuUsageMs,
-    delay_sec: tx.header.delaySec
-  };
-  const ack = [];
-  tx.actions.forEach(action => {
-    ack.push(parseAction(action));
-  });
-  return {
-    chain_id: tx.chainId,
-    header,
-    ack
-  };
-};
-exports.validate = validate;
-const CHUNK_SIZE = 2048;
-const getDataChunk = (data, offset) => {
-  if (!data || offset < 0 || data.length < offset) return '';
-  const o = offset > 0 ? data.length - offset * 2 : 0;
-  return data.substring(o, o + CHUNK_SIZE * 2);
-};
-const processTxRequest = async (typedCall, message, actions, index) => {
-  const action = actions[index];
-  const lastOp = index + 1 >= actions.length;
-  let ack;
-  const requestedDataSize = message.data_size;
-  if (action.unknown) {
-    const {
-      unknown
-    } = action;
-    const offset = typeof requestedDataSize === 'number' ? requestedDataSize : 0;
-    const data_chunk = getDataChunk(unknown.data_chunk, offset);
-    const params = {
-      common: action.common,
-      unknown: {
-        data_size: unknown.data_size,
-        data_chunk
-      }
-    };
-    const sent = offset > 0 ? unknown.data_size - offset + CHUNK_SIZE : CHUNK_SIZE;
-    const lastChunk = sent >= unknown.data_size;
-    if (lastOp && lastChunk) {
-      const response = await typedCall('EosTxActionAck', 'EosSignedTx', params);
-      return response.message;
-    }
-    ack = await typedCall('EosTxActionAck', 'EosTxActionRequest', params);
-    if (lastChunk) {
-      index++;
-    }
-  } else {
-    if (lastOp) {
-      const response = await typedCall('EosTxActionAck', 'EosSignedTx', action);
-      return response.message;
-    }
-    ack = await typedCall('EosTxActionAck', 'EosTxActionRequest', action);
-    index++;
-  }
-  return processTxRequest(typedCall, ack.message, actions, index);
-};
-const signTx = async (typedCall, address_n, chain_id, header, actions, chunkify) => {
-  const response = await typedCall('EosSignTx', 'EosTxActionRequest', {
-    address_n,
-    chain_id,
-    header,
-    num_actions: actions.length,
-    chunkify
-  });
-  return processTxRequest(typedCall, response.message, actions, 0);
-};
-exports.signTx = signTx;
-//# sourceMappingURL=eosSignTx.js.map

package/lib/api/getAccountDescriptor.d.ts

@@ -1,22 +0,0 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import { type CoinInfo } from '../types';
-import { GetAccountDescriptorParams, GetAccountDescriptorResponse } from '../types/api/getAccountDescriptor';
-type Request = GetAccountDescriptorParams & {
-    address_n: number[];
-    coinInfo: CoinInfo;
-};
-export default class GetAccountDescriptor extends AbstractMethod<'getAccountDescriptor', Request[]> {
-    disposed: boolean;
-    hasBundle?: boolean;
-    init(): void;
-    get info(): string;
-    get confirmation(): {
-        view: "export-account-info";
-        label: string;
-    };
-    checkFirmwareRange(): undefined;
-    run(): Promise<GetAccountDescriptorResponse | (GetAccountDescriptorResponse | null)[]>;
-    dispose(): void;
-}
-export {};
-//# sourceMappingURL=getAccountDescriptor.d.ts.map

package/lib/api/getAccountDescriptor.js

@@ -1,139 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../constants");
-const paramsValidator_1 = require("./common/paramsValidator");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const coinInfo_1 = require("../data/coinInfo");
-const events_1 = require("../events");
-const types_1 = require("../types");
-const getAccountDescriptor_1 = require("../types/api/getAccountDescriptor");
-const accountUtils_1 = require("../utils/accountUtils");
-const pathUtils_1 = require("../utils/pathUtils");
-class GetAccountDescriptor extends AbstractMethod_1.AbstractMethod {
-  disposed = false;
-  hasBundle;
-  init() {
-    this.requiredPermissions = ['read'];
-    this.useDevice = true;
-    this.useUi = true;
-    this.hasBundle = !!this.payload.bundle;
-    const payload = !this.payload.bundle ? {
-      ...this.payload,
-      bundle: [this.payload]
-    } : this.payload;
-    (0, schema_utils_1.Assert)((0, types_1.Bundle)(getAccountDescriptor_1.GetAccountDescriptorParams), payload);
-    this.params = payload.bundle.map(batch => {
-      const coinInfo = (0, coinInfo_1.getCoinInfo)(batch.coin);
-      if (!coinInfo) {
-        throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-      }
-      const address_n = (0, pathUtils_1.validatePath)(batch.path, 3);
-      this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
-      return {
-        ...batch,
-        address_n,
-        coinInfo
-      };
-    });
-    this.noBackupConfirmationMode = this.params.every(batch => batch.suppressBackupWarning) ? 'popup-only' : 'always';
-  }
-  get info() {
-    return 'Export account descriptor';
-  }
-  get confirmation() {
-    const keys = {};
-    this.params.forEach(b => {
-      if (!keys[b.coinInfo.label]) {
-        keys[b.coinInfo.label] = {
-          coinInfo: b.coinInfo,
-          values: []
-        };
-      }
-      keys[b.coinInfo.label].values.push(b.address_n);
-    });
-    const str = [];
-    Object.keys(keys).forEach((k, _i, _a) => {
-      const details = keys[k];
-      details.values.forEach(acc => {
-        str.push(k);
-        str.push(' ');
-        if (typeof acc === 'string') {
-          str.push(acc);
-        } else {
-          str.push((0, accountUtils_1.getAccountLabel)(acc, details.coinInfo));
-        }
-      });
-    });
-    return {
-      view: 'export-account-info',
-      label: `Export descriptor for: ${str.join('')}`
-    };
-  }
-  checkFirmwareRange() {
-    const invalid = [];
-    for (let i = 0; i < this.params.length; i++) {
-      this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, this.params[i].coinInfo, AbstractMethod_1.DEFAULT_FIRMWARE_RANGE);
-      const exception = super.checkFirmwareRange();
-      if (exception) {
-        invalid.push({
-          index: i,
-          exception,
-          coin: this.params[i].coin
-        });
-      }
-    }
-    if (invalid.length > 0) {
-      throw constants_1.ERRORS.TypedError('Method_Discovery_BundleException', JSON.stringify(invalid));
-    }
-    return undefined;
-  }
-  async run() {
-    const responses = [];
-    const sendProgress = (progress, response, error) => {
-      if (!this.hasBundle || this.disposed) return;
-      this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
-        total: this.params.length,
-        progress,
-        response,
-        error
-      }));
-    };
-    for (let i = 0; i < this.params.length; i++) {
-      const request = this.params[i];
-      if (this.disposed) break;
-      try {
-        const {
-          descriptor,
-          address_n,
-          legacyXpub
-        } = await this.device.getCommands().getAccountDescriptor(request.coinInfo, request.address_n, request.derivationType);
-        const response = {
-          descriptor,
-          path: (0, pathUtils_1.getSerializedPath)(address_n),
-          legacyXpub
-        };
-        sendProgress(i, response);
-        responses.push(response);
-      } catch (error) {
-        if (this.hasBundle) {
-          responses.push(null);
-          sendProgress(i, null, error.message);
-          continue;
-        } else {
-          throw error;
-        }
-      }
-    }
-    if (this.disposed) return new Promise(() => []);
-    return this.hasBundle ? responses : responses[0];
-  }
-  dispose() {
-    this.disposed = true;
-  }
-}
-exports.default = GetAccountDescriptor;
-//# sourceMappingURL=getAccountDescriptor.js.map

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

@@ -1,3 +0,0 @@
-export { default as nemGetAddress } from './nemGetAddress';
-export { default as nemSignTransaction } from './nemSignTransaction';
-//# sourceMappingURL=index.d.ts.map

package/lib/api/nem/api/index.js

@@ -1,22 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.nemSignTransaction = exports.nemGetAddress = void 0;
-const tslib_1 = require("tslib");
-var nemGetAddress_1 = require("./nemGetAddress");
-Object.defineProperty(exports, "nemGetAddress", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(nemGetAddress_1).default;
-  }
-});
-var nemSignTransaction_1 = require("./nemSignTransaction");
-Object.defineProperty(exports, "nemSignTransaction", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(nemSignTransaction_1).default;
-  }
-});
-//# sourceMappingURL=index.js.map