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

package/lib/api/nem/api/nemSignTransaction.js

@@ -1,5 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+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");
@@ -9,26 +12,28 @@ const pathUtils_1 = require("../../../utils/pathUtils");
 const paramsValidator_1 = require("../../common/paramsValidator");
 const helper = tslib_1.__importStar(require("../nemSignTx"));
 class NEMSignTransaction extends AbstractMethod_1.AbstractMethod {
-    init() {
-        this.requiredPermissions = ['read', 'write'];
-        this.requiredDeviceCapabilities = ['Capability_NEM'];
-        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('NEM'), this.firmwareRange);
-        const { payload } = this;
-        if (payload?.transaction?.timestamp) {
-            payload.transaction.timeStamp = payload.transaction.timestamp;
-        }
-        (0, schema_utils_1.AssertWeak)(nem_1.NEMSignTransaction, payload);
-        const path = (0, pathUtils_1.validatePath)(payload.path, 3);
-        this.params = helper.createTx(payload.transaction, path, payload.chunkify);
-    }
-    get info() {
-        return 'Sign NEM transaction';
-    }
-    async run() {
-        const cmd = this.device.getCommands();
-        const response = await cmd.typedCall('NEMSignTx', 'NEMSignedTx', this.params);
-        return response.message;
+  init() {
+    this.requiredPermissions = ['read', 'write'];
+    this.requiredDeviceCapabilities = ['Capability_NEM'];
+    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('NEM'), this.firmwareRange);
+    const {
+      payload
+    } = this;
+    if (payload?.transaction?.timestamp) {
+      payload.transaction.timeStamp = payload.transaction.timestamp;
     }
+    (0, schema_utils_1.AssertWeak)(nem_1.NEMSignTransaction, payload);
+    const path = (0, pathUtils_1.validatePath)(payload.path, 3);
+    this.params = helper.createTx(payload.transaction, path, payload.chunkify);
+  }
+  get info() {
+    return 'Sign NEM transaction';
+  }
+  async run() {
+    const cmd = this.device.getCommands();
+    const response = await cmd.typedCall('NEMSignTx', 'NEMSignedTx', this.params);
+    return response.message;
+  }
 }
 exports.default = NEMSignTransaction;
 //# sourceMappingURL=nemSignTransaction.js.map

package/lib/api/nem/nemSignTx.js

@@ -1,140 +1,143 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.createTx = void 0;
 const constants_1 = require("../../constants");
 const getCommon = (tx, address_n) => ({
-    address_n,
-    network: (tx.version >> 24) & 0xff,
-    timestamp: tx.timeStamp,
-    fee: tx.fee,
-    deadline: tx.deadline,
-    signer: address_n ? undefined : tx.signer,
+  address_n,
+  network: tx.version >> 24 & 0xff,
+  timestamp: tx.timeStamp,
+  fee: tx.fee,
+  deadline: tx.deadline,
+  signer: address_n ? undefined : tx.signer
 });
-const transferMessage = (tx) => {
-    const mosaics = tx.mosaics
-        ? tx.mosaics.map(mosaic => ({
-            namespace: mosaic.mosaicId.namespaceId,
-            mosaic: mosaic.mosaicId.name,
-            quantity: mosaic.quantity,
-        }))
-        : undefined;
-    return {
-        recipient: tx.recipient,
-        amount: tx.amount,
-        payload: tx.message ? tx.message.payload : undefined,
-        public_key: tx.message && tx.message.type === 0x02 ? tx.message.publicKey : undefined,
-        mosaics,
-    };
+const transferMessage = tx => {
+  const mosaics = tx.mosaics ? tx.mosaics.map(mosaic => ({
+    namespace: mosaic.mosaicId.namespaceId,
+    mosaic: mosaic.mosaicId.name,
+    quantity: mosaic.quantity
+  })) : undefined;
+  return {
+    recipient: tx.recipient,
+    amount: tx.amount,
+    payload: tx.message ? tx.message.payload : undefined,
+    public_key: tx.message && tx.message.type === 0x02 ? tx.message.publicKey : undefined,
+    mosaics
+  };
 };
-const importanceTransferMessage = (tx) => ({
-    mode: tx.importanceTransfer.mode,
-    public_key: tx.importanceTransfer.publicKey,
+const importanceTransferMessage = tx => ({
+  mode: tx.importanceTransfer.mode,
+  public_key: tx.importanceTransfer.publicKey
 });
-const aggregateModificationMessage = (tx) => {
-    const modifications = tx.modifications
-        ? tx.modifications.map(modification => ({
-            type: modification.modificationType,
-            public_key: modification.cosignatoryAccount,
-        }))
-        : undefined;
-    return {
-        modifications,
-        relative_change: tx.minCosignatories.relativeChange,
-    };
+const aggregateModificationMessage = tx => {
+  const modifications = tx.modifications ? tx.modifications.map(modification => ({
+    type: modification.modificationType,
+    public_key: modification.cosignatoryAccount
+  })) : undefined;
+  return {
+    modifications,
+    relative_change: tx.minCosignatories.relativeChange
+  };
 };
-const provisionNamespaceMessage = (tx) => ({
-    namespace: tx.newPart,
-    parent: tx.parent,
-    sink: tx.rentalFeeSink,
-    fee: tx.rentalFee,
+const provisionNamespaceMessage = tx => ({
+  namespace: tx.newPart,
+  parent: tx.parent,
+  sink: tx.rentalFeeSink,
+  fee: tx.rentalFee
 });
-const mosaicCreationMessage = (tx) => {
-    const { levy } = tx.mosaicDefinition;
-    const definition = {
-        namespace: tx.mosaicDefinition.id.namespaceId,
-        mosaic: tx.mosaicDefinition.id.name,
-        levy: levy && levy.type,
-        fee: levy && levy.fee,
-        levy_address: levy && levy.recipient,
-        levy_namespace: levy && levy.mosaicId && levy.mosaicId.namespaceId,
-        levy_mosaic: levy && levy.mosaicId && levy.mosaicId.name,
-        description: tx.mosaicDefinition.description,
-    };
-    const { properties } = tx.mosaicDefinition;
-    if (Array.isArray(properties)) {
-        properties.forEach(property => {
-            const { name, value } = property;
-            switch (name) {
-                case 'divisibility':
-                    definition.divisibility = parseInt(value, 10);
-                    break;
-                case 'initialSupply':
-                    definition.supply = parseInt(value, 10);
-                    break;
-                case 'supplyMutable':
-                    definition.mutable_supply = value === 'true';
-                    break;
-                case 'transferable':
-                    definition.transferable = value === 'true';
-                    break;
-            }
-        });
-    }
-    return {
-        definition,
-        sink: tx.creationFeeSink,
-        fee: tx.creationFee,
-    };
+const mosaicCreationMessage = tx => {
+  const {
+    levy
+  } = tx.mosaicDefinition;
+  const definition = {
+    namespace: tx.mosaicDefinition.id.namespaceId,
+    mosaic: tx.mosaicDefinition.id.name,
+    levy: levy && levy.type,
+    fee: levy && levy.fee,
+    levy_address: levy && levy.recipient,
+    levy_namespace: levy && levy.mosaicId && levy.mosaicId.namespaceId,
+    levy_mosaic: levy && levy.mosaicId && levy.mosaicId.name,
+    description: tx.mosaicDefinition.description
+  };
+  const {
+    properties
+  } = tx.mosaicDefinition;
+  if (Array.isArray(properties)) {
+    properties.forEach(property => {
+      const {
+        name,
+        value
+      } = property;
+      switch (name) {
+        case 'divisibility':
+          definition.divisibility = parseInt(value, 10);
+          break;
+        case 'initialSupply':
+          definition.supply = parseInt(value, 10);
+          break;
+        case 'supplyMutable':
+          definition.mutable_supply = value === 'true';
+          break;
+        case 'transferable':
+          definition.transferable = value === 'true';
+          break;
+      }
+    });
+  }
+  return {
+    definition,
+    sink: tx.creationFeeSink,
+    fee: tx.creationFee
+  };
 };
-const supplyChangeMessage = (tx) => ({
-    namespace: tx.mosaicId.namespaceId,
-    mosaic: tx.mosaicId.name,
-    type: tx.supplyType,
-    delta: tx.delta,
+const supplyChangeMessage = tx => ({
+  namespace: tx.mosaicId.namespaceId,
+  mosaic: tx.mosaicId.name,
+  type: tx.supplyType,
+  delta: tx.delta
 });
 const createTx = (tx, address_n, chunkify) => {
-    let transaction = tx;
-    const message = {
-        chunkify: typeof chunkify === 'boolean' ? chunkify : false,
-        transaction: getCommon(tx, address_n),
-        transfer: undefined,
-        importance_transfer: undefined,
-        aggregate_modification: undefined,
-        provision_namespace: undefined,
-        mosaic_creation: undefined,
-        supply_change: undefined,
-    };
-    if (tx.type === constants_1.NEM.TxType.COSIGNING ||
-        tx.type === constants_1.NEM.TxType.MULTISIG ||
-        tx.type === constants_1.NEM.TxType.MULTISIG_SIGNATURE) {
-        message.cosigning =
-            tx.type === constants_1.NEM.TxType.COSIGNING || tx.type === constants_1.NEM.TxType.MULTISIG_SIGNATURE;
-        transaction = tx.otherTrans;
-        message.multisig = getCommon(transaction);
-    }
-    switch (transaction.type) {
-        case constants_1.NEM.TxType.TRANSFER:
-            message.transfer = transferMessage(transaction);
-            break;
-        case constants_1.NEM.TxType.IMPORTANCE_TRANSFER:
-            message.importance_transfer = importanceTransferMessage(transaction);
-            break;
-        case constants_1.NEM.TxType.AGGREGATE_MODIFICATION:
-            message.aggregate_modification = aggregateModificationMessage(transaction);
-            break;
-        case constants_1.NEM.TxType.PROVISION_NAMESPACE:
-            message.provision_namespace = provisionNamespaceMessage(transaction);
-            break;
-        case constants_1.NEM.TxType.MOSAIC_CREATION:
-            message.mosaic_creation = mosaicCreationMessage(transaction);
-            break;
-        case constants_1.NEM.TxType.SUPPLY_CHANGE:
-            message.supply_change = supplyChangeMessage(transaction);
-            break;
-        default:
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Unknown transaction type');
-    }
-    return message;
+  let transaction = tx;
+  const message = {
+    chunkify: typeof chunkify === 'boolean' ? chunkify : false,
+    transaction: getCommon(tx, address_n),
+    transfer: undefined,
+    importance_transfer: undefined,
+    aggregate_modification: undefined,
+    provision_namespace: undefined,
+    mosaic_creation: undefined,
+    supply_change: undefined
+  };
+  if (tx.type === constants_1.NEM.TxType.COSIGNING || tx.type === constants_1.NEM.TxType.MULTISIG || tx.type === constants_1.NEM.TxType.MULTISIG_SIGNATURE) {
+    message.cosigning = tx.type === constants_1.NEM.TxType.COSIGNING || tx.type === constants_1.NEM.TxType.MULTISIG_SIGNATURE;
+    transaction = tx.otherTrans;
+    message.multisig = getCommon(transaction);
+  }
+  switch (transaction.type) {
+    case constants_1.NEM.TxType.TRANSFER:
+      message.transfer = transferMessage(transaction);
+      break;
+    case constants_1.NEM.TxType.IMPORTANCE_TRANSFER:
+      message.importance_transfer = importanceTransferMessage(transaction);
+      break;
+    case constants_1.NEM.TxType.AGGREGATE_MODIFICATION:
+      message.aggregate_modification = aggregateModificationMessage(transaction);
+      break;
+    case constants_1.NEM.TxType.PROVISION_NAMESPACE:
+      message.provision_namespace = provisionNamespaceMessage(transaction);
+      break;
+    case constants_1.NEM.TxType.MOSAIC_CREATION:
+      message.mosaic_creation = mosaicCreationMessage(transaction);
+      break;
+    case constants_1.NEM.TxType.SUPPLY_CHANGE:
+      message.supply_change = supplyChangeMessage(transaction);
+      break;
+    default:
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Unknown transaction type');
+  }
+  return message;
 };
 exports.createTx = createTx;
 //# sourceMappingURL=nemSignTx.js.map

package/lib/api/pushTransaction.js

@@ -1,5 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 const schema_utils_1 = require("@trezor/schema-utils");
 const BlockchainLink_1 = require("../backend/BlockchainLink");
 const constants_1 = require("../constants");
@@ -7,34 +10,35 @@ const AbstractMethod_1 = require("../core/AbstractMethod");
 const coinInfo_1 = require("../data/coinInfo");
 const pushTransaction_1 = require("../types/api/pushTransaction");
 class PushTransaction extends AbstractMethod_1.AbstractMethod {
-    init() {
-        this.requiredPermissions = ['push_tx'];
-        this.useUi = false;
-        this.useDevice = false;
-        const { payload } = this;
-        (0, schema_utils_1.Assert)(pushTransaction_1.PushTransaction, payload);
-        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
-        if (!coinInfo) {
-            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-        }
-        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-        if (coinInfo.type === 'bitcoin' &&
-            (typeof payload.tx !== 'string' || !/^[0-9A-Fa-f]*$/.test(payload.tx))) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Transaction must be hexadecimal');
-        }
-        this.params = {
-            tx: payload.tx,
-            coinInfo,
-            identity: payload.identity,
-        };
+  init() {
+    this.requiredPermissions = ['push_tx'];
+    this.useUi = false;
+    this.useDevice = false;
+    const {
+      payload
+    } = this;
+    (0, schema_utils_1.Assert)(pushTransaction_1.PushTransaction, payload);
+    const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+    if (!coinInfo) {
+      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
     }
-    async run() {
-        const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
-        const txid = await backend.pushTransaction(this.params.tx);
-        return {
-            txid,
-        };
+    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+    if (coinInfo.type === 'bitcoin' && (typeof payload.tx !== 'string' || !/^[0-9A-Fa-f]*$/.test(payload.tx))) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Transaction must be hexadecimal');
     }
+    this.params = {
+      tx: payload.tx,
+      coinInfo,
+      identity: payload.identity
+    };
+  }
+  async run() {
+    const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
+    const txid = await backend.pushTransaction(this.params.tx);
+    return {
+      txid
+    };
+  }
 }
 exports.default = PushTransaction;
 //# sourceMappingURL=pushTransaction.js.map

package/lib/api/recoveryDevice.js

@@ -1,48 +1,53 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../core/AbstractMethod");
 const events_1 = require("../events");
 const recoveryDevice_1 = require("../types/api/recoveryDevice");
 class RecoveryDevice extends AbstractMethod_1.AbstractMethod {
-    init() {
-        this.requiredPermissions = ['management'];
-        this.skipFinalReload = false;
-        this.useEmptyPassphrase = true;
-        const { payload } = this;
-        (0, schema_utils_1.Assert)(recoveryDevice_1.RecoveryDevice, payload);
-        this.params = {
-            word_count: payload.word_count,
-            passphrase_protection: payload.passphrase_protection,
-            pin_protection: payload.pin_protection,
-            language: payload.language,
-            label: payload.label,
-            enforce_wordlist: payload.enforce_wordlist,
-            input_method: payload.input_method,
-            type: payload.type,
-            u2f_counter: payload.u2f_counter,
-        };
-        this.allowDeviceMode = [...this.allowDeviceMode, events_1.UI.INITIALIZE];
-        this.useDeviceState = false;
-    }
-    get confirmation() {
-        return {
-            view: 'device-management',
-            customConfirmButton: {
-                className: 'confirm',
-                label: 'Proceed',
-            },
-            label: 'Do you want to recover device from seed?',
-        };
-    }
-    async run() {
-        const cmd = this.device.getCommands();
-        const response = await cmd.typedCall('RecoveryDevice', 'Success', this.params);
-        return response.message;
-    }
-    get info() {
-        return 'Recover device';
-    }
+  init() {
+    this.requiredPermissions = ['management'];
+    this.skipFinalReload = false;
+    this.useEmptyPassphrase = true;
+    const {
+      payload
+    } = this;
+    (0, schema_utils_1.Assert)(recoveryDevice_1.RecoveryDevice, payload);
+    this.params = {
+      word_count: payload.word_count,
+      passphrase_protection: payload.passphrase_protection,
+      pin_protection: payload.pin_protection,
+      language: payload.language,
+      label: payload.label,
+      enforce_wordlist: payload.enforce_wordlist,
+      input_method: payload.input_method,
+      type: payload.type,
+      u2f_counter: payload.u2f_counter
+    };
+    this.allowDeviceMode = [...this.allowDeviceMode, events_1.UI.INITIALIZE];
+    this.useDeviceState = false;
+  }
+  get confirmation() {
+    return {
+      view: 'device-management',
+      customConfirmButton: {
+        className: 'confirm',
+        label: 'Proceed'
+      },
+      label: 'Do you want to recover device from seed?'
+    };
+  }
+  async run() {
+    const cmd = this.device.getCommands();
+    const response = await cmd.typedCall('RecoveryDevice', 'Success', this.params);
+    return response.message;
+  }
+  get info() {
+    return 'Recover device';
+  }
 }
 exports.default = RecoveryDevice;
 //# sourceMappingURL=recoveryDevice.js.map

package/lib/api/requestLogin.d.ts

@@ -1,7 +1,6 @@
 import { MessagesSchema as PROTO } from '@trezor/protobuf';
 import { AbstractMethod } from '../core/AbstractMethod';
 export default class RequestLogin extends AbstractMethod<'requestLogin', PROTO.SignIdentity> {
-    asyncChallenge?: boolean;
     init(): void;
     get info(): string;
     run(): Promise<{

package/lib/api/requestLogin.js

@@ -1,64 +1,59 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../constants");
 const AbstractMethod_1 = require("../core/AbstractMethod");
-const events_1 = require("../events");
 const paramsValidator_1 = require("./common/paramsValidator");
 const DataManager_1 = require("../data/DataManager");
 const requestLogin_1 = require("../types/api/requestLogin");
 class RequestLogin extends AbstractMethod_1.AbstractMethod {
-    asyncChallenge;
-    init() {
-        this.requiredPermissions = ['read', 'write'];
-        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
-        this.useEmptyPassphrase = true;
-        const { payload } = this;
-        const identity = {};
-        const settings = DataManager_1.DataManager.getSettings();
-        if (settings.origin) {
-            const [proto, host, port] = settings.origin.split(':');
-            identity.proto = proto;
-            identity.host = host.substring(2);
-            if (port) {
-                identity.port = port;
-            }
-            identity.index = 0;
-        }
-        (0, schema_utils_1.Assert)(requestLogin_1.RequestLoginSchema, payload);
-        this.params = {
-            identity,
-            challenge_hidden: payload.challengeHidden || '',
-            challenge_visual: payload.challengeVisual || '',
-        };
-        this.asyncChallenge = !!payload.asyncChallenge;
+  init() {
+    this.requiredPermissions = ['read', 'write'];
+    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
+    this.useEmptyPassphrase = true;
+    const {
+      payload
+    } = this;
+    (0, schema_utils_1.Assert)(requestLogin_1.RequestLoginSchema, payload);
+    const identity = {};
+    const settings = DataManager_1.DataManager.getSettings();
+    let origin;
+    if (settings.trustedHost && payload.origin) {
+      origin = payload.origin;
+    } else if (settings.origin) {
+      origin = settings.origin;
     }
-    get info() {
-        return 'Login';
-    }
-    async run() {
-        if (this.asyncChallenge) {
-            const uiPromise = this.createUiPromise(events_1.UI.LOGIN_CHALLENGE_RESPONSE);
-            this.postMessage((0, events_1.createUiMessage)(events_1.UI.LOGIN_CHALLENGE_REQUEST));
-            const { payload } = await uiPromise.promise;
-            if (typeof payload === 'string') {
-                throw constants_1.ERRORS.TypedError('Runtime', `TrezorConnect.requestLogin callback error: ${payload}`);
-            }
-            (0, schema_utils_1.Assert)(schema_utils_1.Type.Object({
-                challengeHidden: schema_utils_1.Type.String(),
-                challengeVisual: schema_utils_1.Type.String(),
-            }), payload);
-            this.params.challenge_hidden = payload.challengeHidden;
-            this.params.challenge_visual = payload.challengeVisual;
-        }
-        const cmd = this.device.getCommands();
-        const { message } = await cmd.typedCall('SignIdentity', 'SignedIdentity', this.params);
-        return {
-            address: message.address,
-            publicKey: message.public_key,
-            signature: message.signature,
-        };
+    if (origin) {
+      const [proto, host, port] = origin.split(':');
+      identity.proto = proto;
+      identity.host = host.substring(2);
+      if (port) {
+        identity.port = port;
+      }
+      identity.index = 0;
     }
+    this.params = {
+      identity,
+      challenge_hidden: payload.challengeHidden || '',
+      challenge_visual: payload.challengeVisual || ''
+    };
+  }
+  get info() {
+    return 'Login';
+  }
+  async run() {
+    const cmd = this.device.getCommands();
+    const {
+      message
+    } = await cmd.typedCall('SignIdentity', 'SignedIdentity', this.params);
+    return {
+      address: message.address,
+      publicKey: message.public_key,
+      signature: message.signature
+    };
+  }
 }
 exports.default = RequestLogin;
 //# sourceMappingURL=requestLogin.js.map