@onekeyfe/hd-web-sdk 0.1.8 → 0.1.11

package/build/onekey-js-sdk.js

@@ -4086,6 +4086,9 @@ const inject = ({
     checkTransportRelease: () => call({
       method: 'checkTransportRelease'
     }),
+    checkBridgeStatus: () => call({
+      method: 'checkBridgeStatus'
+    }),
     cipherKeyValue: (connectId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
       method: 'cipherKeyValue'
@@ -4122,6 +4125,10 @@ const inject = ({
       connectId,
       method: 'deviceUpdateReboot'
     }),
+    deviceVerify: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      method: 'deviceVerify'
+    })),
     deviceWipe: connectId => call({
       connectId,
       method: 'deviceWipe'
@@ -4968,6 +4975,18 @@ const versionCompare = (a, b) => {
   return 0;
 };
 
+function patchFeatures(response) {
+  if (response.type !== 'Features') {
+    return response;
+  }
+
+  if (response.message.major_version < 1) {
+    response.message.major_version = 1;
+  }
+
+  return response;
+}
+
 const getDeviceModel = features => {
   if (!features || typeof features !== 'object') {
     return 'model_mini';
@@ -4992,6 +5011,18 @@ const getDeviceType = features => {
   return 'classic';
 };
 
+const getDeviceTypeOnBootloader = features => {
+  if (!features || typeof features !== 'object') {
+    return 'classic';
+  }
+
+  if (features.model === 'T') {
+    return 'touch';
+  }
+
+  return getDeviceType(features);
+};
+
 const getDeviceTypeByBleName = name => {
   if (!name) return 'classic';
   if (name.startsWith('MI')) return 'mini';
@@ -14311,7 +14342,7 @@ class DeviceCommands {
     }
 
     if (res.type === 'Features') {
-      return Promise.resolve(res);
+      return Promise.resolve(patchFeatures(res));
     }
 
     if (res.type === 'ButtonRequest') {
@@ -14508,7 +14539,7 @@ class Device extends events.exports {
     return {
       connectId: env === 'react-native' ? this.mainId || null : getDeviceUUID(this.features),
       uuid: getDeviceUUID(this.features),
-      deviceType: getDeviceType(this.features),
+      deviceType: this.features.bootloader_mode ? getDeviceTypeOnBootloader(this.features) : getDeviceType(this.features),
       deviceId: this.features.device_id || null,
       path: this.originalDescriptor.path,
       name: this.features.ble_name || this.features.label || `OneKey ${getDeviceType(this.features).toUpperCase()}`,
@@ -16317,6 +16348,25 @@ class CheckTransportRelease extends BaseMethod {
 
 }
 
+class CheckBridgeStatus extends BaseMethod {
+  init() {
+    this.useDevice = false;
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      return new Promise(resolve => {
+        axios__default["default"].request({
+          url: 'http://localhost:21320',
+          method: 'POST',
+          withCredentials: false
+        }).then(() => resolve(true)).catch(() => resolve(false));
+      });
+    });
+  }
+
+}
+
 class DeviceBackup extends BaseMethod {
   init() {}
 
@@ -16568,6 +16618,43 @@ class DeviceUpdateReboot extends BaseMethod {
 
 }
 
+class DeviceVerify extends BaseMethod {
+  init() {
+    validateParams(this.payload, [{
+      name: 'dataHex',
+      type: 'hexString'
+    }]);
+    this.params = {
+      data: formatAnyHex(this.payload.dataHex)
+    };
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const deviceType = getDeviceType(this.device.features);
+      let response;
+
+      if (deviceType === 'classic') {
+        const res = yield this.device.commands.typedCall('BixinVerifyDeviceRequest', 'BixinVerifyDeviceAck', Object.assign({}, this.params));
+        response = res.message;
+      } else if (deviceType === 'mini') {
+        const signatureRes = yield this.device.commands.typedCall('SESignMessage', 'SEMessageSignature', {
+          message: this.params.data
+        });
+        const certRes = yield this.device.commands.typedCall('ReadSEPublicCert', 'SEPublicCert');
+        response = {
+          cert: certRes.message.public_cert,
+          signature: signatureRes.message.signature
+        };
+      }
+
+      if (response) return Promise.resolve(response);
+      return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device not support verify'));
+    });
+  }
+
+}
+
 class DeviceWipe extends BaseMethod {
   init() {}
 
@@ -16990,6 +17077,147 @@ class EVMSignTransaction extends BaseMethod {
 
 }
 
+const twosComplement = (number, bytes) => {
+  if (bytes < 1 || bytes > 32) {
+    throw hdShared.ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
+  }
+
+  const minValue = new BigNumber__default["default"](2).exponentiatedBy(bytes * 8 - 1).negated();
+  const maxValue = minValue.negated().minus(1);
+  const bigNumber = new BigNumber__default["default"](number);
+
+  if (bigNumber.isGreaterThan(maxValue) || bigNumber.isLessThan(minValue)) {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`);
+  }
+
+  if (bigNumber.isPositive()) {
+    return bigNumber;
+  }
+
+  return bigNumber.minus(minValue).minus(minValue);
+};
+
+const intToHex = (number, bytes, signed) => {
+  let bigNumber = new BigNumber__default["default"](number);
+
+  if (signed) {
+    bigNumber = twosComplement(bigNumber, bytes);
+  }
+
+  if (bigNumber.isNegative()) {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Cannot convert negative number to unsigned interger: ${number.toString()}`);
+  }
+
+  const hex = bigNumber.toString(16);
+  const hexChars = bytes * 2;
+
+  if (hex.length > hexChars) {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`);
+  }
+
+  return hex.padStart(bytes * 2, '0');
+};
+
+const paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
+const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
+const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
+
+const parseArrayType = arrayTypeName => {
+  const arrayMatch = paramTypeArray.exec(arrayTypeName);
+
+  if (arrayMatch === null) {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `typename ${arrayTypeName} could not be parsed as an EIP-712 array`);
+  }
+
+  const [_, entryTypeName, arraySize] = arrayMatch;
+  return {
+    entryTypeName,
+    arraySize: parseInt(arraySize, 10) || null
+  };
+};
+
+const encodeData = (typeName, data) => {
+  if (paramTypeBytes.test(typeName) || typeName === 'address') {
+    return formatAnyHex(data);
+  }
+
+  if (typeName === 'string') {
+    return Buffer.from(data, 'utf-8').toString('hex');
+  }
+
+  const numberMatch = paramTypeNumber.exec(typeName);
+
+  if (numberMatch) {
+    const [_, intType, bits] = numberMatch;
+    const bytes = Math.ceil(parseInt(bits, 10) / 8);
+    return intToHex(data, bytes, intType === 'int');
+  }
+
+  if (typeName === 'bool') {
+    return data ? '01' : '00';
+  }
+
+  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Unsupported data type for direct field encoding: ${typeName}`);
+};
+
+const paramTypesMap = {
+  string: hdTransport.EthereumDataType.STRING,
+  bool: hdTransport.EthereumDataType.BOOL,
+  address: hdTransport.EthereumDataType.ADDRESS
+};
+
+const getFieldType = (typeName, types) => {
+  const arrayMatch = paramTypeArray.exec(typeName);
+
+  if (arrayMatch) {
+    const [_, arrayItemTypeName, arraySize] = arrayMatch;
+    const entryType = getFieldType(arrayItemTypeName, types);
+    return {
+      data_type: hdTransport.EthereumDataType.ARRAY,
+      size: parseInt(arraySize, 10) || undefined,
+      entry_type: entryType
+    };
+  }
+
+  const numberMatch = paramTypeNumber.exec(typeName);
+
+  if (numberMatch) {
+    const [_, type, bits] = numberMatch;
+    return {
+      data_type: type === 'uint' ? hdTransport.EthereumDataType.UINT : hdTransport.EthereumDataType.INT,
+      size: Math.floor(parseInt(bits, 10) / 8)
+    };
+  }
+
+  const bytesMatch = paramTypeBytes.exec(typeName);
+
+  if (bytesMatch) {
+    const [_, size] = bytesMatch;
+    return {
+      data_type: hdTransport.EthereumDataType.BYTES,
+      size: parseInt(size, 10) || undefined
+    };
+  }
+
+  const fixedSizeTypeMatch = paramTypesMap[typeName];
+
+  if (fixedSizeTypeMatch) {
+    return {
+      data_type: fixedSizeTypeMatch
+    };
+  }
+
+  if (typeName in types) {
+    return {
+      data_type: hdTransport.EthereumDataType.STRUCT,
+      size: types[typeName].length,
+      struct_name: typeName
+    };
+  }
+
+  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `No type definition specified: ${typeName}`);
+};
+
 class EVMSignTypedData extends BaseMethod {
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
@@ -17034,6 +17262,112 @@ class EVMSignTypedData extends BaseMethod {
     }
   }
 
+  signTypedData() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const {
+        commands
+      } = this.device;
+      const {
+        addressN,
+        data,
+        metamaskV4Compat
+      } = this.params;
+      const {
+        types,
+        primaryType,
+        domain,
+        message
+      } = data;
+      let response = yield commands.typedCall('EthereumSignTypedData', ['EthereumTypedDataStructRequest', 'EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'], {
+        address_n: addressN,
+        primary_type: primaryType,
+        metamask_v4_compat: metamaskV4Compat
+      });
+
+      while (response.type === 'EthereumTypedDataStructRequest') {
+        const {
+          name: typeDefinitionName
+        } = response.message;
+        const typeDefinition = types[typeDefinitionName];
+
+        if (typeDefinition === undefined) {
+          throw hdShared.ERRORS.TypedError('Runtime', `Type ${typeDefinitionName} was not defined in types object`);
+        }
+
+        const dataStruckAck = {
+          members: typeDefinition.map(({
+            name,
+            type: typeName
+          }) => ({
+            name,
+            type: getFieldType(typeName, types)
+          }))
+        };
+        response = yield commands.typedCall('EthereumTypedDataStructAck', ['EthereumTypedDataStructRequest', 'EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'], dataStruckAck);
+      }
+
+      while (response.type === 'EthereumTypedDataValueRequest') {
+        const {
+          member_path
+        } = response.message;
+        let memberData;
+        let memberTypeName;
+        const [rootIndex, ...nestedMemberPath] = member_path;
+
+        switch (rootIndex) {
+          case 0:
+            memberData = domain;
+            memberTypeName = 'EIP712Domain';
+            break;
+
+          case 1:
+            memberData = message;
+            memberTypeName = primaryType;
+            break;
+
+          default:
+            throw hdShared.ERRORS.TypedError('Runtime', 'Root index can only be 0 or 1');
+        }
+
+        for (const index of nestedMemberPath) {
+          if (Array.isArray(memberData)) {
+            memberTypeName = parseArrayType(memberTypeName).entryTypeName;
+            memberData = memberData[index];
+          } else if (typeof memberData === 'object' && memberData !== null) {
+            const memberTypeDefinition = types[memberTypeName][index];
+            memberTypeName = memberTypeDefinition.type;
+            memberData = memberData[memberTypeDefinition.name];
+          } else ;
+        }
+
+        let encodedData;
+
+        if (Array.isArray(memberData)) {
+          encodedData = encodeData('uint16', memberData.length);
+        } else {
+          encodedData = encodeData(memberTypeName, memberData);
+        }
+
+        response = yield commands.typedCall('EthereumTypedDataValueAck', ['EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'], {
+          value: encodedData
+        });
+      }
+
+      if (response.type !== 'EthereumTypedDataSignature') {
+        throw hdShared.ERRORS.TypedError('Runtime', 'Unexpected response type');
+      }
+
+      const {
+        address,
+        signature
+      } = response.message;
+      return {
+        address,
+        signature
+      };
+    });
+  }
+
   getVersionRange() {
     return {
       model_mini: {
@@ -17101,7 +17435,7 @@ class EVMSignTypedData extends BaseMethod {
         return Promise.resolve(response.message);
       }
 
-      return Promise.resolve(hdShared.ERRORS.TypedError('Runtime', 'Not implemented'));
+      return this.signTypedData();
     });
   }
 
@@ -18272,6 +18606,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   checkFirmwareRelease: CheckFirmwareRelease,
   checkBLEFirmwareRelease: CheckBLEFirmwareRelease,
   checkTransportRelease: CheckTransportRelease,
+  checkBridgeStatus: CheckBridgeStatus,
   deviceBackup: DeviceBackup,
   deviceChangePin: DeviceChangePin,
   deviceFlags: DeviceFlags,
@@ -18280,6 +18615,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   deviceReset: DeviceReset,
   deviceSettings: DeviceSettings,
   deviceUpdateReboot: DeviceUpdateReboot,
+  deviceVerify: DeviceVerify,
   deviceWipe: DeviceWipe,
   evmGetAddress: EvmGetAddress,
   evmGetPublicKey: EVMGetPublicKey,
@@ -18921,6 +19257,7 @@ __webpack_unused_export__ = isValidVersionString;
 __webpack_unused_export__ = normalizeVersionArray;
 exports._4 = parseConnectSettings;
 exports.kW = parseMessage;
+__webpack_unused_export__ = patchFeatures;
 __webpack_unused_export__ = safeThrowError;
 __webpack_unused_export__ = versionCompare;
 __webpack_unused_export__ = versionSplit;
@@ -19408,33 +19745,33 @@ var check = /*#__PURE__*/Object.freeze({
   acquire: acquire,
   call: call
 });
-var BinanceOrderType;
+exports.BinanceOrderType = void 0;
 
 (function (BinanceOrderType) {
   BinanceOrderType[BinanceOrderType["OT_UNKNOWN"] = 0] = "OT_UNKNOWN";
   BinanceOrderType[BinanceOrderType["MARKET"] = 1] = "MARKET";
   BinanceOrderType[BinanceOrderType["LIMIT"] = 2] = "LIMIT";
   BinanceOrderType[BinanceOrderType["OT_RESERVED"] = 3] = "OT_RESERVED";
-})(BinanceOrderType || (BinanceOrderType = {}));
+})(exports.BinanceOrderType || (exports.BinanceOrderType = {}));
 
-var BinanceOrderSide;
+exports.BinanceOrderSide = void 0;
 
 (function (BinanceOrderSide) {
   BinanceOrderSide[BinanceOrderSide["SIDE_UNKNOWN"] = 0] = "SIDE_UNKNOWN";
   BinanceOrderSide[BinanceOrderSide["BUY"] = 1] = "BUY";
   BinanceOrderSide[BinanceOrderSide["SELL"] = 2] = "SELL";
-})(BinanceOrderSide || (BinanceOrderSide = {}));
+})(exports.BinanceOrderSide || (exports.BinanceOrderSide = {}));
 
-var BinanceTimeInForce;
+exports.BinanceTimeInForce = void 0;
 
 (function (BinanceTimeInForce) {
   BinanceTimeInForce[BinanceTimeInForce["TIF_UNKNOWN"] = 0] = "TIF_UNKNOWN";
   BinanceTimeInForce[BinanceTimeInForce["GTE"] = 1] = "GTE";
   BinanceTimeInForce[BinanceTimeInForce["TIF_RESERVED"] = 2] = "TIF_RESERVED";
   BinanceTimeInForce[BinanceTimeInForce["IOC"] = 3] = "IOC";
-})(BinanceTimeInForce || (BinanceTimeInForce = {}));
+})(exports.BinanceTimeInForce || (exports.BinanceTimeInForce = {}));
 
-var Enum_InputScriptType;
+exports.Enum_InputScriptType = void 0;
 
 (function (Enum_InputScriptType) {
   Enum_InputScriptType[Enum_InputScriptType["SPENDADDRESS"] = 0] = "SPENDADDRESS";
@@ -19443,9 +19780,9 @@ var Enum_InputScriptType;
   Enum_InputScriptType[Enum_InputScriptType["SPENDWITNESS"] = 3] = "SPENDWITNESS";
   Enum_InputScriptType[Enum_InputScriptType["SPENDP2SHWITNESS"] = 4] = "SPENDP2SHWITNESS";
   Enum_InputScriptType[Enum_InputScriptType["SPENDTAPROOT"] = 5] = "SPENDTAPROOT";
-})(Enum_InputScriptType || (Enum_InputScriptType = {}));
+})(exports.Enum_InputScriptType || (exports.Enum_InputScriptType = {}));
 
-var Enum_OutputScriptType;
+exports.Enum_OutputScriptType = void 0;
 
 (function (Enum_OutputScriptType) {
   Enum_OutputScriptType[Enum_OutputScriptType["PAYTOADDRESS"] = 0] = "PAYTOADDRESS";
@@ -19455,25 +19792,25 @@ var Enum_OutputScriptType;
   Enum_OutputScriptType[Enum_OutputScriptType["PAYTOWITNESS"] = 4] = "PAYTOWITNESS";
   Enum_OutputScriptType[Enum_OutputScriptType["PAYTOP2SHWITNESS"] = 5] = "PAYTOP2SHWITNESS";
   Enum_OutputScriptType[Enum_OutputScriptType["PAYTOTAPROOT"] = 6] = "PAYTOTAPROOT";
-})(Enum_OutputScriptType || (Enum_OutputScriptType = {}));
+})(exports.Enum_OutputScriptType || (exports.Enum_OutputScriptType = {}));
 
-var DecredStakingSpendType;
+exports.DecredStakingSpendType = void 0;
 
 (function (DecredStakingSpendType) {
   DecredStakingSpendType[DecredStakingSpendType["SSGen"] = 0] = "SSGen";
   DecredStakingSpendType[DecredStakingSpendType["SSRTX"] = 1] = "SSRTX";
-})(DecredStakingSpendType || (DecredStakingSpendType = {}));
+})(exports.DecredStakingSpendType || (exports.DecredStakingSpendType = {}));
 
-var AmountUnit;
+exports.AmountUnit = void 0;
 
 (function (AmountUnit) {
   AmountUnit[AmountUnit["BITCOIN"] = 0] = "BITCOIN";
   AmountUnit[AmountUnit["MILLIBITCOIN"] = 1] = "MILLIBITCOIN";
   AmountUnit[AmountUnit["MICROBITCOIN"] = 2] = "MICROBITCOIN";
   AmountUnit[AmountUnit["SATOSHI"] = 3] = "SATOSHI";
-})(AmountUnit || (AmountUnit = {}));
+})(exports.AmountUnit || (exports.AmountUnit = {}));
 
-var Enum_RequestType;
+exports.Enum_RequestType = void 0;
 
 (function (Enum_RequestType) {
   Enum_RequestType[Enum_RequestType["TXINPUT"] = 0] = "TXINPUT";
@@ -19484,17 +19821,17 @@ var Enum_RequestType;
   Enum_RequestType[Enum_RequestType["TXORIGINPUT"] = 5] = "TXORIGINPUT";
   Enum_RequestType[Enum_RequestType["TXORIGOUTPUT"] = 6] = "TXORIGOUTPUT";
   Enum_RequestType[Enum_RequestType["TXPAYMENTREQ"] = 7] = "TXPAYMENTREQ";
-})(Enum_RequestType || (Enum_RequestType = {}));
+})(exports.Enum_RequestType || (exports.Enum_RequestType = {}));
 
-var CardanoDerivationType;
+exports.CardanoDerivationType = void 0;
 
 (function (CardanoDerivationType) {
   CardanoDerivationType[CardanoDerivationType["LEDGER"] = 0] = "LEDGER";
   CardanoDerivationType[CardanoDerivationType["ICARUS"] = 1] = "ICARUS";
   CardanoDerivationType[CardanoDerivationType["ICARUS_TREZOR"] = 2] = "ICARUS_TREZOR";
-})(CardanoDerivationType || (CardanoDerivationType = {}));
+})(exports.CardanoDerivationType || (exports.CardanoDerivationType = {}));
 
-var CardanoAddressType;
+exports.CardanoAddressType = void 0;
 
 (function (CardanoAddressType) {
   CardanoAddressType[CardanoAddressType["BASE"] = 0] = "BASE";
@@ -19508,9 +19845,9 @@ var CardanoAddressType;
   CardanoAddressType[CardanoAddressType["BYRON"] = 8] = "BYRON";
   CardanoAddressType[CardanoAddressType["REWARD"] = 14] = "REWARD";
   CardanoAddressType[CardanoAddressType["REWARD_SCRIPT"] = 15] = "REWARD_SCRIPT";
-})(CardanoAddressType || (CardanoAddressType = {}));
+})(exports.CardanoAddressType || (exports.CardanoAddressType = {}));
 
-var CardanoNativeScriptType;
+exports.CardanoNativeScriptType = void 0;
 
 (function (CardanoNativeScriptType) {
   CardanoNativeScriptType[CardanoNativeScriptType["PUB_KEY"] = 0] = "PUB_KEY";
@@ -19519,57 +19856,57 @@ var CardanoNativeScriptType;
   CardanoNativeScriptType[CardanoNativeScriptType["N_OF_K"] = 3] = "N_OF_K";
   CardanoNativeScriptType[CardanoNativeScriptType["INVALID_BEFORE"] = 4] = "INVALID_BEFORE";
   CardanoNativeScriptType[CardanoNativeScriptType["INVALID_HEREAFTER"] = 5] = "INVALID_HEREAFTER";
-})(CardanoNativeScriptType || (CardanoNativeScriptType = {}));
+})(exports.CardanoNativeScriptType || (exports.CardanoNativeScriptType = {}));
 
-var CardanoNativeScriptHashDisplayFormat;
+exports.CardanoNativeScriptHashDisplayFormat = void 0;
 
 (function (CardanoNativeScriptHashDisplayFormat) {
   CardanoNativeScriptHashDisplayFormat[CardanoNativeScriptHashDisplayFormat["HIDE"] = 0] = "HIDE";
   CardanoNativeScriptHashDisplayFormat[CardanoNativeScriptHashDisplayFormat["BECH32"] = 1] = "BECH32";
   CardanoNativeScriptHashDisplayFormat[CardanoNativeScriptHashDisplayFormat["POLICY_ID"] = 2] = "POLICY_ID";
-})(CardanoNativeScriptHashDisplayFormat || (CardanoNativeScriptHashDisplayFormat = {}));
+})(exports.CardanoNativeScriptHashDisplayFormat || (exports.CardanoNativeScriptHashDisplayFormat = {}));
 
-var CardanoCertificateType;
+exports.CardanoCertificateType = void 0;
 
 (function (CardanoCertificateType) {
   CardanoCertificateType[CardanoCertificateType["STAKE_REGISTRATION"] = 0] = "STAKE_REGISTRATION";
   CardanoCertificateType[CardanoCertificateType["STAKE_DEREGISTRATION"] = 1] = "STAKE_DEREGISTRATION";
   CardanoCertificateType[CardanoCertificateType["STAKE_DELEGATION"] = 2] = "STAKE_DELEGATION";
   CardanoCertificateType[CardanoCertificateType["STAKE_POOL_REGISTRATION"] = 3] = "STAKE_POOL_REGISTRATION";
-})(CardanoCertificateType || (CardanoCertificateType = {}));
+})(exports.CardanoCertificateType || (exports.CardanoCertificateType = {}));
 
-var CardanoPoolRelayType;
+exports.CardanoPoolRelayType = void 0;
 
 (function (CardanoPoolRelayType) {
   CardanoPoolRelayType[CardanoPoolRelayType["SINGLE_HOST_IP"] = 0] = "SINGLE_HOST_IP";
   CardanoPoolRelayType[CardanoPoolRelayType["SINGLE_HOST_NAME"] = 1] = "SINGLE_HOST_NAME";
   CardanoPoolRelayType[CardanoPoolRelayType["MULTIPLE_HOST_NAME"] = 2] = "MULTIPLE_HOST_NAME";
-})(CardanoPoolRelayType || (CardanoPoolRelayType = {}));
+})(exports.CardanoPoolRelayType || (exports.CardanoPoolRelayType = {}));
 
-var CardanoTxAuxiliaryDataSupplementType;
+exports.CardanoTxAuxiliaryDataSupplementType = void 0;
 
 (function (CardanoTxAuxiliaryDataSupplementType) {
   CardanoTxAuxiliaryDataSupplementType[CardanoTxAuxiliaryDataSupplementType["NONE"] = 0] = "NONE";
   CardanoTxAuxiliaryDataSupplementType[CardanoTxAuxiliaryDataSupplementType["CATALYST_REGISTRATION_SIGNATURE"] = 1] = "CATALYST_REGISTRATION_SIGNATURE";
-})(CardanoTxAuxiliaryDataSupplementType || (CardanoTxAuxiliaryDataSupplementType = {}));
+})(exports.CardanoTxAuxiliaryDataSupplementType || (exports.CardanoTxAuxiliaryDataSupplementType = {}));
 
-var CardanoTxSigningMode;
+exports.CardanoTxSigningMode = void 0;
 
 (function (CardanoTxSigningMode) {
   CardanoTxSigningMode[CardanoTxSigningMode["ORDINARY_TRANSACTION"] = 0] = "ORDINARY_TRANSACTION";
   CardanoTxSigningMode[CardanoTxSigningMode["POOL_REGISTRATION_AS_OWNER"] = 1] = "POOL_REGISTRATION_AS_OWNER";
   CardanoTxSigningMode[CardanoTxSigningMode["MULTISIG_TRANSACTION"] = 2] = "MULTISIG_TRANSACTION";
   CardanoTxSigningMode[CardanoTxSigningMode["PLUTUS_TRANSACTION"] = 3] = "PLUTUS_TRANSACTION";
-})(CardanoTxSigningMode || (CardanoTxSigningMode = {}));
+})(exports.CardanoTxSigningMode || (exports.CardanoTxSigningMode = {}));
 
-var CardanoTxWitnessType;
+exports.CardanoTxWitnessType = void 0;
 
 (function (CardanoTxWitnessType) {
   CardanoTxWitnessType[CardanoTxWitnessType["BYRON_WITNESS"] = 0] = "BYRON_WITNESS";
   CardanoTxWitnessType[CardanoTxWitnessType["SHELLEY_WITNESS"] = 1] = "SHELLEY_WITNESS";
-})(CardanoTxWitnessType || (CardanoTxWitnessType = {}));
+})(exports.CardanoTxWitnessType || (exports.CardanoTxWitnessType = {}));
 
-var FailureType;
+exports.FailureType = void 0;
 
 (function (FailureType) {
   FailureType[FailureType["Failure_UnexpectedMessage"] = 1] = "Failure_UnexpectedMessage";
@@ -19587,9 +19924,9 @@ var FailureType;
   FailureType[FailureType["Failure_WipeCodeMismatch"] = 13] = "Failure_WipeCodeMismatch";
   FailureType[FailureType["Failure_InvalidSession"] = 14] = "Failure_InvalidSession";
   FailureType[FailureType["Failure_FirmwareError"] = 99] = "Failure_FirmwareError";
-})(FailureType || (FailureType = {}));
+})(exports.FailureType || (exports.FailureType = {}));
 
-var Enum_ButtonRequestType;
+exports.Enum_ButtonRequestType = void 0;
 
 (function (Enum_ButtonRequestType) {
   Enum_ButtonRequestType[Enum_ButtonRequestType["ButtonRequest_Other"] = 1] = "ButtonRequest_Other";
@@ -19612,9 +19949,9 @@ var Enum_ButtonRequestType;
   Enum_ButtonRequestType[Enum_ButtonRequestType["ButtonRequest_Warning"] = 18] = "ButtonRequest_Warning";
   Enum_ButtonRequestType[Enum_ButtonRequestType["ButtonRequest_PassphraseEntry"] = 19] = "ButtonRequest_PassphraseEntry";
   Enum_ButtonRequestType[Enum_ButtonRequestType["ButtonRequest_PinEntry"] = 20] = "ButtonRequest_PinEntry";
-})(Enum_ButtonRequestType || (Enum_ButtonRequestType = {}));
+})(exports.Enum_ButtonRequestType || (exports.Enum_ButtonRequestType = {}));
 
-var Enum_PinMatrixRequestType;
+exports.Enum_PinMatrixRequestType = void 0;
 
 (function (Enum_PinMatrixRequestType) {
   Enum_PinMatrixRequestType[Enum_PinMatrixRequestType["PinMatrixRequestType_Current"] = 1] = "PinMatrixRequestType_Current";
@@ -19622,17 +19959,17 @@ var Enum_PinMatrixRequestType;
   Enum_PinMatrixRequestType[Enum_PinMatrixRequestType["PinMatrixRequestType_NewSecond"] = 3] = "PinMatrixRequestType_NewSecond";
   Enum_PinMatrixRequestType[Enum_PinMatrixRequestType["PinMatrixRequestType_WipeCodeFirst"] = 4] = "PinMatrixRequestType_WipeCodeFirst";
   Enum_PinMatrixRequestType[Enum_PinMatrixRequestType["PinMatrixRequestType_WipeCodeSecond"] = 5] = "PinMatrixRequestType_WipeCodeSecond";
-})(Enum_PinMatrixRequestType || (Enum_PinMatrixRequestType = {}));
+})(exports.Enum_PinMatrixRequestType || (exports.Enum_PinMatrixRequestType = {}));
 
-var DebugButton;
+exports.DebugButton = void 0;
 
 (function (DebugButton) {
   DebugButton[DebugButton["NO"] = 0] = "NO";
   DebugButton[DebugButton["YES"] = 1] = "YES";
   DebugButton[DebugButton["INFO"] = 2] = "INFO";
-})(DebugButton || (DebugButton = {}));
+})(exports.DebugButton || (exports.DebugButton = {}));
 
-var EthereumDataType;
+exports.EthereumDataType = void 0;
 
 (function (EthereumDataType) {
   EthereumDataType[EthereumDataType["UINT"] = 1] = "UINT";
@@ -19643,25 +19980,25 @@ var EthereumDataType;
   EthereumDataType[EthereumDataType["ADDRESS"] = 6] = "ADDRESS";
   EthereumDataType[EthereumDataType["ARRAY"] = 7] = "ARRAY";
   EthereumDataType[EthereumDataType["STRUCT"] = 8] = "STRUCT";
-})(EthereumDataType || (EthereumDataType = {}));
+})(exports.EthereumDataType || (exports.EthereumDataType = {}));
 
-var Enum_BackupType;
+exports.Enum_BackupType = void 0;
 
 (function (Enum_BackupType) {
   Enum_BackupType[Enum_BackupType["Bip39"] = 0] = "Bip39";
   Enum_BackupType[Enum_BackupType["Slip39_Basic"] = 1] = "Slip39_Basic";
   Enum_BackupType[Enum_BackupType["Slip39_Advanced"] = 2] = "Slip39_Advanced";
-})(Enum_BackupType || (Enum_BackupType = {}));
+})(exports.Enum_BackupType || (exports.Enum_BackupType = {}));
 
-var Enum_SafetyCheckLevel;
+exports.Enum_SafetyCheckLevel = void 0;
 
 (function (Enum_SafetyCheckLevel) {
   Enum_SafetyCheckLevel[Enum_SafetyCheckLevel["Strict"] = 0] = "Strict";
   Enum_SafetyCheckLevel[Enum_SafetyCheckLevel["PromptAlways"] = 1] = "PromptAlways";
   Enum_SafetyCheckLevel[Enum_SafetyCheckLevel["PromptTemporarily"] = 2] = "PromptTemporarily";
-})(Enum_SafetyCheckLevel || (Enum_SafetyCheckLevel = {}));
+})(exports.Enum_SafetyCheckLevel || (exports.Enum_SafetyCheckLevel = {}));
 
-var Enum_Capability;
+exports.Enum_Capability = void 0;
 
 (function (Enum_Capability) {
   Enum_Capability[Enum_Capability["Capability_Bitcoin"] = 1] = "Capability_Bitcoin";
@@ -19681,68 +20018,68 @@ var Enum_Capability;
   Enum_Capability[Enum_Capability["Capability_Shamir"] = 15] = "Capability_Shamir";
   Enum_Capability[Enum_Capability["Capability_ShamirGroups"] = 16] = "Capability_ShamirGroups";
   Enum_Capability[Enum_Capability["Capability_PassphraseEntry"] = 17] = "Capability_PassphraseEntry";
-})(Enum_Capability || (Enum_Capability = {}));
+})(exports.Enum_Capability || (exports.Enum_Capability = {}));
 
-var SdProtectOperationType;
+exports.SdProtectOperationType = void 0;
 
 (function (SdProtectOperationType) {
   SdProtectOperationType[SdProtectOperationType["DISABLE"] = 0] = "DISABLE";
   SdProtectOperationType[SdProtectOperationType["ENABLE"] = 1] = "ENABLE";
   SdProtectOperationType[SdProtectOperationType["REFRESH"] = 2] = "REFRESH";
-})(SdProtectOperationType || (SdProtectOperationType = {}));
+})(exports.SdProtectOperationType || (exports.SdProtectOperationType = {}));
 
-var RecoveryDeviceType;
+exports.RecoveryDeviceType = void 0;
 
 (function (RecoveryDeviceType) {
   RecoveryDeviceType[RecoveryDeviceType["RecoveryDeviceType_ScrambledWords"] = 0] = "RecoveryDeviceType_ScrambledWords";
   RecoveryDeviceType[RecoveryDeviceType["RecoveryDeviceType_Matrix"] = 1] = "RecoveryDeviceType_Matrix";
-})(RecoveryDeviceType || (RecoveryDeviceType = {}));
+})(exports.RecoveryDeviceType || (exports.RecoveryDeviceType = {}));
 
-var Enum_WordRequestType;
+exports.Enum_WordRequestType = void 0;
 
 (function (Enum_WordRequestType) {
   Enum_WordRequestType[Enum_WordRequestType["WordRequestType_Plain"] = 0] = "WordRequestType_Plain";
   Enum_WordRequestType[Enum_WordRequestType["WordRequestType_Matrix9"] = 1] = "WordRequestType_Matrix9";
   Enum_WordRequestType[Enum_WordRequestType["WordRequestType_Matrix6"] = 2] = "WordRequestType_Matrix6";
-})(Enum_WordRequestType || (Enum_WordRequestType = {}));
+})(exports.Enum_WordRequestType || (exports.Enum_WordRequestType = {}));
 
-var NEMMosaicLevy;
+exports.NEMMosaicLevy = void 0;
 
 (function (NEMMosaicLevy) {
   NEMMosaicLevy[NEMMosaicLevy["MosaicLevy_Absolute"] = 1] = "MosaicLevy_Absolute";
   NEMMosaicLevy[NEMMosaicLevy["MosaicLevy_Percentile"] = 2] = "MosaicLevy_Percentile";
-})(NEMMosaicLevy || (NEMMosaicLevy = {}));
+})(exports.NEMMosaicLevy || (exports.NEMMosaicLevy = {}));
 
-var NEMSupplyChangeType;
+exports.NEMSupplyChangeType = void 0;
 
 (function (NEMSupplyChangeType) {
   NEMSupplyChangeType[NEMSupplyChangeType["SupplyChange_Increase"] = 1] = "SupplyChange_Increase";
   NEMSupplyChangeType[NEMSupplyChangeType["SupplyChange_Decrease"] = 2] = "SupplyChange_Decrease";
-})(NEMSupplyChangeType || (NEMSupplyChangeType = {}));
+})(exports.NEMSupplyChangeType || (exports.NEMSupplyChangeType = {}));
 
-var NEMModificationType;
+exports.NEMModificationType = void 0;
 
 (function (NEMModificationType) {
   NEMModificationType[NEMModificationType["CosignatoryModification_Add"] = 1] = "CosignatoryModification_Add";
   NEMModificationType[NEMModificationType["CosignatoryModification_Delete"] = 2] = "CosignatoryModification_Delete";
-})(NEMModificationType || (NEMModificationType = {}));
+})(exports.NEMModificationType || (exports.NEMModificationType = {}));
 
-var NEMImportanceTransferMode;
+exports.NEMImportanceTransferMode = void 0;
 
 (function (NEMImportanceTransferMode) {
   NEMImportanceTransferMode[NEMImportanceTransferMode["ImportanceTransfer_Activate"] = 1] = "ImportanceTransfer_Activate";
   NEMImportanceTransferMode[NEMImportanceTransferMode["ImportanceTransfer_Deactivate"] = 2] = "ImportanceTransfer_Deactivate";
-})(NEMImportanceTransferMode || (NEMImportanceTransferMode = {}));
+})(exports.NEMImportanceTransferMode || (exports.NEMImportanceTransferMode = {}));
 
-var StellarAssetType;
+exports.StellarAssetType = void 0;
 
 (function (StellarAssetType) {
   StellarAssetType[StellarAssetType["NATIVE"] = 0] = "NATIVE";
   StellarAssetType[StellarAssetType["ALPHANUM4"] = 1] = "ALPHANUM4";
   StellarAssetType[StellarAssetType["ALPHANUM12"] = 2] = "ALPHANUM12";
-})(StellarAssetType || (StellarAssetType = {}));
+})(exports.StellarAssetType || (exports.StellarAssetType = {}));
 
-var StellarMemoType;
+exports.StellarMemoType = void 0;
 
 (function (StellarMemoType) {
   StellarMemoType[StellarMemoType["NONE"] = 0] = "NONE";
@@ -19750,180 +20087,180 @@ var StellarMemoType;
   StellarMemoType[StellarMemoType["ID"] = 2] = "ID";
   StellarMemoType[StellarMemoType["HASH"] = 3] = "HASH";
   StellarMemoType[StellarMemoType["RETURN"] = 4] = "RETURN";
-})(StellarMemoType || (StellarMemoType = {}));
+})(exports.StellarMemoType || (exports.StellarMemoType = {}));
 
-var StellarSignerType;
+exports.StellarSignerType = void 0;
 
 (function (StellarSignerType) {
   StellarSignerType[StellarSignerType["ACCOUNT"] = 0] = "ACCOUNT";
   StellarSignerType[StellarSignerType["PRE_AUTH"] = 1] = "PRE_AUTH";
   StellarSignerType[StellarSignerType["HASH"] = 2] = "HASH";
-})(StellarSignerType || (StellarSignerType = {}));
+})(exports.StellarSignerType || (exports.StellarSignerType = {}));
 
-var TezosContractType;
+exports.TezosContractType = void 0;
 
 (function (TezosContractType) {
   TezosContractType[TezosContractType["Implicit"] = 0] = "Implicit";
   TezosContractType[TezosContractType["Originated"] = 1] = "Originated";
-})(TezosContractType || (TezosContractType = {}));
+})(exports.TezosContractType || (exports.TezosContractType = {}));
 
-var TezosBallotType;
+exports.TezosBallotType = void 0;
 
 (function (TezosBallotType) {
   TezosBallotType[TezosBallotType["Yay"] = 0] = "Yay";
   TezosBallotType[TezosBallotType["Nay"] = 1] = "Nay";
   TezosBallotType[TezosBallotType["Pass"] = 2] = "Pass";
-})(TezosBallotType || (TezosBallotType = {}));
+})(exports.TezosBallotType || (exports.TezosBallotType = {}));
 
 var messages = /*#__PURE__*/Object.freeze({
   __proto__: null,
 
   get BinanceOrderType() {
-    return BinanceOrderType;
+    return exports.BinanceOrderType;
   },
 
   get BinanceOrderSide() {
-    return BinanceOrderSide;
+    return exports.BinanceOrderSide;
   },
 
   get BinanceTimeInForce() {
-    return BinanceTimeInForce;
+    return exports.BinanceTimeInForce;
   },
 
   get Enum_InputScriptType() {
-    return Enum_InputScriptType;
+    return exports.Enum_InputScriptType;
   },
 
   get Enum_OutputScriptType() {
-    return Enum_OutputScriptType;
+    return exports.Enum_OutputScriptType;
   },
 
   get DecredStakingSpendType() {
-    return DecredStakingSpendType;
+    return exports.DecredStakingSpendType;
   },
 
   get AmountUnit() {
-    return AmountUnit;
+    return exports.AmountUnit;
   },
 
   get Enum_RequestType() {
-    return Enum_RequestType;
+    return exports.Enum_RequestType;
   },
 
   get CardanoDerivationType() {
-    return CardanoDerivationType;
+    return exports.CardanoDerivationType;
   },
 
   get CardanoAddressType() {
-    return CardanoAddressType;
+    return exports.CardanoAddressType;
   },
 
   get CardanoNativeScriptType() {
-    return CardanoNativeScriptType;
+    return exports.CardanoNativeScriptType;
   },
 
   get CardanoNativeScriptHashDisplayFormat() {
-    return CardanoNativeScriptHashDisplayFormat;
+    return exports.CardanoNativeScriptHashDisplayFormat;
   },
 
   get CardanoCertificateType() {
-    return CardanoCertificateType;
+    return exports.CardanoCertificateType;
   },
 
   get CardanoPoolRelayType() {
-    return CardanoPoolRelayType;
+    return exports.CardanoPoolRelayType;
   },
 
   get CardanoTxAuxiliaryDataSupplementType() {
-    return CardanoTxAuxiliaryDataSupplementType;
+    return exports.CardanoTxAuxiliaryDataSupplementType;
   },
 
   get CardanoTxSigningMode() {
-    return CardanoTxSigningMode;
+    return exports.CardanoTxSigningMode;
   },
 
   get CardanoTxWitnessType() {
-    return CardanoTxWitnessType;
+    return exports.CardanoTxWitnessType;
   },
 
   get FailureType() {
-    return FailureType;
+    return exports.FailureType;
   },
 
   get Enum_ButtonRequestType() {
-    return Enum_ButtonRequestType;
+    return exports.Enum_ButtonRequestType;
   },
 
   get Enum_PinMatrixRequestType() {
-    return Enum_PinMatrixRequestType;
+    return exports.Enum_PinMatrixRequestType;
   },
 
   get DebugButton() {
-    return DebugButton;
+    return exports.DebugButton;
   },
 
   get EthereumDataType() {
-    return EthereumDataType;
+    return exports.EthereumDataType;
   },
 
   get Enum_BackupType() {
-    return Enum_BackupType;
+    return exports.Enum_BackupType;
   },
 
   get Enum_SafetyCheckLevel() {
-    return Enum_SafetyCheckLevel;
+    return exports.Enum_SafetyCheckLevel;
   },
 
   get Enum_Capability() {
-    return Enum_Capability;
+    return exports.Enum_Capability;
   },
 
   get SdProtectOperationType() {
-    return SdProtectOperationType;
+    return exports.SdProtectOperationType;
   },
 
   get RecoveryDeviceType() {
-    return RecoveryDeviceType;
+    return exports.RecoveryDeviceType;
   },
 
   get Enum_WordRequestType() {
-    return Enum_WordRequestType;
+    return exports.Enum_WordRequestType;
   },
 
   get NEMMosaicLevy() {
-    return NEMMosaicLevy;
+    return exports.NEMMosaicLevy;
   },
 
   get NEMSupplyChangeType() {
-    return NEMSupplyChangeType;
+    return exports.NEMSupplyChangeType;
   },
 
   get NEMModificationType() {
-    return NEMModificationType;
+    return exports.NEMModificationType;
   },
 
   get NEMImportanceTransferMode() {
-    return NEMImportanceTransferMode;
+    return exports.NEMImportanceTransferMode;
   },
 
   get StellarAssetType() {
-    return StellarAssetType;
+    return exports.StellarAssetType;
   },
 
   get StellarMemoType() {
-    return StellarMemoType;
+    return exports.StellarMemoType;
   },
 
   get StellarSignerType() {
-    return StellarSignerType;
+    return exports.StellarSignerType;
   },
 
   get TezosContractType() {
-    return TezosContractType;
+    return exports.TezosContractType;
   },
 
   get TezosBallotType() {
-    return TezosBallotType;
+    return exports.TezosBallotType;
   }
 
 });