@onekeyfe/hd-web-sdk 0.0.6 → 0.0.9

package/build/onekey-js-sdk.js

@@ -4023,12 +4023,12 @@ __webpack_unused_export__ = ({
   value: true
 });
 
+var semver = __webpack_require__(7699);
+
 var hdTransport = __webpack_require__(7495);
 
 var axios = __webpack_require__(9644);
 
-var semver = __webpack_require__(7699);
-
 var BigNumber = __webpack_require__(6391);
 
 function _interopDefaultLegacy(e) {
@@ -4037,10 +4037,10 @@ function _interopDefaultLegacy(e) {
   };
 }
 
-var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
-
 var semver__default = /*#__PURE__*/_interopDefaultLegacy(semver);
 
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+
 var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
 
 const inject = ({
@@ -4084,6 +4084,10 @@ const inject = ({
     checkTransportRelease: () => call({
       method: 'checkTransportRelease'
     }),
+    cipherKeyValue: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      method: 'cipherKeyValue'
+    })),
     deviceBackup: connectId => call({
       connectId,
       method: 'deviceBackup'
@@ -4187,6 +4191,30 @@ const inject = ({
     starcoinVerifyMessage: (connectId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
       method: 'starcoinVerifyMessage'
+    })),
+    nemGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      method: 'nemGetAddress'
+    })),
+    nemSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      method: 'nemSignTransaction'
+    })),
+    solGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      method: 'solGetAddress'
+    })),
+    solSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      method: 'solSignTransaction'
+    })),
+    stellarGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      method: 'stellarGetAddress'
+    })),
+    stellarSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      method: 'stellarSignTransaction'
     }))
   };
   return api;
@@ -4207,6 +4235,17 @@ PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 
 
+function __rest(s, e) {
+  var t = {};
+
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+}
+
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function (resolve) {
@@ -4998,6 +5037,18 @@ function create(arg, data) {
   };
 }
 
+const getDeviceModel = features => {
+  if (!features || typeof features !== 'object') {
+    return 'model_mini';
+  }
+
+  if (features.model === '1') {
+    return 'model_mini';
+  }
+
+  return 'model_touch';
+};
+
 const getDeviceType = features => {
   if (!features || typeof features !== 'object' || !features.serial_no) {
     return 'classic';
@@ -5006,6 +5057,24 @@ const getDeviceType = features => {
   const serialNo = features.serial_no;
   const miniFlag = serialNo.slice(0, 2);
   if (miniFlag.toLowerCase() === 'mi') return 'mini';
+  if (miniFlag.toLowerCase() === 'tc') return 'touch';
+  return 'classic';
+};
+
+const getDeviceTypeByBleName = name => {
+  if (!name) return 'classic';
+  if (name.startsWith('MI')) return 'mini';
+  if (name.startsWith('T')) return 'touch';
+  return 'classic';
+};
+
+const getDeviceTypeByDeviceId = deviceId => {
+  if (!deviceId) {
+    return 'classic';
+  }
+
+  const miniFlag = deviceId.slice(0, 2);
+  if (miniFlag.toLowerCase() === 'mi') return 'mini';
   return 'classic';
 };
 
@@ -5030,6 +5099,8 @@ const getDeviceLabel = features => {
 };
 
 const getDeviceFirmwareVersion = features => {
+  if (!features) return [0, 0, 0];
+
   if (features.onekey_version) {
     return features.onekey_version.split('.');
   }
@@ -14295,7 +14366,7 @@ const UI_REQUEST = {
   NOT_USE_ONEKEY_DEVICE: 'ui-device_please_use_onekey_device'
 };
 const VERSION = '1.0.0-alpha.1';
-const DEFAULT_DOMAIN = `https://localhost:8088/`;
+const DEFAULT_DOMAIN = `https://hardware-sdk.onekey.so/`;
 const DEFAULT_PRIORITY = 2;
 const initialSettings = {
   configSrc: './data/config.json',
@@ -14811,6 +14882,10 @@ class BaseMethod {
     this.requireDeviceMode = [];
   }
 
+  getVersionRange() {
+    return {};
+  }
+
   setDevice(device) {
     this.device = device;
     this.connectId = device.originalDescriptor.path;
@@ -14837,10 +14912,14 @@ class SearchDevices extends BaseMethod {
       const env = DataManager.getSettings('env');
 
       if (env === 'react-native') {
-        return devicesDescriptor.map(device => Object.assign(Object.assign({}, device), {
-          connectId: device.id,
-          deviceType: 'classic'
-        }));
+        return devicesDescriptor.map(device => {
+          var _a;
+
+          return Object.assign(Object.assign({}, device), {
+            connectId: device.id,
+            deviceType: getDeviceTypeByBleName((_a = device.name) !== null && _a !== void 0 ? _a : '')
+          });
+        });
       }
 
       const devices = [];
@@ -14931,7 +15010,6 @@ const formatAnyHex = value => {
     return modifyValues(value, value => formatAnyHex(value));
   }
 
-  console.log('unexpected value', value);
   return value;
 };
 
@@ -15000,6 +15078,79 @@ const validateParams = (values, fields) => {
   });
 };
 
+class CipherKeyValue extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.hasBundle = false;
+  }
+
+  init() {
+    var _a;
+
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+    const payload = this.hasBundle ? this.payload : {
+      bundle: [this.payload]
+    };
+    validateParams(payload, [{
+      name: 'bundle',
+      type: 'array'
+    }]);
+    this.params = [];
+    payload.bundle.forEach(batch => {
+      const addressN = validatePath(batch.path);
+      validateParams(batch, [{
+        name: 'path',
+        required: true
+      }, {
+        name: 'key',
+        type: 'string'
+      }, {
+        name: 'value',
+        type: 'hexString'
+      }, {
+        name: 'encrypt',
+        type: 'boolean'
+      }, {
+        name: 'askOnEncrypt',
+        type: 'boolean'
+      }, {
+        name: 'askOnDecrypt',
+        type: 'boolean'
+      }, {
+        name: 'iv',
+        type: 'hexString'
+      }]);
+      this.params.push({
+        address_n: addressN,
+        key: batch.key,
+        value: formatAnyHex(batch.value),
+        encrypt: batch.encrypt,
+        ask_on_encrypt: batch.askOnEncrypt,
+        ask_on_decrypt: batch.askOnDecrypt,
+        iv: formatAnyHex(batch.iv)
+      });
+    });
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const responses = [];
+
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const res = yield this.device.commands.typedCall('CipherKeyValue', 'CipheredKeyValue', Object.assign({}, param));
+        responses.push(Object.assign({
+          path: serializedPath(param.address_n)
+        }, res.message));
+      }
+
+      return Promise.resolve(this.hasBundle ? responses : responses[0]);
+    });
+  }
+
+}
+
 var bitcoin = [{
   name: "Bitcoin",
   label: "BTC",
@@ -16165,6 +16316,17 @@ class DeviceFlags extends BaseMethod {
 class DeviceRebootToBootloader extends BaseMethod {
   init() {}
 
+  getVersionRange() {
+    return {
+      classic: {
+        min: '2.1.11'
+      },
+      mini: {
+        min: '2.1.11'
+      }
+    };
+  }
+
   run() {
     return __awaiter(this, void 0, void 0, function* () {
       const res = yield this.device.commands.typedCall('RebootToBootloader', 'Success');
@@ -16509,7 +16671,7 @@ class EVMSignMessage$2 extends BaseMethod {
 
 }
 
-class EVMSignMessageEIP712$1 extends BaseMethod {
+class EVMSignMessageEIP712 extends BaseMethod {
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
     validateParams(this.payload, [{
@@ -16537,6 +16699,14 @@ class EVMSignMessageEIP712$1 extends BaseMethod {
     };
   }
 
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.1.9'
+      }
+    };
+  }
+
   run() {
     return __awaiter(this, void 0, void 0, function* () {
       const res = yield this.device.commands.typedCall('EthereumSignMessageEIP712', 'EthereumMessageSignature', Object.assign({}, this.params));
@@ -16734,6 +16904,22 @@ class EVMSignTransaction extends BaseMethod {
     this.formattedTx = formatAnyHex(tx);
   }
 
+  getVersionRange() {
+    if (this.isEIP1559) {
+      return {
+        model_mini: {
+          min: '2.1.11'
+        }
+      };
+    }
+
+    return {
+      model_mini: {
+        min: '1.0.0'
+      }
+    };
+  }
+
   run() {
     return __awaiter(this, void 0, void 0, function* () {
       const {
@@ -16748,7 +16934,7 @@ class EVMSignTransaction extends BaseMethod {
 
 }
 
-class EVMSignMessageEIP712 extends BaseMethod {
+class EVMSignTypedData extends BaseMethod {
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
     validateParams(this.payload, [{
@@ -16756,12 +16942,10 @@ class EVMSignMessageEIP712 extends BaseMethod {
       required: true
     }, {
       name: 'metamaskV4Compat',
-      type: 'boolean',
-      required: true
+      type: 'boolean'
     }, {
       name: 'data',
-      type: 'object',
-      required: true
+      type: 'object'
     }, {
       name: 'domainHash',
       type: 'hexString'
@@ -16788,12 +16972,35 @@ class EVMSignMessageEIP712 extends BaseMethod {
 
       if (messageHash) {
         this.params.messageHash = formatAnyHex(messageHash);
-      } else if (!data.primaryType || data.primaryType !== 'EIP712Domain') {
+      } else if (!!data && (!data.primaryType || data.primaryType !== 'EIP712Domain')) {
         throw TypedError('Method_InvalidParameter', 'message_hash should only be empty when data.primaryType=EIP712Domain');
       }
     }
   }
 
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.1.9'
+      }
+    };
+  }
+
+  supportSignTyped() {
+    const deviceType = getDeviceType(this.device.features);
+
+    if (deviceType === 'classic' || deviceType === 'mini') {
+      const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+      const supportSignTypedVersion = '2.2.0';
+
+      if (semver__default["default"].lt(currentVersion, supportSignTypedVersion)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   run() {
     return __awaiter(this, void 0, void 0, function* () {
       if (!this.device.features) {
@@ -16803,25 +17010,38 @@ class EVMSignMessageEIP712 extends BaseMethod {
       const {
         addressN
       } = this.params;
+      const deviceType = getDeviceType(this.device.features);
 
-      if (this.device.features.model === '1') {
+      if (deviceType === 'classic' || deviceType === 'mini') {
         validateParams(this.params, [{
           name: 'domainHash',
           type: 'hexString',
           required: true
         }, {
           name: 'messageHash',
-          type: 'hexString'
+          type: 'hexString',
+          required: true
         }]);
         const {
           domainHash,
           messageHash
         } = this.params;
-        const response = yield this.device.commands.typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', {
-          address_n: addressN,
-          domain_separator_hash: domainHash !== null && domainHash !== void 0 ? domainHash : '',
-          message_hash: messageHash
-        });
+        let response;
+
+        if (this.supportSignTyped()) {
+          response = yield this.device.commands.typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', {
+            address_n: addressN,
+            domain_separator_hash: domainHash !== null && domainHash !== void 0 ? domainHash : '',
+            message_hash: messageHash
+          });
+        } else {
+          response = yield this.device.commands.typedCall('EthereumSignMessageEIP712', 'EthereumMessageSignature', {
+            address_n: addressN,
+            domain_hash: domainHash !== null && domainHash !== void 0 ? domainHash : '',
+            message_hash: messageHash !== null && messageHash !== void 0 ? messageHash : ''
+          });
+        }
+
         return Promise.resolve(response.message);
       }
 
@@ -17079,64 +17299,794 @@ class EVMSignMessage extends BaseMethod {
 
 }
 
-var ApiMethods = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  searchDevices: SearchDevices,
-  getFeatures: GetFeatures,
-  btcGetAddress: BTCGetAddress,
-  btcGetPublicKey: BTCGetPublicKey,
-  btcSignMessage: BTCSignMessage,
-  btcSignTransaction: BTCSignTransaction,
-  btcVerifyMessage: BTCVerifyMessage,
-  checkFirmwareRelease: CheckFirmwareRelease,
-  checkBLEFirmwareRelease: CheckBLEFirmwareRelease,
-  checkTransportRelease: CheckTransportRelease,
-  deviceBackup: DeviceBackup,
-  deviceChangePin: DeviceChangePin,
-  deviceFlags: DeviceFlags,
-  deviceRebootToBootloader: DeviceRebootToBootloader,
-  deviceRecovery: DeviceRecovery,
-  deviceReset: DeviceReset,
-  deviceSettings: DeviceSettings,
-  deviceUpdateReboot: DeviceUpdateReboot,
-  deviceWipe: DeviceWipe,
-  evmGetAddress: EvmGetAddress,
-  evmGetPublicKey: EVMGetPublicKey,
-  evmSignMessage: EVMSignMessage$2,
-  evmSignMessageEIP712: EVMSignMessageEIP712$1,
-  evmSignTransaction: EVMSignTransaction,
-  evmSignTypedData: EVMSignMessageEIP712,
-  evmVerifyMessage: EVMSignMessage$1,
-  starcoinGetAddress: StarcoinGetAddress,
-  starcoinGetPublicKey: StarcoinGetPublicKey,
-  starcoinSignMessage: StarcoinSignMessage,
-  starcoinSignTransaction: StarcoinSignTransaction,
-  starcoinVerifyMessage: EVMSignMessage
-});
+const MAINNET = 0x68;
 
-function findMethod(message) {
-  const {
-    method
-  } = message.payload;
+class NEMGetAddress extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.hasBundle = false;
+  }
 
-  if (typeof method !== 'string') {
-    throw TypedError('Method_InvalidParameter', 'Method is not set');
+  init() {
+    var _a;
+
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+    const payload = this.hasBundle ? this.payload : {
+      bundle: [this.payload]
+    };
+    validateParams(payload, [{
+      name: 'bundle',
+      type: 'array'
+    }]);
+    this.params = [];
+    payload.bundle.forEach(batch => {
+      var _a;
+
+      const addressN = validatePath(batch.path, 3);
+      validateParams(batch, [{
+        name: 'path',
+        required: true
+      }, {
+        name: 'network',
+        type: 'number'
+      }, {
+        name: 'showOnOneKey',
+        type: 'boolean'
+      }]);
+      const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+      this.params.push({
+        address_n: addressN,
+        network: batch.network || MAINNET,
+        show_display: showOnOneKey
+      });
+    });
   }
 
-  const MethodConstructor = ApiMethods[method];
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const responses = [];
 
-  if (MethodConstructor) {
-    return new MethodConstructor(message);
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const res = yield this.device.commands.typedCall('NEMGetAddress', 'NEMAddress', Object.assign({}, param));
+        responses.push(Object.assign({
+          path: serializedPath(param.address_n)
+        }, res.message));
+      }
+
+      return Promise.resolve(this.hasBundle ? responses : responses[0]);
+    });
   }
 
-  throw TypedError('Method_InvalidParameter', `Method ${method} is not set`);
 }
 
-const resolveAfter = (msec, value) => new Promise(resolve => {
-  setTimeout(resolve, msec, value);
-});
+const NEM_TRANSFER = 0x0101;
+const NEM_COSIGNING = 0x0102;
+const NEM_IMPORTANCE_TRANSFER = 0x0801;
+const NEM_AGGREGATE_MODIFICATION = 0x1001;
+const NEM_MULTISIG_SIGNATURE = 0x1002;
+const NEM_MULTISIG = 0x1004;
+const NEM_PROVISION_NAMESPACE = 0x2001;
+const NEM_MOSAIC_CREATION = 0x4001;
+const NEM_SUPPLY_CHANGE = 0x4002;
 
-const Log$1 = initLog('DeviceConnector');
+class NEMSignTransaction extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.NEM_MOSAIC_LEVY_TYPES = {
+      1: 'MosaicLevy_Absolute',
+      2: 'MosaicLevy_Percentile'
+    };
+    this.NEM_SUPPLY_CHANGE_TYPES = {
+      1: 'SupplyChange_Increase',
+      2: 'SupplyChange_Decrease'
+    };
+    this.NEM_AGGREGATE_MODIFICATION_TYPES = {
+      1: 'CosignatoryModification_Add',
+      2: 'CosignatoryModification_Delete'
+    };
+    this.NEM_IMPORTANCE_TRANSFER_MODES = {
+      1: 'ImportanceTransfer_Activate',
+      2: 'ImportanceTransfer_Deactivate'
+    };
+
+    this.getCommon = (tx, address_n) => {
+      var _a;
+
+      return {
+        address_n,
+        network: tx.version >> 24 & 0xff,
+        timestamp: tx.timeStamp,
+        fee: tx.fee,
+        deadline: (_a = tx.deadline) !== null && _a !== void 0 ? _a : 0,
+        signer: address_n ? undefined : tx.signer
+      };
+    };
+
+    this.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
+      };
+    };
+
+    this.importanceTransferMessage = tx => ({
+      mode: this.NEM_IMPORTANCE_TRANSFER_MODES[tx.importanceTransfer.mode],
+      public_key: tx.importanceTransfer.publicKey
+    });
+
+    this.aggregateModificationMessage = tx => {
+      const modifications = tx.modifications ? tx.modifications.map(modification => ({
+        type: this.NEM_AGGREGATE_MODIFICATION_TYPES[modification.modificationType],
+        public_key: modification.cosignatoryAccount
+      })) : undefined;
+      return {
+        modifications,
+        relative_change: tx.minCosignatories.relativeChange
+      };
+    };
+
+    this.provisionNamespaceMessage = tx => {
+      var _a, _b, _c;
+
+      return {
+        namespace: (_a = tx.newPart) !== null && _a !== void 0 ? _a : '',
+        parent: tx.parent || undefined,
+        sink: (_b = tx.rentalFeeSink) !== null && _b !== void 0 ? _b : '',
+        fee: (_c = tx.rentalFee) !== null && _c !== void 0 ? _c : 0
+      };
+    };
+
+    this.mosaicCreationMessage = tx => {
+      var _a, _b;
+
+      const {
+        levy
+      } = tx.mosaicDefinition;
+      const definition = {
+        namespace: tx.mosaicDefinition.id.namespaceId,
+        mosaic: tx.mosaicDefinition.id.name,
+        levy: levy && levy.type ? this.NEM_MOSAIC_LEVY_TYPES[levy.type] : undefined,
+        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);
+              break;
+
+            case 'initialSupply':
+              definition.supply = parseInt(value);
+              break;
+
+            case 'supplyMutable':
+              definition.mutable_supply = value === 'true';
+              break;
+
+            case 'transferable':
+              definition.transferable = value === 'true';
+              break;
+          }
+        });
+      }
+
+      return {
+        definition,
+        sink: (_a = tx.creationFeeSink) !== null && _a !== void 0 ? _a : '',
+        fee: (_b = tx.creationFee) !== null && _b !== void 0 ? _b : 0
+      };
+    };
+
+    this.supplyChangeMessage = tx => {
+      var _a;
+
+      return {
+        namespace: tx.mosaicId.namespaceId,
+        mosaic: tx.mosaicId.name,
+        type: this.NEM_SUPPLY_CHANGE_TYPES[tx.supplyType],
+        delta: (_a = tx.delta) !== null && _a !== void 0 ? _a : 0
+      };
+    };
+
+    this.parseTx = (tx, address_n) => {
+      let transaction = tx;
+      const message = {
+        transaction: this.getCommon(tx, address_n),
+        transfer: undefined,
+        importance_transfer: undefined,
+        aggregate_modification: undefined,
+        provision_namespace: undefined,
+        mosaic_creation: undefined,
+        supply_change: undefined
+      };
+
+      if (tx.type === NEM_COSIGNING || tx.type === NEM_MULTISIG || tx.type === NEM_MULTISIG_SIGNATURE) {
+        message.cosigning = tx.type === NEM_COSIGNING || tx.type === NEM_MULTISIG_SIGNATURE;
+        transaction = tx.otherTrans;
+        message.multisig = this.getCommon(transaction);
+      }
+
+      switch (transaction.type) {
+        case NEM_TRANSFER:
+          message.transfer = this.transferMessage(transaction);
+          break;
+
+        case NEM_IMPORTANCE_TRANSFER:
+          message.importance_transfer = this.importanceTransferMessage(transaction);
+          break;
+
+        case NEM_AGGREGATE_MODIFICATION:
+          message.aggregate_modification = this.aggregateModificationMessage(transaction);
+          break;
+
+        case NEM_PROVISION_NAMESPACE:
+          message.provision_namespace = this.provisionNamespaceMessage(transaction);
+          break;
+
+        case NEM_MOSAIC_CREATION:
+          message.mosaic_creation = this.mosaicCreationMessage(transaction);
+          break;
+
+        case NEM_SUPPLY_CHANGE:
+          message.supply_change = this.supplyChangeMessage(transaction);
+          break;
+
+        default:
+          throw TypedError('Method_InvalidParameter', 'Unknown transaction type');
+      }
+
+      return message;
+    };
+  }
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    validateParams(this.payload, [{
+      name: 'path',
+      required: true
+    }, {
+      name: 'transaction',
+      type: 'object',
+      required: true
+    }]);
+    const {
+      path,
+      transaction
+    } = this.payload;
+    const addressN = validatePath(path, 3);
+    this.params = this.parseTx(transaction, addressN);
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('NEMSignTx', 'NEMSignedTx', Object.assign({}, this.params));
+      return Promise.resolve(res);
+    });
+  }
+
+}
+
+class SolGetAddress extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.hasBundle = false;
+  }
+
+  init() {
+    var _a;
+
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+    const payload = this.hasBundle ? this.payload : {
+      bundle: [this.payload]
+    };
+    validateParams(payload, [{
+      name: 'bundle',
+      type: 'array'
+    }]);
+    this.params = [];
+    payload.bundle.forEach(batch => {
+      var _a;
+
+      const addressN = validatePath(batch.path, 3);
+      validateParams(batch, [{
+        name: 'path',
+        required: true
+      }, {
+        name: 'showOnOneKey',
+        type: 'boolean'
+      }]);
+      const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey
+      });
+    });
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const responses = [];
+
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const res = yield this.device.commands.typedCall('SolanaGetAddress', 'SolanaAddress', Object.assign({}, param));
+        const {
+          address
+        } = res.message;
+        responses.push({
+          path: serializedPath(param.address_n),
+          address
+        });
+      }
+
+      return Promise.resolve(this.hasBundle ? responses : responses[0]);
+    });
+  }
+
+}
+
+class SolSignTransaction extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.hasBundle = false;
+  }
+
+  init() {
+    var _a;
+
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+    const payload = this.hasBundle ? this.payload : {
+      bundle: [this.payload]
+    };
+    validateParams(payload, [{
+      name: 'bundle',
+      type: 'array'
+    }]);
+    this.params = [];
+    payload.bundle.forEach(batch => {
+      const addressN = validatePath(batch.path, 3);
+      validateParams(batch, [{
+        name: 'path',
+        required: true
+      }, {
+        name: 'rawTx',
+        type: 'hexString',
+        required: true
+      }]);
+      this.params.push({
+        address_n: addressN,
+        raw_tx: formatAnyHex(batch.rawTx)
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      classic: {
+        min: '2.1.9'
+      },
+      mini: {
+        min: '2.1.9'
+      }
+    };
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const responses = [];
+
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const res = yield this.device.commands.typedCall('SolanaSignTx', 'SolanaSignedTx', Object.assign({}, param));
+        const {
+          signature
+        } = res.message;
+        responses.push({
+          path: serializedPath(param.address_n),
+          signature
+        });
+      }
+
+      return Promise.resolve(this.hasBundle ? responses : responses[0]);
+    });
+  }
+
+}
+
+class StellarGetAddress extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.hasBundle = false;
+  }
+
+  init() {
+    var _a;
+
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+    const payload = this.hasBundle ? this.payload : {
+      bundle: [this.payload]
+    };
+    validateParams(payload, [{
+      name: 'bundle',
+      type: 'array'
+    }]);
+    this.params = [];
+    payload.bundle.forEach(batch => {
+      var _a;
+
+      const addressN = validatePath(batch.path, 3);
+      validateParams(batch, [{
+        name: 'path',
+        required: true
+      }, {
+        name: 'showOnOneKey',
+        type: 'boolean'
+      }]);
+      const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey
+      });
+    });
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const responses = [];
+
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const res = yield this.device.commands.typedCall('StellarGetAddress', 'StellarAddress', Object.assign({}, param));
+        const {
+          address
+        } = res.message;
+        responses.push({
+          path: serializedPath(param.address_n),
+          address
+        });
+      }
+
+      return Promise.resolve(this.hasBundle ? responses : responses[0]);
+    });
+  }
+
+}
+
+class StellarSignTransaction extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.operations = [];
+
+    this.parseOperation = op => {
+      switch (op.type) {
+        case 'createAccount':
+          validateParams(op, [{
+            name: 'destination',
+            type: 'string',
+            required: true
+          }, {
+            name: 'startingBalance',
+            type: 'bigNumber',
+            required: true
+          }]);
+          return {
+            type: 'StellarCreateAccountOp',
+            source_account: op.source,
+            new_account: op.destination,
+            starting_balance: op.startingBalance
+          };
+
+        case 'payment':
+          validateParams(op, [{
+            name: 'destination',
+            type: 'string',
+            required: true
+          }, {
+            name: 'amount',
+            type: 'bigNumber',
+            required: true
+          }, {
+            name: 'asset',
+            required: true
+          }]);
+          return {
+            type: 'StellarPaymentOp',
+            source_account: op.source,
+            destination_account: op.destination,
+            asset: op.asset,
+            amount: op.amount
+          };
+
+        case 'pathPayment':
+          validateParams(op, [{
+            name: 'destAmount',
+            type: 'bigNumber',
+            required: true
+          }]);
+          return {
+            type: 'StellarPathPaymentOp',
+            source_account: op.source,
+            send_asset: op.sendAsset,
+            send_max: op.sendMax,
+            destination_account: op.destination,
+            destination_asset: op.destAsset,
+            destination_amount: op.destAmount,
+            paths: op.path
+          };
+
+        case 'createPassiveOffer':
+          validateParams(op, [{
+            name: 'amount',
+            type: 'bigNumber',
+            required: true
+          }]);
+          return {
+            type: 'StellarCreatePassiveOfferOp',
+            source_account: op.source,
+            buying_asset: op.buying,
+            selling_asset: op.selling,
+            amount: op.amount,
+            price_n: op.price.n,
+            price_d: op.price.d
+          };
+
+        case 'manageOffer':
+          validateParams(op, [{
+            name: 'amount',
+            type: 'bigNumber',
+            required: true
+          }]);
+          return {
+            type: 'StellarManageOfferOp',
+            source_account: op.source,
+            buying_asset: op.buying,
+            selling_asset: op.selling,
+            amount: op.amount,
+            offer_id: op.offerId,
+            price_n: op.price.n,
+            price_d: op.price.d
+          };
+
+        case 'setOptions':
+          {
+            const signer = op.signer ? {
+              signer_type: op.signer.type,
+              signer_key: op.signer.key,
+              signer_weight: op.signer.weight
+            } : undefined;
+            return Object.assign({
+              type: 'StellarSetOptionsOp',
+              source_account: op.source,
+              clear_flags: op.clearFlags,
+              set_flags: op.setFlags,
+              master_weight: op.masterWeight,
+              low_threshold: op.lowThreshold,
+              medium_threshold: op.medThreshold,
+              high_threshold: op.highThreshold,
+              home_domain: op.homeDomain,
+              inflation_destination_account: op.inflationDest
+            }, signer);
+          }
+
+        case 'changeTrust':
+          validateParams(op, [{
+            name: 'limit',
+            type: 'bigNumber'
+          }]);
+          return {
+            type: 'StellarChangeTrustOp',
+            source_account: op.source,
+            asset: op.line,
+            limit: op.limit
+          };
+
+        case 'allowTrust':
+          return {
+            type: 'StellarAllowTrustOp',
+            source_account: op.source,
+            trusted_account: op.trustor,
+            asset_type: op.assetType,
+            asset_code: op.assetCode,
+            is_authorized: op.authorize ? 1 : 0
+          };
+
+        case 'accountMerge':
+          return {
+            type: 'StellarAccountMergeOp',
+            source_account: op.source,
+            destination_account: op.destination
+          };
+
+        case 'manageData':
+          return {
+            type: 'StellarManageDataOp',
+            source_account: op.source,
+            key: op.name,
+            value: op.value
+          };
+
+        case 'bumpSequence':
+          return {
+            type: 'StellarBumpSequenceOp',
+            source_account: op.source,
+            bump_to: op.bumpTo
+          };
+
+        default:
+          return {};
+      }
+    };
+
+    this.processTxRequest = (operations, index) => __awaiter(this, void 0, void 0, function* () {
+      const isLastOp = index + 1 >= operations.length;
+
+      const _a = operations[index],
+            {
+        type
+      } = _a,
+            op = __rest(_a, ["type"]);
+
+      if (isLastOp) {
+        const response = yield this.device.commands.typedCall(type, 'StellarSignedTx', op);
+        return response.message;
+      }
+
+      yield this.device.commands.typedCall(type, 'StellarTxOpRequest', op);
+      return this.processTxRequest(operations, index + 1);
+    });
+  }
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    validateParams(this.payload, [{
+      name: 'path',
+      required: true
+    }, {
+      name: 'networkPassphrase',
+      type: 'string',
+      required: true
+    }, {
+      name: 'transaction',
+      type: 'object',
+      required: true
+    }]);
+    const addressN = validatePath(this.payload.path, 3);
+    const {
+      transaction,
+      networkPassphrase
+    } = this.payload;
+    this.params = {
+      address_n: addressN,
+      network_passphrase: networkPassphrase,
+      source_account: transaction.source,
+      fee: transaction.fee,
+      sequence_number: transaction.sequence,
+      num_operations: transaction.operations.length
+    };
+
+    if (transaction.timebounds) {
+      this.params.timebounds_start = transaction.timebounds.minTime;
+      this.params.timebounds_end = transaction.timebounds.maxTime;
+    }
+
+    if (transaction.memo) {
+      this.params.memo_type = transaction.memo.type;
+      this.params.memo_text = transaction.memo.text;
+      this.params.memo_id = transaction.memo.id;
+      this.params.memo_hash = transaction.memo.hash;
+    }
+
+    transaction.operations.forEach(op => {
+      const transformed = this.parseOperation(op);
+
+      if (transformed) {
+        this.operations.push(transformed);
+      }
+    });
+    console.log('StellarSignTransactionParams', this.params);
+    console.log('StellarSignTransactionOperations', this.operations);
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.device.commands.typedCall('StellarSignTx', 'StellarTxOpRequest', Object.assign({}, this.params));
+      return this.processTxRequest(this.operations, 0);
+    });
+  }
+
+}
+
+var ApiMethods = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  searchDevices: SearchDevices,
+  getFeatures: GetFeatures,
+  cipherKeyValue: CipherKeyValue,
+  btcGetAddress: BTCGetAddress,
+  btcGetPublicKey: BTCGetPublicKey,
+  btcSignMessage: BTCSignMessage,
+  btcSignTransaction: BTCSignTransaction,
+  btcVerifyMessage: BTCVerifyMessage,
+  checkFirmwareRelease: CheckFirmwareRelease,
+  checkBLEFirmwareRelease: CheckBLEFirmwareRelease,
+  checkTransportRelease: CheckTransportRelease,
+  deviceBackup: DeviceBackup,
+  deviceChangePin: DeviceChangePin,
+  deviceFlags: DeviceFlags,
+  deviceRebootToBootloader: DeviceRebootToBootloader,
+  deviceRecovery: DeviceRecovery,
+  deviceReset: DeviceReset,
+  deviceSettings: DeviceSettings,
+  deviceUpdateReboot: DeviceUpdateReboot,
+  deviceWipe: DeviceWipe,
+  evmGetAddress: EvmGetAddress,
+  evmGetPublicKey: EVMGetPublicKey,
+  evmSignMessage: EVMSignMessage$2,
+  evmSignMessageEIP712: EVMSignMessageEIP712,
+  evmSignTransaction: EVMSignTransaction,
+  evmSignTypedData: EVMSignTypedData,
+  evmVerifyMessage: EVMSignMessage$1,
+  starcoinGetAddress: StarcoinGetAddress,
+  starcoinGetPublicKey: StarcoinGetPublicKey,
+  starcoinSignMessage: StarcoinSignMessage,
+  starcoinSignTransaction: StarcoinSignTransaction,
+  starcoinVerifyMessage: EVMSignMessage,
+  nemGetAddress: NEMGetAddress,
+  nemSignTransaction: NEMSignTransaction,
+  solGetAddress: SolGetAddress,
+  solSignTransaction: SolSignTransaction,
+  stellarGetAddress: StellarGetAddress,
+  stellarSignTransaction: StellarSignTransaction
+});
+
+function findMethod(message) {
+  const {
+    method
+  } = message.payload;
+
+  if (typeof method !== 'string') {
+    throw TypedError('Method_InvalidParameter', 'Method is not set');
+  }
+
+  const MethodConstructor = ApiMethods[method];
+
+  if (MethodConstructor) {
+    return new MethodConstructor(message);
+  }
+
+  throw TypedError('Method_InvalidParameter', `Method ${method} is not set`);
+}
+
+const resolveAfter = (msec, value) => new Promise(resolve => {
+  setTimeout(resolve, msec, value);
+});
+
+const Log$1 = initLog('DeviceConnector');
 
 const getDiff = (current, descriptors) => {
   const env = DataManager.getSettings('env');
@@ -17362,6 +18312,24 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
 
   try {
     const inner = () => __awaiter(void 0, void 0, void 0, function* () {
+      const deviceType = getDeviceType(device.features);
+      const deviceModel = getDeviceModel(device.features);
+      const versionRangeType = method.getVersionRange()[deviceType];
+      const versionRangeModel = method.getVersionRange()[deviceModel];
+      const versionRange = versionRangeType !== null && versionRangeType !== void 0 ? versionRangeType : versionRangeModel;
+
+      if (versionRange && device.features) {
+        const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+
+        if (semver__default["default"].valid(versionRange.min) && semver__default["default"].lt(currentVersion, versionRange.min)) {
+          return Promise.reject(TypedError('Device_FwException', `Device firmware version is too low, please update to ${versionRange.min}`));
+        }
+
+        if (versionRange.max && semver__default["default"].valid(versionRange.max) && semver__default["default"].gt(currentVersion, versionRange.max)) {
+          return Promise.reject(TypedError('Device_FwException', `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`));
+        }
+      }
+
       const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
 
       if (unexpectedMode) {
@@ -17399,6 +18367,7 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
   } catch (error) {
     messageResponse = createResponseMessage(method.responseID, false, error);
     _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.reject(TypedError('Call_API', error));
+    Log.debug('Call API - Run Error: ', error);
   } finally {
     const response = messageResponse;
 
@@ -17497,9 +18466,17 @@ const onDeviceButtonHandler = (...[device, request]) => {
   postMessage(createDeviceMessage(DEVICE.BUTTON, Object.assign(Object.assign({}, request), {
     device: device.toMessageObject()
   })));
-  postMessage(createUiMessage(UI_REQUEST$1.REQUEST_BUTTON, {
-    device: device.toMessageObject()
-  }));
+
+  if (request.code === 'ButtonRequest_PinEntry') {
+    postMessage(createUiMessage(UI_REQUEST$1.REQUEST_PIN, {
+      device: device.toMessageObject(),
+      type: 'ButtonRequest_PinEntry'
+    }));
+  } else {
+    postMessage(createUiMessage(UI_REQUEST$1.REQUEST_BUTTON, {
+      device: device.toMessageObject()
+    }));
+  }
 };
 
 const postMessage = message => {
@@ -17636,6 +18613,8 @@ exports.ZP = HardwareSdk;
 exports.yI = enableLog;
 __webpack_unused_export__ = getDeviceLabel;
 __webpack_unused_export__ = getDeviceType;
+__webpack_unused_export__ = getDeviceTypeByBleName;
+__webpack_unused_export__ = getDeviceTypeByDeviceId;
 __webpack_unused_export__ = getDeviceUUID;
 __webpack_unused_export__ = getEnv;
 __webpack_unused_export__ = getHDPath;
@@ -17895,6 +18874,7 @@ const MESSAGE_TOP_CHAR = 0x003f;
 const MESSAGE_HEADER_BYTE = 0x23;
 const HEADER_SIZE = 1 + 1 + 4 + 2;
 const BUFFER_SIZE = 63;
+const COMMON_HEADER_SIZE = 6;
 
 const readHeader = buffer => {
   const typeId = buffer.readUint16();
@@ -18663,6 +19643,7 @@ var index = {
   parseConfigure
 };
 exports.BUFFER_SIZE = BUFFER_SIZE;
+exports.COMMON_HEADER_SIZE = COMMON_HEADER_SIZE;
 exports.HEADER_SIZE = HEADER_SIZE;
 exports.MESSAGE_HEADER_BYTE = MESSAGE_HEADER_BYTE;
 exports.MESSAGE_TOP_CHAR = MESSAGE_TOP_CHAR;