@trezor/connect 9.7.3 → 10.0.0-alpha.1

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

@@ -1,23 +0,0 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-export default class EosGetPublicKey extends AbstractMethod<'eosGetPublicKey', PROTO.EosGetPublicKey[]> {
-    hasBundle?: boolean;
-    init(): void;
-    get info(): string;
-    get confirmation(): {
-        view: "export-address";
-        label: string;
-    };
-    run(): Promise<{
-        path: number[];
-        serializedPath: string;
-        wifPublicKey: string;
-        rawPublicKey: string;
-    } | {
-        path: number[];
-        serializedPath: string;
-        wifPublicKey: string;
-        rawPublicKey: string;
-    }[]>;
-}
-//# sourceMappingURL=eosGetPublicKey.d.ts.map

package/lib/api/eos/api/eosGetPublicKey.js

@@ -1,69 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const events_1 = require("../../../events");
-const types_1 = require("../../../types");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-class EosGetPublicKey extends AbstractMethod_1.AbstractMethod {
-  hasBundle;
-  init() {
-    this.requiredPermissions = ['read'];
-    this.requiredDeviceCapabilities = ['Capability_EOS'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('EOS'), this.firmwareRange);
-    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)(types_1.GetPublicKey), payload);
-    this.params = payload.bundle.map(batch => {
-      const path = (0, pathUtils_1.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
-      };
-    });
-  }
-  get info() {
-    return 'Export Eos public key';
-  }
-  get confirmation() {
-    return {
-      view: 'export-address',
-      label: this.params.length > 1 ? 'Export multiple Eos public keys' : `Export Eos public key for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`
-    };
-  }
-  async run() {
-    const responses = [];
-    const cmd = this.device.getCommands();
-    for (let i = 0; i < this.params.length; i++) {
-      const batch = this.params[i];
-      const {
-        message
-      } = await cmd.typedCall('EosGetPublicKey', 'EosPublicKey', batch);
-      responses.push({
-        rawPublicKey: message.raw_public_key,
-        wifPublicKey: message.wif_public_key,
-        path: batch.address_n,
-        serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n)
-      });
-      if (this.hasBundle) {
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
-          total: this.params.length,
-          progress: i,
-          response: message
-        }));
-      }
-    }
-    return this.hasBundle ? responses : responses[0];
-  }
-}
-exports.default = EosGetPublicKey;
-//# sourceMappingURL=eosGetPublicKey.js.map

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

@@ -1,18 +0,0 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-type Params = {
-    path: number[];
-    chain_id: string;
-    header: PROTO.EosTxHeader;
-    ack: PROTO.EosTxActionAck[];
-    chunkify: boolean;
-};
-export default class EosSignTransaction extends AbstractMethod<'eosSignTransaction', Params> {
-    init(): void;
-    get info(): string;
-    run(): Promise<{
-        signature: string;
-    }>;
-}
-export {};
-//# sourceMappingURL=eosSignTransaction.d.ts.map

package/lib/api/eos/api/eosSignTransaction.js

@@ -1,48 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const tslib_1 = require("tslib");
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const eos_1 = require("../../../types/api/eos");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-const helper = tslib_1.__importStar(require("../eosSignTx"));
-class EosSignTransaction extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.requiredDeviceCapabilities = ['Capability_EOS'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('EOS'), this.firmwareRange);
-    const {
-      payload
-    } = this;
-    (0, schema_utils_1.AssertWeak)(eos_1.EosSignTransaction, payload);
-    const path = (0, pathUtils_1.validatePath)(payload.path, 3);
-    const {
-      chain_id,
-      header,
-      ack
-    } = helper.validate(payload.transaction);
-    this.params = {
-      path,
-      chain_id,
-      header,
-      ack,
-      chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false
-    };
-  }
-  get info() {
-    return 'Sign EOS transaction';
-  }
-  async run() {
-    const response = await helper.signTx(this.device.getCommands().typedCall, this.params.path, this.params.chain_id, this.params.header, this.params.ack, this.params.chunkify);
-    return {
-      signature: response.signature
-    };
-  }
-}
-exports.default = EosSignTransaction;
-//# sourceMappingURL=eosSignTransaction.js.map

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

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

package/lib/api/eos/api/index.js

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

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