@onekeyfe/hd-web-sdk 0.1.43 → 0.1.44

package/build/onekey-js-sdk.js

@@ -27041,15 +27041,6 @@ var HardwareError$1 = /*#__PURE__*/Object.freeze({
   CreateErrorByMessage: CreateErrorByMessage
 });
 
-// EXTERNAL MODULE: ../../node_modules/axios/index.js
-var axios = __webpack_require__(9644);
-var axios_default = /*#__PURE__*/__webpack_require__.n(axios);
-// EXTERNAL MODULE: ../../node_modules/bignumber.js/bignumber.js
-var bignumber = __webpack_require__(6391);
-var bignumber_default = /*#__PURE__*/__webpack_require__.n(bignumber);
-// EXTERNAL MODULE: ../../node_modules/js-sha256/src/sha256.js
-var sha256 = __webpack_require__(1965);
-var sha256_default = /*#__PURE__*/__webpack_require__.n(sha256);
 // EXTERNAL MODULE: ../../node_modules/protobufjs/light.js
 var light = __webpack_require__(3448);
 // EXTERNAL MODULE: ../../node_modules/long/src/long.js
@@ -27611,7 +27602,6 @@ var Enum_RequestType;
   Enum_RequestType[Enum_RequestType["TXEXTRADATA"] = 4] = "TXEXTRADATA";
   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 = {}));
 
 var CardanoDerivationType;
@@ -27687,7 +27677,6 @@ var 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 = {}));
 
 var CardanoTxWitnessType;
@@ -27750,16 +27739,10 @@ 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["PinMatrixRequestType_BackupFirst"] = 6] = "PinMatrixRequestType_BackupFirst";
+  Enum_PinMatrixRequestType[Enum_PinMatrixRequestType["PinMatrixRequestType_BackupSecond"] = 7] = "PinMatrixRequestType_BackupSecond";
 })(Enum_PinMatrixRequestType || (Enum_PinMatrixRequestType = {}));
 
-var DebugButton;
-
-(function (DebugButton) {
-  DebugButton[DebugButton["NO"] = 0] = "NO";
-  DebugButton[DebugButton["YES"] = 1] = "YES";
-  DebugButton[DebugButton["INFO"] = 2] = "INFO";
-})(DebugButton || (DebugButton = {}));
-
 var EthereumDataType;
 
 (function (EthereumDataType) {
@@ -27811,6 +27794,14 @@ var Enum_Capability;
   Enum_Capability[Enum_Capability["Capability_PassphraseEntry"] = 17] = "Capability_PassphraseEntry";
 })(Enum_Capability || (Enum_Capability = {}));
 
+var ExportType;
+
+(function (ExportType) {
+  ExportType[ExportType["SeedEncExportType_NO"] = 0] = "SeedEncExportType_NO";
+  ExportType[ExportType["SeedEncExportType_YES"] = 1] = "SeedEncExportType_YES";
+  ExportType[ExportType["MnemonicPlainExportType_YES"] = 2] = "MnemonicPlainExportType_YES";
+})(ExportType || (ExportType = {}));
+
 var SdProtectOperationType;
 
 (function (SdProtectOperationType) {
@@ -27834,6 +27825,22 @@ var Enum_WordRequestType;
   Enum_WordRequestType[Enum_WordRequestType["WordRequestType_Matrix6"] = 2] = "WordRequestType_Matrix6";
 })(Enum_WordRequestType || (Enum_WordRequestType = {}));
 
+var SeedRequestType;
+
+(function (SeedRequestType) {
+  SeedRequestType[SeedRequestType["SeedRequestType_Gen"] = 0] = "SeedRequestType_Gen";
+  SeedRequestType[SeedRequestType["SeedRequestType_EncExport"] = 1] = "SeedRequestType_EncExport";
+  SeedRequestType[SeedRequestType["SeedRequestType_EncImport"] = 2] = "SeedRequestType_EncImport";
+})(SeedRequestType || (SeedRequestType = {}));
+
+var WL_OperationType;
+
+(function (WL_OperationType) {
+  WL_OperationType[WL_OperationType["WL_OperationType_Add"] = 0] = "WL_OperationType_Add";
+  WL_OperationType[WL_OperationType["WL_OperationType_Delete"] = 1] = "WL_OperationType_Delete";
+  WL_OperationType[WL_OperationType["WL_OperationType_Inquire"] = 2] = "WL_OperationType_Inquire";
+})(WL_OperationType || (WL_OperationType = {}));
+
 var NEMMosaicLevy;
 
 (function (NEMMosaicLevy) {
@@ -27903,6 +27910,13 @@ var TezosBallotType;
   TezosBallotType[TezosBallotType["Pass"] = 2] = "Pass";
 })(TezosBallotType || (TezosBallotType = {}));
 
+var CommandFlags;
+
+(function (CommandFlags) {
+  CommandFlags[CommandFlags["Default"] = 0] = "Default";
+  CommandFlags[CommandFlags["Factory_Only"] = 1] = "Factory_Only";
+})(CommandFlags || (CommandFlags = {}));
+
 var messages = /*#__PURE__*/Object.freeze({
   __proto__: null,
 
@@ -27986,10 +28000,6 @@ var messages = /*#__PURE__*/Object.freeze({
     return Enum_PinMatrixRequestType;
   },
 
-  get DebugButton() {
-    return DebugButton;
-  },
-
   get EthereumDataType() {
     return EthereumDataType;
   },
@@ -28006,6 +28016,10 @@ var messages = /*#__PURE__*/Object.freeze({
     return Enum_Capability;
   },
 
+  get ExportType() {
+    return ExportType;
+  },
+
   get SdProtectOperationType() {
     return SdProtectOperationType;
   },
@@ -28018,6 +28032,14 @@ var messages = /*#__PURE__*/Object.freeze({
     return Enum_WordRequestType;
   },
 
+  get SeedRequestType() {
+    return SeedRequestType;
+  },
+
+  get WL_OperationType() {
+    return WL_OperationType;
+  },
+
   get NEMMosaicLevy() {
     return NEMMosaicLevy;
   },
@@ -28052,6 +28074,10 @@ var messages = /*#__PURE__*/Object.freeze({
 
   get TezosBallotType() {
     return TezosBallotType;
+  },
+
+  get CommandFlags() {
+    return CommandFlags;
   }
 
 });
@@ -28067,6 +28093,15 @@ var index = {
   decodeProtocol
 };
 
+// EXTERNAL MODULE: ../../node_modules/axios/index.js
+var axios = __webpack_require__(9644);
+var axios_default = /*#__PURE__*/__webpack_require__.n(axios);
+// EXTERNAL MODULE: ../../node_modules/bignumber.js/bignumber.js
+var bignumber = __webpack_require__(6391);
+var bignumber_default = /*#__PURE__*/__webpack_require__.n(bignumber);
+// EXTERNAL MODULE: ../../node_modules/js-sha256/src/sha256.js
+var sha256 = __webpack_require__(1965);
+var sha256_default = /*#__PURE__*/__webpack_require__.n(sha256);
 ;// CONCATENATED MODULE: ../core/dist/index.js
 
 
@@ -28297,7 +28332,62 @@ const inject = ({
     })),
     requestWebUsbDevice: () => call({
       method: 'requestWebUsbDevice'
-    })
+    }),
+    tronGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'tronGetAddress'
+    })),
+    tronSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'tronSignMessage'
+    })),
+    tronSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'tronSignTransaction'
+    })),
+    confluxGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'confluxGetAddress'
+    })),
+    confluxSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'confluxSignMessage'
+    })),
+    confluxSignMessageCIP23: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'confluxSignMessageCIP23'
+    })),
+    confluxSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'confluxSignTransaction'
+    })),
+    nearGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'nearGetAddress'
+    })),
+    nearSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'nearSignTransaction'
+    })),
+    aptosGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'aptosGetAddress'
+    })),
+    aptosSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'aptosSignTransaction'
+    }))
   };
   return api;
 };
@@ -29014,13 +29104,15 @@ const getDeviceTypeByDeviceId = deviceId => {
 };
 
 const getDeviceUUID = features => {
+  var _a, _b;
+
   const deviceType = getDeviceType(features);
 
   if (deviceType === 'classic') {
-    return features.onekey_serial;
+    return (_a = features.onekey_serial) !== null && _a !== void 0 ? _a : '';
   }
 
-  return features.serial_no;
+  return (_b = features.serial_no) !== null && _b !== void 0 ? _b : '';
 };
 
 const getDeviceLabel = features => {
@@ -29107,6 +29199,61 @@ const getPassphraseState = (features, commands) => dist_awaiter(void 0, void 0,
 });
 
 var nested = {
+  AptosGetAddress: {
+    fields: {
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
+      },
+      show_display: {
+        type: "bool",
+        id: 2
+      }
+    }
+  },
+  AptosAddress: {
+    fields: {
+      address: {
+        type: "string",
+        id: 1
+      }
+    }
+  },
+  AptosSignTx: {
+    fields: {
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
+      },
+      raw_tx: {
+        rule: "required",
+        type: "bytes",
+        id: 2
+      }
+    }
+  },
+  AptosSignedTx: {
+    fields: {
+      public_key: {
+        rule: "required",
+        type: "bytes",
+        id: 1
+      },
+      signature: {
+        rule: "required",
+        type: "bytes",
+        id: 2
+      }
+    }
+  },
   BinanceGetAddress: {
     fields: {
       address_n: {
@@ -31723,7 +31870,7 @@ var nested = {
   BixinPinInputOnDevice: {
     fields: {}
   },
-  CipherKeyValue: {
+  ConfluxGetAddress: {
     fields: {
       address_n: {
         rule: "repeated",
@@ -31733,130 +31880,286 @@ var nested = {
           packed: false
         }
       },
-      key: {
-        rule: "required",
-        type: "string",
+      show_display: {
+        type: "bool",
         id: 2
       },
-      value: {
-        rule: "required",
-        type: "bytes",
+      chain_id: {
+        type: "uint32",
         id: 3
-      },
-      encrypt: {
-        type: "bool",
-        id: 4
-      },
-      ask_on_encrypt: {
-        type: "bool",
-        id: 5
-      },
-      ask_on_decrypt: {
-        type: "bool",
-        id: 6
-      },
-      iv: {
-        type: "bytes",
-        id: 7
       }
     }
   },
-  CipheredKeyValue: {
+  ConfluxAddress: {
     fields: {
-      value: {
-        rule: "required",
-        type: "bytes",
+      address: {
+        type: "string",
         id: 1
       }
     }
   },
-  IdentityType: {
+  ConfluxSignTx: {
     fields: {
-      proto: {
-        type: "string",
-        id: 1
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
       },
-      user: {
-        type: "string",
+      nonce: {
+        type: "bytes",
         id: 2
       },
-      host: {
-        type: "string",
+      gas_price: {
+        type: "bytes",
         id: 3
       },
-      port: {
-        type: "string",
+      gas_limit: {
+        type: "bytes",
         id: 4
       },
-      path: {
+      to: {
         type: "string",
         id: 5
       },
-      index: {
-        type: "uint32",
-        id: 6,
-        options: {
-          "default": 0
-        }
-      }
-    }
-  },
-  SignIdentity: {
-    fields: {
-      identity: {
-        rule: "required",
-        type: "IdentityType",
-        id: 1
+      value: {
+        type: "bytes",
+        id: 6
       },
-      challenge_hidden: {
+      epoch_height: {
         type: "bytes",
-        id: 2,
-        options: {
-          "default": ""
-        }
+        id: 7
       },
-      challenge_visual: {
-        type: "string",
-        id: 3,
-        options: {
-          "default": ""
-        }
+      storage_limit: {
+        type: "bytes",
+        id: 8
       },
-      ecdsa_curve_name: {
-        type: "string",
-        id: 4
+      data_initial_chunk: {
+        type: "bytes",
+        id: 9
+      },
+      data_length: {
+        type: "uint32",
+        id: 10
+      },
+      chain_id: {
+        type: "uint32",
+        id: 11
       }
     }
   },
-  SignedIdentity: {
+  ConfluxTxRequest: {
     fields: {
-      address: {
-        type: "string",
+      data_length: {
+        type: "uint32",
         id: 1
       },
-      public_key: {
-        rule: "required",
-        type: "bytes",
+      signature_v: {
+        type: "uint32",
         id: 2
       },
-      signature: {
-        rule: "required",
+      signature_r: {
         type: "bytes",
         id: 3
+      },
+      signature_s: {
+        type: "bytes",
+        id: 4
       }
     }
   },
-  GetECDHSessionKey: {
+  ConfluxTxAck: {
     fields: {
-      identity: {
-        rule: "required",
-        type: "IdentityType",
-        id: 1
-      },
-      peer_public_key: {
-        rule: "required",
+      data_chunk: {
         type: "bytes",
-        id: 2
+        id: 1
+      }
+    }
+  },
+  ConfluxSignMessage: {
+    fields: {
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
+      },
+      message: {
+        type: "bytes",
+        id: 2
+      }
+    }
+  },
+  ConfluxMessageSignature: {
+    fields: {
+      signature: {
+        type: "bytes",
+        id: 2
+      },
+      address: {
+        type: "string",
+        id: 3
+      }
+    }
+  },
+  ConfluxSignMessageCIP23: {
+    fields: {
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
+      },
+      domain_hash: {
+        type: "bytes",
+        id: 2
+      },
+      message_hash: {
+        type: "bytes",
+        id: 3
+      }
+    }
+  },
+  CipherKeyValue: {
+    fields: {
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
+      },
+      key: {
+        rule: "required",
+        type: "string",
+        id: 2
+      },
+      value: {
+        rule: "required",
+        type: "bytes",
+        id: 3
+      },
+      encrypt: {
+        type: "bool",
+        id: 4
+      },
+      ask_on_encrypt: {
+        type: "bool",
+        id: 5
+      },
+      ask_on_decrypt: {
+        type: "bool",
+        id: 6
+      },
+      iv: {
+        type: "bytes",
+        id: 7
+      }
+    }
+  },
+  CipheredKeyValue: {
+    fields: {
+      value: {
+        rule: "required",
+        type: "bytes",
+        id: 1
+      }
+    }
+  },
+  IdentityType: {
+    fields: {
+      proto: {
+        type: "string",
+        id: 1
+      },
+      user: {
+        type: "string",
+        id: 2
+      },
+      host: {
+        type: "string",
+        id: 3
+      },
+      port: {
+        type: "string",
+        id: 4
+      },
+      path: {
+        type: "string",
+        id: 5
+      },
+      index: {
+        type: "uint32",
+        id: 6,
+        options: {
+          "default": 0
+        }
+      }
+    }
+  },
+  SignIdentity: {
+    fields: {
+      identity: {
+        rule: "required",
+        type: "IdentityType",
+        id: 1
+      },
+      challenge_hidden: {
+        type: "bytes",
+        id: 2,
+        options: {
+          "default": ""
+        }
+      },
+      challenge_visual: {
+        type: "string",
+        id: 3,
+        options: {
+          "default": ""
+        }
+      },
+      ecdsa_curve_name: {
+        type: "string",
+        id: 4
+      }
+    }
+  },
+  SignedIdentity: {
+    fields: {
+      address: {
+        type: "string",
+        id: 1
+      },
+      public_key: {
+        rule: "required",
+        type: "bytes",
+        id: 2
+      },
+      signature: {
+        rule: "required",
+        type: "bytes",
+        id: 3
+      }
+    }
+  },
+  GetECDHSessionKey: {
+    fields: {
+      identity: {
+        rule: "required",
+        type: "IdentityType",
+        id: 1
+      },
+      peer_public_key: {
+        rule: "required",
+        type: "bytes",
+        id: 2
       },
       ecdsa_curve_name: {
         type: "string",
@@ -33407,6 +33710,10 @@ var nested = {
       coin_switch: {
         type: "uint32",
         id: 517
+      },
+      build_id: {
+        type: "string",
+        id: 518
       }
     },
     nested: {
@@ -35095,6 +35402,55 @@ var nested = {
       }
     }
   },
+  NearGetAddress: {
+    fields: {
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
+      },
+      show_display: {
+        type: "bool",
+        id: 2
+      }
+    }
+  },
+  NearAddress: {
+    fields: {
+      address: {
+        type: "string",
+        id: 1
+      }
+    }
+  },
+  NearSignTx: {
+    fields: {
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
+      },
+      raw_tx: {
+        type: "bytes",
+        id: 2
+      }
+    }
+  },
+  NearSignedTx: {
+    fields: {
+      signature: {
+        rule: "required",
+        type: "bytes",
+        id: 1
+      }
+    }
+  },
   NEMGetAddress: {
     fields: {
       address_n: {
@@ -35611,6 +35967,7 @@ var nested = {
         }
       },
       raw_tx: {
+        rule: "required",
         type: "bytes",
         id: 2
       }
@@ -36647,28 +37004,193 @@ var nested = {
       }
     }
   },
-  WebAuthnListResidentCredentials: {
-    fields: {}
-  },
-  WebAuthnAddResidentCredential: {
+  TronGetAddress: {
     fields: {
-      credential_id: {
-        type: "bytes",
-        id: 1
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
+      },
+      show_display: {
+        type: "bool",
+        id: 2
       }
     }
   },
-  WebAuthnRemoveResidentCredential: {
+  TronAddress: {
     fields: {
-      index: {
-        type: "uint32",
+      address: {
+        type: "string",
         id: 1
       }
     }
   },
-  WebAuthnCredentials: {
+  TronSignTx: {
     fields: {
-      credentials: {
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
+      },
+      ref_block_bytes: {
+        rule: "required",
+        type: "bytes",
+        id: 2
+      },
+      ref_block_hash: {
+        rule: "required",
+        type: "bytes",
+        id: 3
+      },
+      expiration: {
+        rule: "required",
+        type: "uint64",
+        id: 4
+      },
+      data: {
+        type: "string",
+        id: 5
+      },
+      contract: {
+        rule: "required",
+        type: "TronContract",
+        id: 6
+      },
+      timestamp: {
+        rule: "required",
+        type: "uint64",
+        id: 7
+      },
+      fee_limit: {
+        type: "uint64",
+        id: 8
+      }
+    },
+    nested: {
+      TronContract: {
+        fields: {
+          transfer_contract: {
+            type: "TronTransferContract",
+            id: 2
+          },
+          trigger_smart_contract: {
+            type: "TronTriggerSmartContract",
+            id: 31
+          }
+        },
+        nested: {
+          TronTransferContract: {
+            fields: {
+              to_address: {
+                type: "string",
+                id: 2
+              },
+              amount: {
+                type: "uint64",
+                id: 3
+              }
+            }
+          },
+          TronTriggerSmartContract: {
+            fields: {
+              contract_address: {
+                type: "string",
+                id: 2
+              },
+              call_value: {
+                type: "uint64",
+                id: 3
+              },
+              data: {
+                type: "bytes",
+                id: 4
+              },
+              call_token_value: {
+                type: "uint64",
+                id: 5
+              },
+              asset_id: {
+                type: "uint64",
+                id: 6
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  TronSignedTx: {
+    fields: {
+      signature: {
+        rule: "required",
+        type: "bytes",
+        id: 1
+      },
+      serialized_tx: {
+        type: "bytes",
+        id: 2
+      }
+    }
+  },
+  TronSignMessage: {
+    fields: {
+      address_n: {
+        rule: "repeated",
+        type: "uint32",
+        id: 1,
+        options: {
+          packed: false
+        }
+      },
+      message: {
+        rule: "required",
+        type: "bytes",
+        id: 2
+      }
+    }
+  },
+  TronMessageSignature: {
+    fields: {
+      address: {
+        rule: "required",
+        type: "bytes",
+        id: 1
+      },
+      signature: {
+        rule: "required",
+        type: "bytes",
+        id: 2
+      }
+    }
+  },
+  WebAuthnListResidentCredentials: {
+    fields: {}
+  },
+  WebAuthnAddResidentCredential: {
+    fields: {
+      credential_id: {
+        type: "bytes",
+        id: 1
+      }
+    }
+  },
+  WebAuthnRemoveResidentCredential: {
+    fields: {
+      index: {
+        type: "uint32",
+        id: 1
+      }
+    }
+  },
+  WebAuthnCredentials: {
+    fields: {
+      credentials: {
         rule: "repeated",
         type: "WebAuthnCredential",
         id: 1
@@ -37041,6 +37563,20 @@ var nested = {
       MessageType_StarcoinSignMessage: 10306,
       MessageType_StarcoinMessageSignature: 10307,
       MessageType_StarcoinVerifyMessage: 10308,
+      MessageType_ConfluxGetAddress: 10401,
+      MessageType_ConfluxAddress: 10402,
+      MessageType_ConfluxSignTx: 10403,
+      MessageType_ConfluxTxRequest: 10404,
+      MessageType_ConfluxTxAck: 10405,
+      MessageType_ConfluxSignMessage: 10406,
+      MessageType_ConfluxSignMessageCIP23: 10407,
+      MessageType_ConfluxMessageSignature: 10408,
+      MessageType_ConfluxVerifyMessage: 10409,
+      MessageType_ConfluxVerifyMessageCIP23: 10410,
+      MessageType_AptosGetAddress: 10600,
+      MessageType_AptosAddress: 10601,
+      MessageType_AptosSignTx: 10602,
+      MessageType_AptosSignedTx: 10603,
       MessageType_WebAuthnListResidentCredentials: 800,
       MessageType_WebAuthnCredentials: 801,
       MessageType_WebAuthnAddResidentCredential: 802,
@@ -37064,6 +37600,16 @@ var nested = {
       MessageType_EthereumSignMessageEIP712: 10200,
       MessageType_GetPublicKeyMultiple: 10210,
       MessageType_PublicKeyMultiple: 10211,
+      MessageType_TronGetAddress: 10501,
+      MessageType_TronAddress: 10502,
+      MessageType_TronSignTx: 10503,
+      MessageType_TronSignedTx: 10504,
+      MessageType_TronSignMessage: 10505,
+      MessageType_TronMessageSignature: 10506,
+      MessageType_NearGetAddress: 10701,
+      MessageType_NearAddress: 10702,
+      MessageType_NearSignTx: 10703,
+      MessageType_NearSignedTx: 10704,
       MessageType_DeviceInfoSettings: 10001,
       MessageType_GetDeviceInfo: 10002,
       MessageType_DeviceInfo: 10003,
@@ -38840,23 +39386,23 @@ class DeviceCommands {
       } = res.message;
       let error = null;
 
-      if (code === 'Failure_FirmwareError' && !message) {
+      if (code === FailureType.Failure_FirmwareError && !message) {
         error = HardwareError$1.TypedError(dist_HardwareErrorCode.FirmwareError);
       }
 
-      if (code === 'Failure_ActionCancelled') {
+      if (code === FailureType.Failure_ActionCancelled) {
         error = HardwareError$1.TypedError(dist_HardwareErrorCode.ActionCancelled);
       }
 
-      if (code === 'Failure_PinInvalid') {
+      if (code === FailureType.Failure_PinInvalid) {
         error = HardwareError$1.TypedError(dist_HardwareErrorCode.PinInvalid, message);
       }
 
-      if (code === 'Failure_PinCancelled') {
+      if (code === FailureType.Failure_PinCancelled) {
         error = HardwareError$1.TypedError(dist_HardwareErrorCode.PinCancelled);
       }
 
-      if (code === 'Failure_DataError' && message === 'Please confirm the BlindSign enabled') {
+      if (code === FailureType.Failure_DataError && message === 'Please confirm the BlindSign enabled') {
         error = HardwareError$1.TypedError(dist_HardwareErrorCode.BlindSignDisabled);
       }
 
@@ -38945,7 +39491,7 @@ const UI_REQUEST = {
   FIRMWARE_NOT_INSTALLED: 'ui-device_firmware_not_installed',
   NOT_USE_ONEKEY_DEVICE: 'ui-device_please_use_onekey_device'
 };
-const DEFAULT_DOMAIN = `https://jssdk.onekey.so/${"0.1.43"}/`;
+const DEFAULT_DOMAIN = `https://jssdk.onekey.so/${"0.1.44"}/`;
 const DEFAULT_PRIORITY = 2;
 const initialSettings = {
   configSrc: './data/config.json',
@@ -39713,82 +40259,224 @@ class GetFeatures extends BaseMethod {
 
 }
 
-const hasHexPrefix = str => str.slice(0, 2).toLowerCase() === '0x';
+class GetPassphraseState extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    this.useDevicePassphraseState = false;
+  }
 
-const stripHexPrefix = str => hasHexPrefix(str) ? str.slice(2) : str;
+  run() {
+    var _a, _b;
 
-const addHexPrefix = str => hasHexPrefix(str) ? str : `0x${str}`;
+    return dist_awaiter(this, void 0, void 0, function* () {
+      if (!this.device.features) return Promise.reject(HardwareError$1.TypedError(dist_HardwareErrorCode.DeviceInitializeFailed));
+      let {
+        features
+      } = this.device;
+      const locked = ((_b = (_a = this.device) === null || _a === void 0 ? void 0 : _a.features) === null || _b === void 0 ? void 0 : _b.unlocked) === true;
+      const passphraseState = yield getPassphraseState(this.device.features, this.device.commands);
+      const isModeT = getDeviceType(features) === 'touch' || getDeviceType(features) === 'pro';
 
-const isHexString = (value, length) => {
-  if (typeof value !== 'string' || !value.match(/^(0x|0X)?[0-9A-Fa-f]*$/)) {
-    return false;
-  }
+      if (isModeT && locked) {
+        const {
+          message
+        } = yield this.device.commands.typedCall('GetFeatures', 'Features', {});
+        features = message;
+      }
 
-  if (length && value.length !== 2 + 2 * length) {
-    return false;
+      if (features && features.passphrase_protection === true) {
+        return Promise.resolve(passphraseState);
+      }
+
+      return Promise.resolve(undefined);
+    });
   }
 
-  return true;
-};
+}
 
-const stripHexStartZeroes = str => {
-  while (/^00/.test(str)) {
-    str = str.slice(2);
+class CheckBridgeStatus$1 extends BaseMethod {
+  init() {
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
   }
 
-  return str;
-};
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const logs = getLog();
+      return Promise.resolve(logs);
+    });
+  }
 
-const modifyValues = (object, transformer) => Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transformer(value, key)]));
+}
 
-const formatAnyHex = value => {
-  if (typeof value === 'string') {
-    let stripped = stripHexPrefix(value);
+class CheckFirmwareRelease extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
 
-    if (stripped.length % 2 !== 0) {
-      stripped = `0${stripped}`;
+  run() {
+    if (this.device.features) {
+      const releaseInfo = getFirmwareReleaseInfo(this.device.features);
+      return Promise.resolve(releaseInfo);
     }
 
-    return stripped;
+    return Promise.resolve(null);
   }
 
-  if (Array.isArray(value)) {
-    return value.map(formatAnyHex);
-  }
+}
 
-  if (typeof value === 'object') {
-    return modifyValues(value, value => formatAnyHex(value));
+class CheckBLEFirmwareRelease extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.checkDeviceId = true;
+    this.useDevicePassphraseState = false;
   }
 
-  return value;
-};
-
-const invalidParameter = message => HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodInvalidParameter, message);
-
-const validateParams = (values, fields) => {
-  fields.forEach(field => {
-    const existsProp = Object.prototype.hasOwnProperty.call(values, field.name);
-
-    if (!existsProp && field.required) {
-      throw invalidParameter(`Missing required parameter: ${field.name}`);
+  run() {
+    if (this.device.features) {
+      const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
+      return Promise.resolve(releaseInfo);
     }
 
-    const value = values[field.name];
+    return Promise.resolve(null);
+  }
 
-    if (value && field.type) {
-      switch (field.type) {
-        case 'array':
-          if (!Array.isArray(value)) {
-            throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [${field.type}].`);
-          } else if (!field.allowEmpty && value.length < 1) {
-            throw invalidParameter(`Parameter "${field.name}" is empty.`);
-          }
+}
 
-          break;
+class CheckTransportRelease extends BaseMethod {
+  init() {
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
+  }
 
-        case 'bigNumber':
-          if (typeof value !== 'string') {
-            throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [string].`);
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const transport = TransportManager.getTransport();
+      const localVersion = yield transport.init();
+      const response = DataManager.getTransportStatus(localVersion);
+      return Promise.resolve(response);
+    });
+  }
+
+}
+
+class CheckBridgeStatus extends BaseMethod {
+  init() {
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
+  }
+
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      return new Promise((resolve, reject) => {
+        axios_default().request({
+          url: 'http://localhost:21320',
+          method: 'POST',
+          withCredentials: false,
+          timeout: 3000
+        }).then(() => resolve(true)).catch(e => {
+          if (e.code === 'ECONNABORTED') {
+            reject(HardwareError$1.TypedError(dist_HardwareErrorCode.BridgeTimeoutError));
+          } else {
+            resolve(false);
+          }
+        });
+      });
+    });
+  }
+
+}
+
+class DeviceBackup extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('BackupDevice', 'Success');
+      return Promise.resolve(res.message);
+    });
+  }
+
+}
+
+const hasHexPrefix = str => str.slice(0, 2).toLowerCase() === '0x';
+
+const stripHexPrefix = str => hasHexPrefix(str) ? str.slice(2) : str;
+
+const addHexPrefix = str => hasHexPrefix(str) ? str : `0x${str}`;
+
+const isHexString = (value, length) => {
+  if (typeof value !== 'string' || !value.match(/^(0x|0X)?[0-9A-Fa-f]*$/)) {
+    return false;
+  }
+
+  if (length && value.length !== 2 + 2 * length) {
+    return false;
+  }
+
+  return true;
+};
+
+const stripHexStartZeroes = str => {
+  while (/^00/.test(str)) {
+    str = str.slice(2);
+  }
+
+  return str;
+};
+
+const modifyValues = (object, transformer) => Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transformer(value, key)]));
+
+const formatAnyHex = value => {
+  if (typeof value === 'string') {
+    let stripped = stripHexPrefix(value);
+
+    if (stripped.length % 2 !== 0) {
+      stripped = `0${stripped}`;
+    }
+
+    return stripped;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(formatAnyHex);
+  }
+
+  if (typeof value === 'object') {
+    return modifyValues(value, value => formatAnyHex(value));
+  }
+
+  return value;
+};
+
+const invalidParameter = message => HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodInvalidParameter, message);
+
+const validateParams = (values, fields) => {
+  fields.forEach(field => {
+    const existsProp = Object.prototype.hasOwnProperty.call(values, field.name);
+
+    if (!existsProp && field.required) {
+      throw invalidParameter(`Missing required parameter: ${field.name}`);
+    }
+
+    const value = values[field.name];
+
+    if (value && field.type) {
+      switch (field.type) {
+        case 'array':
+          if (!Array.isArray(value)) {
+            throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [${field.type}].`);
+          } else if (!field.allowEmpty && value.length < 1) {
+            throw invalidParameter(`Parameter "${field.name}" is empty.`);
+          }
+
+          break;
+
+        case 'bigNumber':
+          if (typeof value !== 'string') {
+            throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [string].`);
           }
 
           try {
@@ -39828,99 +40516,654 @@ const validateParams = (values, fields) => {
   });
 };
 
-class CipherKeyValue extends BaseMethod {
-  constructor() {
-    super(...arguments);
-    this.hasBundle = false;
+class DeviceChangePin extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+    validateParams(this.payload, [{
+      name: 'remove',
+      type: 'boolean'
+    }]);
+    this.params = {
+      remove: this.payload.remove
+    };
   }
 
-  init() {
-    var _a;
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('ChangePin', 'Success', Object.assign({}, this.params));
+      return Promise.resolve(res.message);
+    });
+  }
 
-    this.checkDeviceId = true;
-    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'
+}
+
+class DeviceFlags extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+    validateParams(this.payload, [{
+      name: 'flags',
+      type: 'number'
     }]);
-    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)
-      });
-    });
+    this.params = {
+      flags: this.payload.flags
+    };
   }
 
   run() {
     return dist_awaiter(this, void 0, void 0, function* () {
-      const responses = [];
+      const res = yield this.device.commands.typedCall('ApplyFlags', 'Success', Object.assign({}, this.params));
+      return Promise.resolve(res.message);
+    });
+  }
 
-      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));
+}
+
+class DeviceRebootToBootloader extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  getVersionRange() {
+    return {
+      classic: {
+        min: '2.1.11'
+      },
+      mini: {
+        min: '2.1.11'
       }
+    };
+  }
 
-      return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('RebootToBootloader', 'Success');
+      return Promise.resolve(res.message);
     });
   }
 
 }
 
-var bitcoin = [{
-  name: "Bitcoin",
-  label: "BTC",
-  slip44: 0
-}, {
-  name: "Regtest",
-  label: "REGTEST",
-  slip44: 1
-}, {
-  name: "Testnet",
-  label: "TEST",
-  slip44: 1
-}, {
-  name: "Actinium",
-  label: "ACM",
-  slip44: 228
-}, {
-  name: "Axe",
-  label: "AXE",
+class DeviceRecovery extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+    validateParams(this.payload, [{
+      name: 'wordCount',
+      type: 'number'
+    }, {
+      name: 'passphraseProtection',
+      type: 'boolean'
+    }, {
+      name: 'pinProtection',
+      type: 'boolean'
+    }, {
+      name: 'language',
+      type: 'string'
+    }, {
+      name: 'label',
+      type: 'string'
+    }, {
+      name: 'enforceWordlist',
+      type: 'boolean'
+    }, {
+      name: 'type',
+      type: 'object'
+    }, {
+      name: 'u2fCounter',
+      type: 'number'
+    }, {
+      name: 'dryRun',
+      type: 'boolean'
+    }]);
+    this.params = {
+      word_count: this.payload.wordCount,
+      passphrase_protection: this.payload.passphraseProtection,
+      pin_protection: this.payload.pinProtection,
+      language: this.payload.language,
+      label: this.payload.label,
+      enforce_wordlist: this.payload.enforceWordlist,
+      type: this.payload.type,
+      u2f_counter: this.payload.u2fCounter || Math.floor(Date.now() / 1000),
+      dry_run: this.payload.dryRun
+    };
+  }
+
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('RecoveryDevice', 'Success', Object.assign({}, this.params));
+      return Promise.resolve(res.message);
+    });
+  }
+
+}
+
+class DeviceReset extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+    validateParams(this.payload, [{
+      name: 'displayRandom',
+      type: 'boolean'
+    }, {
+      name: 'strength',
+      type: 'number'
+    }, {
+      name: 'passphraseProtection',
+      type: 'boolean'
+    }, {
+      name: 'pinProtection',
+      type: 'boolean'
+    }, {
+      name: 'language',
+      type: 'string'
+    }, {
+      name: 'label',
+      type: 'string'
+    }, {
+      name: 'u2fCounter',
+      type: 'number'
+    }, {
+      name: 'skipBackup',
+      type: 'boolean'
+    }, {
+      name: 'noBackup',
+      type: 'boolean'
+    }, {
+      name: 'backupType'
+    }]);
+    this.params = {
+      display_random: this.payload.displayRandom,
+      strength: this.payload.strength || 256,
+      passphrase_protection: this.payload.passphraseProtection,
+      pin_protection: this.payload.pinProtection,
+      language: this.payload.language,
+      label: this.payload.label,
+      u2f_counter: this.payload.u2fCounter || Math.floor(Date.now() / 1000),
+      skip_backup: this.payload.skipBackup,
+      no_backup: this.payload.noBackup,
+      backup_type: this.payload.backupType
+    };
+  }
+
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('ResetDevice', 'Success', Object.assign({}, this.params));
+      return Promise.resolve(res.message);
+    });
+  }
+
+}
+
+class DeviceSettings extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+    validateParams(this.payload, [{
+      name: 'language',
+      type: 'string'
+    }, {
+      name: 'label',
+      type: 'string'
+    }, {
+      name: 'usePassphrase',
+      type: 'boolean'
+    }, {
+      name: 'homescreen',
+      type: 'string'
+    }, {
+      name: 'passphraseSource',
+      type: 'number'
+    }, {
+      name: 'autoLockDelayMs',
+      type: 'number'
+    }, {
+      name: 'displayRotation',
+      type: 'number'
+    }, {
+      name: 'passphraseAlwaysOnDevice',
+      type: 'boolean'
+    }, {
+      name: 'safetyChecks',
+      type: 'number'
+    }, {
+      name: 'experimentalFeatures',
+      type: 'boolean'
+    }]);
+    this.params = {
+      language: this.payload.language,
+      label: this.payload.label,
+      use_passphrase: this.payload.usePassphrase,
+      homescreen: this.payload.homescreen,
+      _passphrase_source: this.payload.passphraseSource,
+      auto_lock_delay_ms: this.payload.autoLockDelayMs,
+      display_rotation: this.payload.displayRotation,
+      passphrase_always_on_device: this.payload.passphraseAlwaysOnDevice,
+      safety_checks: this.payload.safetyChecks,
+      experimental_features: this.payload.experimentalFeatures
+    };
+  }
+
+  getVersionRange() {
+    if (this.payload.usePassphrase) {
+      return {
+        model_mini: {
+          min: '2.4.0'
+        }
+      };
+    }
+
+    return {};
+  }
+
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('ApplySettings', 'Success', Object.assign({}, this.params));
+      return Promise.resolve(res.message);
+    });
+  }
+
+}
+
+class DeviceUpdateReboot extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('BixinReboot', 'Success');
+      return Promise.resolve(res.message);
+    });
+  }
+
+}
+
+class DeviceSupportFeatures extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  run() {
+    if (!this.device.features) return Promise.reject(HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Device not initialized'));
+    const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
+    return Promise.resolve({
+      inputPinOnSoftware,
+      device: this.device.toMessageObject()
+    });
+  }
+
+}
+
+class DeviceVerify extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+    validateParams(this.payload, [{
+      name: 'dataHex',
+      type: 'hexString'
+    }]);
+    this.params = {
+      data: formatAnyHex(this.payload.dataHex)
+    };
+  }
+
+  run() {
+    return dist_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(Object.assign({}, this.params), {
+          data: sha256_default().sha256(this.params.data)
+        }));
+        response = res.message;
+      } else {
+        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(HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Device not support verify'));
+    });
+  }
+
+}
+
+class DeviceWipe extends BaseMethod {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('WipeDevice', 'Success');
+      return Promise.resolve(res.message);
+    });
+  }
+
+}
+
+const getBinary = ({
+  features,
+  updateType,
+  version
+}) => dist_awaiter(void 0, void 0, void 0, function* () {
+  const releaseInfo = getInfo({
+    features,
+    updateType
+  });
+
+  if (!releaseInfo) {
+    throw HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'no firmware found for this device');
+  }
+
+  if (version && !semver_default().eq(releaseInfo.version, version)) {
+    throw HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'firmware version mismatch');
+  }
+
+  const url = updateType === 'ble' ? releaseInfo.webUpdate : releaseInfo.url;
+  let fw;
+
+  try {
+    fw = yield httpRequest(url, 'binary');
+  } catch (_a) {
+    throw HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
+  }
+
+  return Object.assign(Object.assign({}, releaseInfo), {
+    binary: fw
+  });
+});
+
+const getInfo = ({
+  features,
+  updateType
+}) => {
+  var _a, _b, _c;
+
+  const deviceType = getDeviceType(features);
+  const {
+    deviceMap
+  } = DataManager;
+  const releaseInfo = (_c = (_b = (_a = deviceMap === null || deviceMap === void 0 ? void 0 : deviceMap[deviceType]) === null || _a === void 0 ? void 0 : _a[updateType]) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : null;
+  return releaseInfo;
+};
+
+const postConfirmationMessage = device => {
+  var _a;
+
+  if ((_a = device.features) === null || _a === void 0 ? void 0 : _a.firmware_present) {
+    device.emit(DEVICE.BUTTON, device, {
+      code: 'ButtonRequest_FirmwareUpdate'
+    });
+  }
+};
+
+const postProgressMessage = (device, progress, postMessage) => {
+  postMessage(createUiMessage(UI_REQUEST$1.FIRMWARE_PROGRESS, {
+    device: device.toMessageObject(),
+    progress
+  }));
+};
+
+const uploadFirmware = (updateType, typedCall, postMessage, device, {
+  payload
+}) => dist_awaiter(void 0, void 0, void 0, function* () {
+  var _a, _b;
+
+  if (((_a = device.features) === null || _a === void 0 ? void 0 : _a.major_version) === 1) {
+    postConfirmationMessage(device);
+    const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
+    yield typedCall(eraseCommand, 'Success', {});
+    postProgressMessage(device, 0, postMessage);
+    const {
+      message
+    } = yield typedCall('FirmwareUpload', 'Success', {
+      payload
+    });
+    postProgressMessage(device, 100, postMessage);
+    return message;
+  }
+
+  if (((_b = device.features) === null || _b === void 0 ? void 0 : _b.major_version) === 2) {
+    postConfirmationMessage(device);
+    const length = payload.byteLength;
+    let response = yield typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], {
+      length
+    });
+
+    while (response.type !== 'Success') {
+      const start = response.message.offset;
+      const end = response.message.offset + response.message.length;
+      const chunk = payload.slice(start, end);
+
+      if (start > 0) {
+        postProgressMessage(device, Math.round(start / length * 100), postMessage);
+      }
+
+      response = yield typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
+        payload: chunk
+      });
+    }
+
+    postProgressMessage(device, 100, postMessage);
+    return response.message;
+  }
+
+  throw HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
+});
+
+class FirmwareUpdate extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.INITIALIZE];
+    this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
+    this.useDevicePassphraseState = false;
+    const {
+      payload
+    } = this;
+    validateParams(payload, [{
+      name: 'version',
+      type: 'array'
+    }, {
+      name: 'binary',
+      type: 'buffer'
+    }]);
+
+    if (!payload.updateType) {
+      throw HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
+    }
+
+    this.params = {
+      updateType: payload.updateType
+    };
+
+    if ('version' in payload) {
+      this.params = Object.assign(Object.assign({}, this.params), {
+        version: payload.version
+      });
+    }
+
+    if ('binary' in payload) {
+      this.params = Object.assign(Object.assign({}, this.params), {
+        binary: payload.binary
+      });
+    }
+  }
+
+  run() {
+    var _a;
+
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const {
+        device,
+        params
+      } = this;
+      let binary;
+
+      try {
+        if (params.binary) {
+          binary = this.params.binary;
+        } else {
+          if (!device.features) {
+            throw HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'no features found for this device');
+          }
+
+          const firmware = yield getBinary({
+            features: device.features,
+            version: params.version,
+            updateType: params.updateType
+          });
+          binary = firmware.binary;
+        }
+      } catch (err) {
+        throw HardwareError$1.TypedError(dist_HardwareErrorCode.FirmwareUpdateDownloadFailed, (_a = err.message) !== null && _a !== void 0 ? _a : err);
+      }
+
+      return uploadFirmware(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, {
+        payload: binary
+      });
+    });
+  }
+
+}
+
+const Log$2 = getLogger(LoggerNames.Method);
+
+class RequestWebUsbDevice extends BaseMethod {
+  init() {
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
+  }
+
+  run() {
+    var _a, _b;
+
+    return dist_awaiter(this, void 0, void 0, function* () {
+      yield TransportManager.configure();
+      const env = DataManager.getSettings('env');
+
+      if (env !== 'webusb') {
+        return Promise.reject(HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Not webusb environment'));
+      }
+
+      try {
+        const deviceDiff = yield (_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate();
+        const devicesDescriptor = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
+        const {
+          deviceList
+        } = yield DevicePool.getDevices(devicesDescriptor);
+
+        if (deviceList.length > 0) {
+          return {
+            device: deviceList[0].toMessageObject()
+          };
+        }
+
+        return yield Promise.reject(HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+      } catch (error) {
+        Log$2.debug(error);
+        return Promise.reject(HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+      }
+    });
+  }
+
+}
+
+class CipherKeyValue extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.hasBundle = false;
+  }
+
+  init() {
+    var _a;
+
+    this.checkDeviceId = true;
+    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 dist_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",
+  slip44: 0
+}, {
+  name: "Regtest",
+  label: "REGTEST",
+  slip44: 1
+}, {
+  name: "Testnet",
+  label: "TEST",
+  slip44: 1
+}, {
+  name: "Actinium",
+  label: "ACM",
+  slip44: 228
+}, {
+  name: "Axe",
+  label: "AXE",
   slip44: 4242
 }, {
   name: "Bitcore",
@@ -40866,527 +42109,417 @@ class BTCSignTransaction extends BaseMethod {
       }, {
         name: 'op_return_data',
         type: 'string'
-      }, {
-        name: 'multisig',
-        type: 'object'
-      }]);
-
-      if (Object.prototype.hasOwnProperty.call(output, 'address_n') && Object.prototype.hasOwnProperty.call(output, 'address')) {
-        throw HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodInvalidParameter, 'Cannot use address and address_n in one output');
-      }
-
-      if (output.address_n) {
-        const scriptType = getOutputScriptType(output.address_n);
-        if (output.script_type !== scriptType) throw HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodInvalidParameter, `Output change script_type should be set to ${scriptType}`);
-      }
-    });
-    const {
-      inputs,
-      outputs,
-      refTxs,
-      account,
-      coin
-    } = this.payload;
-    const coinName = getCoinInfo(undefined, coin).name;
-    this.params = {
-      inputs,
-      outputs,
-      refTxs,
-      addresses: account ? account.addresses : undefined,
-      options: {
-        lock_time: this.payload.locktime,
-        timestamp: this.payload.timestamp,
-        version: this.payload.version,
-        expiry: this.payload.expiry,
-        overwintered: this.payload.overwintered,
-        version_group_id: this.payload.versionGroupId,
-        branch_id: this.payload.branchId
-      },
-      coinName
-    };
-  }
-
-  run() {
-    return dist_awaiter(this, void 0, void 0, function* () {
-      const {
-        device,
-        params
-      } = this;
-      const useLegacySignProcess = device.unavailableCapabilities.replaceTransaction;
-      const {
-        refTxs
-      } = params;
-      const signTxMethod = !useLegacySignProcess ? signtx : signtxLegacy;
-      const response = yield signTxMethod(device.commands.typedCall.bind(device.commands), params.inputs, params.outputs, refTxs, params.options, params.coinName);
-      return response;
-    });
-  }
-
-}
-
-class BTCVerifyMessage extends BaseMethod {
-  init() {
-    this.checkDeviceId = true;
-    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
-    validateParams(this.payload, [{
-      name: 'address',
-      type: 'string',
-      required: true
-    }, {
-      name: 'messageHex',
-      type: 'hexString',
-      required: true
-    }, {
-      name: 'signature',
-      type: 'hexString',
-      required: true
-    }, {
-      name: 'coin',
-      type: 'string',
-      required: true
-    }]);
-    const {
-      coin
-    } = this.payload;
-    const {
-      address,
-      messageHex,
-      signature
-    } = formatAnyHex(this.payload);
-    const coinName = getCoinInfo(undefined, coin).name;
-    this.params = {
-      address,
-      message: messageHex,
-      signature,
-      coin_name: coinName
-    };
-  }
-
-  run() {
-    return dist_awaiter(this, void 0, void 0, function* () {
-      const res = yield this.device.commands.typedCall('VerifyMessage', 'Success', Object.assign({}, this.params));
-      return Promise.resolve(res.message);
-    });
-  }
-
-}
-
-class CheckFirmwareRelease extends BaseMethod {
-  init() {
-    this.useDevicePassphraseState = false;
-  }
-
-  run() {
-    if (this.device.features) {
-      const releaseInfo = getFirmwareReleaseInfo(this.device.features);
-      return Promise.resolve(releaseInfo);
-    }
-
-    return Promise.resolve(null);
-  }
-
-}
-
-class CheckBLEFirmwareRelease extends BaseMethod {
-  init() {
-    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-    this.checkDeviceId = true;
-    this.useDevicePassphraseState = false;
-  }
-
-  run() {
-    if (this.device.features) {
-      const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
-      return Promise.resolve(releaseInfo);
-    }
-
-    return Promise.resolve(null);
-  }
-
-}
-
-class CheckTransportRelease extends BaseMethod {
-  init() {
-    this.useDevice = false;
-    this.useDevicePassphraseState = false;
-  }
-
-  run() {
-    return dist_awaiter(this, void 0, void 0, function* () {
-      const transport = TransportManager.getTransport();
-      const localVersion = yield transport.init();
-      const response = DataManager.getTransportStatus(localVersion);
-      return Promise.resolve(response);
-    });
-  }
-
-}
-
-class CheckBridgeStatus$1 extends BaseMethod {
-  init() {
-    this.useDevice = false;
-    this.useDevicePassphraseState = false;
-  }
-
-  run() {
-    return dist_awaiter(this, void 0, void 0, function* () {
-      return new Promise((resolve, reject) => {
-        axios_default().request({
-          url: 'http://localhost:21320',
-          method: 'POST',
-          withCredentials: false,
-          timeout: 3000
-        }).then(() => resolve(true)).catch(e => {
-          if (e.code === 'ECONNABORTED') {
-            reject(HardwareError$1.TypedError(dist_HardwareErrorCode.BridgeTimeoutError));
-          } else {
-            resolve(false);
-          }
-        });
-      });
-    });
-  }
-
-}
-
-class DeviceBackup extends BaseMethod {
-  init() {
-    this.useDevicePassphraseState = false;
-  }
-
-  run() {
-    return dist_awaiter(this, void 0, void 0, function* () {
-      const res = yield this.device.commands.typedCall('BackupDevice', 'Success');
-      return Promise.resolve(res.message);
-    });
-  }
+      }, {
+        name: 'multisig',
+        type: 'object'
+      }]);
 
-}
+      if (Object.prototype.hasOwnProperty.call(output, 'address_n') && Object.prototype.hasOwnProperty.call(output, 'address')) {
+        throw HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodInvalidParameter, 'Cannot use address and address_n in one output');
+      }
 
-class DeviceChangePin extends BaseMethod {
-  init() {
-    this.useDevicePassphraseState = false;
-    validateParams(this.payload, [{
-      name: 'remove',
-      type: 'boolean'
-    }]);
+      if (output.address_n) {
+        const scriptType = getOutputScriptType(output.address_n);
+        if (output.script_type !== scriptType) throw HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodInvalidParameter, `Output change script_type should be set to ${scriptType}`);
+      }
+    });
+    const {
+      inputs,
+      outputs,
+      refTxs,
+      account,
+      coin
+    } = this.payload;
+    const coinName = getCoinInfo(undefined, coin).name;
     this.params = {
-      remove: this.payload.remove
+      inputs,
+      outputs,
+      refTxs,
+      addresses: account ? account.addresses : undefined,
+      options: {
+        lock_time: this.payload.locktime,
+        timestamp: this.payload.timestamp,
+        version: this.payload.version,
+        expiry: this.payload.expiry,
+        overwintered: this.payload.overwintered,
+        version_group_id: this.payload.versionGroupId,
+        branch_id: this.payload.branchId
+      },
+      coinName
     };
   }
 
   run() {
     return dist_awaiter(this, void 0, void 0, function* () {
-      const res = yield this.device.commands.typedCall('ChangePin', 'Success', Object.assign({}, this.params));
-      return Promise.resolve(res.message);
+      const {
+        device,
+        params
+      } = this;
+      const useLegacySignProcess = device.unavailableCapabilities.replaceTransaction;
+      const {
+        refTxs
+      } = params;
+      const signTxMethod = !useLegacySignProcess ? signtx : signtxLegacy;
+      const response = yield signTxMethod(device.commands.typedCall.bind(device.commands), params.inputs, params.outputs, refTxs, params.options, params.coinName);
+      return response;
     });
   }
 
 }
 
-class DeviceFlags extends BaseMethod {
+class BTCVerifyMessage extends BaseMethod {
   init() {
-    this.useDevicePassphraseState = false;
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
     validateParams(this.payload, [{
-      name: 'flags',
-      type: 'number'
+      name: 'address',
+      type: 'string',
+      required: true
+    }, {
+      name: 'messageHex',
+      type: 'hexString',
+      required: true
+    }, {
+      name: 'signature',
+      type: 'hexString',
+      required: true
+    }, {
+      name: 'coin',
+      type: 'string',
+      required: true
     }]);
+    const {
+      coin
+    } = this.payload;
+    const {
+      address,
+      messageHex,
+      signature
+    } = formatAnyHex(this.payload);
+    const coinName = getCoinInfo(undefined, coin).name;
     this.params = {
-      flags: this.payload.flags
+      address,
+      message: messageHex,
+      signature,
+      coin_name: coinName
     };
   }
 
   run() {
     return dist_awaiter(this, void 0, void 0, function* () {
-      const res = yield this.device.commands.typedCall('ApplyFlags', 'Success', Object.assign({}, this.params));
+      const res = yield this.device.commands.typedCall('VerifyMessage', 'Success', Object.assign({}, this.params));
       return Promise.resolve(res.message);
     });
   }
 
 }
 
-class DeviceRebootToBootloader extends BaseMethod {
+class ConfluxGetAddress extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.hasBundle = false;
+  }
+
   init() {
-    this.useDevicePassphraseState = false;
+    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: 'chainId',
+        type: 'number'
+      }, {
+        name: 'showOnOneKey',
+        type: 'boolean'
+      }]);
+      const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+      this.params.push({
+        address_n: addressN,
+        chain_id: batch.chainId,
+        show_display: showOnOneKey
+      });
+    });
   }
 
   getVersionRange() {
     return {
-      classic: {
-        min: '2.1.11'
-      },
-      mini: {
-        min: '2.1.11'
+      model_mini: {
+        min: '2.4.0'
       }
     };
   }
 
   run() {
     return dist_awaiter(this, void 0, void 0, function* () {
-      const res = yield this.device.commands.typedCall('RebootToBootloader', 'Success');
-      return Promise.resolve(res.message);
+      const responses = [];
+
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const res = yield this.device.commands.typedCall('ConfluxGetAddress', 'ConfluxAddress', Object.assign({}, param));
+        responses.push(Object.assign({
+          path: serializedPath(param.address_n)
+        }, res.message));
+      }
+
+      return Promise.resolve(this.hasBundle ? responses : responses[0]);
     });
   }
 
 }
 
-class DeviceRecovery extends BaseMethod {
+class ConfluxSignMessage extends BaseMethod {
   init() {
-    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
     validateParams(this.payload, [{
-      name: 'wordCount',
-      type: 'number'
-    }, {
-      name: 'passphraseProtection',
-      type: 'boolean'
-    }, {
-      name: 'pinProtection',
-      type: 'boolean'
-    }, {
-      name: 'language',
-      type: 'string'
-    }, {
-      name: 'label',
-      type: 'string'
-    }, {
-      name: 'enforceWordlist',
-      type: 'boolean'
-    }, {
-      name: 'type',
-      type: 'object'
-    }, {
-      name: 'u2fCounter',
-      type: 'number'
+      name: 'path',
+      required: true
     }, {
-      name: 'dryRun',
-      type: 'boolean'
+      name: 'messageHex',
+      type: 'hexString',
+      required: true
     }]);
+    const {
+      path,
+      messageHex
+    } = this.payload;
+    const addressN = validatePath(path, 3);
     this.params = {
-      word_count: this.payload.wordCount,
-      passphrase_protection: this.payload.passphraseProtection,
-      pin_protection: this.payload.pinProtection,
-      language: this.payload.language,
-      label: this.payload.label,
-      enforce_wordlist: this.payload.enforceWordlist,
-      type: this.payload.type,
-      u2f_counter: this.payload.u2fCounter || Math.floor(Date.now() / 1000),
-      dry_run: this.payload.dryRun
+      address_n: addressN,
+      message: formatAnyHex(messageHex)
     };
   }
 
-  run() {
-    return dist_awaiter(this, void 0, void 0, function* () {
-      const res = yield this.device.commands.typedCall('RecoveryDevice', 'Success', Object.assign({}, this.params));
-      return Promise.resolve(res.message);
-    });
-  }
-
-}
-
-class DeviceReset extends BaseMethod {
-  init() {
-    this.useDevicePassphraseState = false;
-    validateParams(this.payload, [{
-      name: 'displayRandom',
-      type: 'boolean'
-    }, {
-      name: 'strength',
-      type: 'number'
-    }, {
-      name: 'passphraseProtection',
-      type: 'boolean'
-    }, {
-      name: 'pinProtection',
-      type: 'boolean'
-    }, {
-      name: 'language',
-      type: 'string'
-    }, {
-      name: 'label',
-      type: 'string'
-    }, {
-      name: 'u2fCounter',
-      type: 'number'
-    }, {
-      name: 'skipBackup',
-      type: 'boolean'
-    }, {
-      name: 'noBackup',
-      type: 'boolean'
-    }, {
-      name: 'backupType'
-    }]);
-    this.params = {
-      display_random: this.payload.displayRandom,
-      strength: this.payload.strength || 256,
-      passphrase_protection: this.payload.passphraseProtection,
-      pin_protection: this.payload.pinProtection,
-      language: this.payload.language,
-      label: this.payload.label,
-      u2f_counter: this.payload.u2fCounter || Math.floor(Date.now() / 1000),
-      skip_backup: this.payload.skipBackup,
-      no_backup: this.payload.noBackup,
-      backup_type: this.payload.backupType
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0'
+      }
     };
   }
 
   run() {
     return dist_awaiter(this, void 0, void 0, function* () {
-      const res = yield this.device.commands.typedCall('ResetDevice', 'Success', Object.assign({}, this.params));
+      const res = yield this.device.commands.typedCall('ConfluxSignMessage', 'ConfluxMessageSignature', Object.assign({}, this.params));
       return Promise.resolve(res.message);
     });
   }
 
 }
 
-class DeviceSettings extends BaseMethod {
+class ConfluxSignMessageCIP23 extends BaseMethod {
   init() {
-    this.useDevicePassphraseState = false;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
     validateParams(this.payload, [{
-      name: 'language',
-      type: 'string'
-    }, {
-      name: 'label',
-      type: 'string'
-    }, {
-      name: 'usePassphrase',
-      type: 'boolean'
-    }, {
-      name: 'homescreen',
-      type: 'string'
-    }, {
-      name: 'passphraseSource',
-      type: 'number'
-    }, {
-      name: 'autoLockDelayMs',
-      type: 'number'
-    }, {
-      name: 'displayRotation',
-      type: 'number'
-    }, {
-      name: 'passphraseAlwaysOnDevice',
-      type: 'boolean'
+      name: 'path',
+      required: true
     }, {
-      name: 'safetyChecks',
-      type: 'number'
+      name: 'domainHash',
+      type: 'hexString',
+      required: true
     }, {
-      name: 'experimentalFeatures',
-      type: 'boolean'
+      name: 'messageHash',
+      type: 'hexString',
+      required: true
     }]);
+    const {
+      path,
+      domainHash,
+      messageHash
+    } = this.payload;
+    const addressN = validatePath(path, 3);
     this.params = {
-      language: this.payload.language,
-      label: this.payload.label,
-      use_passphrase: this.payload.usePassphrase,
-      homescreen: this.payload.homescreen,
-      _passphrase_source: this.payload.passphraseSource,
-      auto_lock_delay_ms: this.payload.autoLockDelayMs,
-      display_rotation: this.payload.displayRotation,
-      passphrase_always_on_device: this.payload.passphraseAlwaysOnDevice,
-      safety_checks: this.payload.safetyChecks,
-      experimental_features: this.payload.experimentalFeatures
+      address_n: addressN,
+      domain_hash: formatAnyHex(domainHash),
+      message_hash: formatAnyHex(messageHash)
     };
   }
 
   getVersionRange() {
-    if (this.payload.usePassphrase) {
-      return {
-        model_mini: {
-          min: '2.4.0'
-        }
-      };
-    }
-
-    return {};
+    return {
+      model_mini: {
+        min: '2.4.0'
+      }
+    };
   }
 
   run() {
     return dist_awaiter(this, void 0, void 0, function* () {
-      const res = yield this.device.commands.typedCall('ApplySettings', 'Success', Object.assign({}, this.params));
+      const res = yield this.device.commands.typedCall('ConfluxSignMessageCIP23', 'ConfluxMessageSignature', Object.assign({}, this.params));
       return Promise.resolve(res.message);
     });
   }
 
 }
 
-class DeviceUpdateReboot extends BaseMethod {
-  init() {
-    this.useDevicePassphraseState = false;
+const cutString = (str, cutLen) => {
+  if (!str) {
+    return ['', ''];
   }
 
-  run() {
-    return dist_awaiter(this, void 0, void 0, function* () {
-      const res = yield this.device.commands.typedCall('BixinReboot', 'Success');
-      return Promise.resolve(res.message);
-    });
-  }
+  const first = str.slice(0, cutLen);
+  const second = str.slice(cutLen);
+  return [first, second];
+};
 
-}
+class ConfluxSignTransaction extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.addressN = [];
 
-class DeviceSupportFeatures extends BaseMethod {
-  init() {
-    this.useDevicePassphraseState = false;
-  }
+    this.processTxRequest = (request, data) => dist_awaiter(this, void 0, void 0, function* () {
+      if (!request.data_length) {
+        const v = request.signature_v;
+        const r = request.signature_r;
+        const s = request.signature_s;
 
-  run() {
-    if (!this.device.features) return Promise.reject(HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Device not initialized'));
-    const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
-    return Promise.resolve({
-      inputPinOnSoftware,
-      device: this.device.toMessageObject()
-    });
-  }
+        if (v == null || r == null || s == null) {
+          throw HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodError, 'sign transaction failed');
+        }
 
-}
+        return Promise.resolve({
+          v: `0x${v.toString(16)}`,
+          r: `0x${r}`,
+          s: `0x${s}`
+        });
+      }
 
-class DeviceVerify extends BaseMethod {
-  init() {
-    this.useDevicePassphraseState = false;
-    validateParams(this.payload, [{
-      name: 'dataHex',
-      type: 'hexString'
-    }]);
-    this.params = {
-      data: formatAnyHex(this.payload.dataHex)
-    };
-  }
+      const [first, rest] = cutString(data, request.data_length * 2);
+      const response = yield this.device.commands.typedCall('ConfluxTxAck', 'ConfluxTxRequest', {
+        data_chunk: first
+      });
+      return this.processTxRequest(response.message, rest);
+    });
 
-  run() {
-    return dist_awaiter(this, void 0, void 0, function* () {
-      const deviceType = getDeviceType(this.device.features);
-      let response;
+    this.evmSignTx = (addressN, tx) => dist_awaiter(this, void 0, void 0, function* () {
+      const {
+        to,
+        value,
+        gasPrice,
+        gasLimit,
+        nonce,
+        data,
+        chainId,
+        epochHeight,
+        storageLimit
+      } = tx;
+      const length = data == null ? 0 : data.length / 2;
+      const [first, rest] = cutString(data, 1024 * 2);
+      let message = {
+        address_n: addressN,
+        nonce: stripHexStartZeroes(nonce),
+        gas_price: stripHexStartZeroes(gasPrice),
+        gas_limit: stripHexStartZeroes(gasLimit),
+        to,
+        value: stripHexStartZeroes(value),
+        epoch_height: stripHexStartZeroes(epochHeight),
+        storage_limit: stripHexStartZeroes(storageLimit),
+        chain_id: chainId
+      };
 
-      if (deviceType === 'classic') {
-        const res = yield this.device.commands.typedCall('BixinVerifyDeviceRequest', 'BixinVerifyDeviceAck', Object.assign(Object.assign({}, this.params), {
-          data: sha256_default().sha256(this.params.data)
-        }));
-        response = res.message;
-      } else {
-        const signatureRes = yield this.device.commands.typedCall('SESignMessage', 'SEMessageSignature', {
-          message: this.params.data
+      if (length !== 0) {
+        message = Object.assign(Object.assign({}, message), {
+          data_length: length,
+          data_initial_chunk: first
         });
-        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(HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Device not support verify'));
+      const response = yield this.device.commands.typedCall('ConfluxSignTx', 'ConfluxTxRequest', message);
+      return this.processTxRequest(response.message, rest);
     });
   }
 
-}
-
-class DeviceWipe extends BaseMethod {
   init() {
-    this.useDevicePassphraseState = false;
+    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;
+    this.addressN = validatePath(path, 3);
+    const tx = transaction;
+    const schema = [{
+      name: 'to',
+      type: 'hexString',
+      required: true
+    }, {
+      name: 'value',
+      type: 'hexString',
+      required: true
+    }, {
+      name: 'gasLimit',
+      type: 'hexString',
+      required: true
+    }, {
+      name: 'gasPrice',
+      type: 'hexString',
+      required: true
+    }, {
+      name: 'nonce',
+      type: 'hexString',
+      required: true
+    }, {
+      name: 'epochHeight',
+      type: 'hexString',
+      required: true
+    }, {
+      name: 'storageLimit',
+      type: 'hexString',
+      required: true
+    }, {
+      name: 'chainId',
+      type: 'number',
+      required: true
+    }, {
+      name: 'data',
+      type: 'hexString'
+    }];
+    validateParams(tx, schema);
+    this.formattedTx = formatAnyHex(tx);
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0'
+      }
+    };
   }
 
   run() {
     return dist_awaiter(this, void 0, void 0, function* () {
-      const res = yield this.device.commands.typedCall('WipeDevice', 'Success');
-      return Promise.resolve(res.message);
+      const {
+        addressN,
+        formattedTx
+      } = this;
+
+      if (formattedTx == null) {
+        throw HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodInvalidParameter, 'ConfluxSignTransaction: format tx error');
+      }
+
+      const signedTx = yield this.evmSignTx(addressN, formattedTx);
+      return Promise.resolve(signedTx);
     });
   }
 
@@ -41583,20 +42716,10 @@ class EVMSignMessageEIP712 extends BaseMethod {
     return dist_awaiter(this, void 0, void 0, function* () {
       const res = yield this.device.commands.typedCall('EthereumSignMessageEIP712', 'EthereumMessageSignature', Object.assign({}, this.params));
       return Promise.resolve(res.message);
-    });
-  }
-
-}
-
-const cutString = (str, cutLen) => {
-  if (!str) {
-    return ['', ''];
+    });
   }
 
-  const first = str.slice(0, cutLen);
-  const second = str.slice(cutLen);
-  return [first, second];
-};
+}
 
 class EVMSignTransaction extends BaseMethod {
   constructor() {
@@ -43109,25 +44232,28 @@ class StellarSignTransaction extends BaseMethod {
       type: 'object',
       required: true
     }]);
-    const addressN = validatePath(this.payload.path, 3);
     const {
       transaction,
       networkPassphrase
     } = this.payload;
+
+    if (!transaction.timebounds) {
+      throw HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodInvalidParameter, 'timebounds is required');
+    }
+
+    const addressN = validatePath(this.payload.path, 3);
     this.params = {
       address_n: addressN,
       network_passphrase: networkPassphrase,
       source_account: transaction.source,
       fee: transaction.fee,
       sequence_number: transaction.sequence,
-      num_operations: transaction.operations.length
+      num_operations: transaction.operations.length,
+      memo_type: StellarMemoType.NONE,
+      timebounds_start: transaction.timebounds.minTime,
+      timebounds_end: transaction.timebounds.maxTime
     };
 
-    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;
@@ -43155,277 +44281,416 @@ class StellarSignTransaction extends BaseMethod {
 
 }
 
-const getBinary = ({
-  features,
-  updateType,
-  version
-}) => dist_awaiter(void 0, void 0, void 0, function* () {
-  const releaseInfo = getInfo({
-    features,
-    updateType
-  });
-
-  if (!releaseInfo) {
-    throw HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'no firmware found for this device');
+class TronGetAddress extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.hasBundle = false;
   }
 
-  if (version && !semver_default().eq(releaseInfo.version, version)) {
-    throw HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'firmware version mismatch');
-  }
+  init() {
+    var _a;
 
-  const url = updateType === 'ble' ? releaseInfo.webUpdate : releaseInfo.url;
-  let fw;
+    this.checkDeviceId = true;
+    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;
 
-  try {
-    fw = yield httpRequest(url, 'binary');
-  } catch (_a) {
-    throw HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
+      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
+      });
+    });
   }
 
-  return Object.assign(Object.assign({}, releaseInfo), {
-    binary: fw
-  });
-});
-
-const getInfo = ({
-  features,
-  updateType
-}) => {
-  var _a, _b, _c;
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0'
+      }
+    };
+  }
 
-  const deviceType = getDeviceType(features);
-  const {
-    deviceMap
-  } = DataManager;
-  const releaseInfo = (_c = (_b = (_a = deviceMap === null || deviceMap === void 0 ? void 0 : deviceMap[deviceType]) === null || _a === void 0 ? void 0 : _a[updateType]) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : null;
-  return releaseInfo;
-};
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const responses = [];
 
-const postConfirmationMessage = device => {
-  var _a;
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const res = yield this.device.commands.typedCall('TronGetAddress', 'TronAddress', Object.assign({}, param));
+        const {
+          address
+        } = res.message;
+        responses.push({
+          path: serializedPath(param.address_n),
+          address
+        });
+      }
 
-  if ((_a = device.features) === null || _a === void 0 ? void 0 : _a.firmware_present) {
-    device.emit(DEVICE.BUTTON, device, {
-      code: 'ButtonRequest_FirmwareUpdate'
+      return Promise.resolve(this.hasBundle ? responses : responses[0]);
     });
   }
-};
-
-const postProgressMessage = (device, progress, postMessage) => {
-  postMessage(createUiMessage(UI_REQUEST$1.FIRMWARE_PROGRESS, {
-    device: device.toMessageObject(),
-    progress
-  }));
-};
 
-const uploadFirmware = (updateType, typedCall, postMessage, device, {
-  payload
-}) => dist_awaiter(void 0, void 0, void 0, function* () {
-  var _a, _b;
+}
 
-  if (((_a = device.features) === null || _a === void 0 ? void 0 : _a.major_version) === 1) {
-    postConfirmationMessage(device);
-    const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
-    yield typedCall(eraseCommand, 'Success', {});
-    postProgressMessage(device, 0, postMessage);
+class TronSignMessage extends BaseMethod {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    validateParams(this.payload, [{
+      name: 'path',
+      required: true
+    }, {
+      name: 'messageHex',
+      type: 'hexString',
+      required: true
+    }]);
     const {
-      message
-    } = yield typedCall('FirmwareUpload', 'Success', {
-      payload
-    });
-    postProgressMessage(device, 100, postMessage);
-    return message;
+      path,
+      messageHex
+    } = this.payload;
+    const addressN = validatePath(path, 3);
+    this.params = {
+      address_n: addressN,
+      message: stripHexPrefix(messageHex)
+    };
   }
 
-  if (((_b = device.features) === null || _b === void 0 ? void 0 : _b.major_version) === 2) {
-    postConfirmationMessage(device);
-    const length = payload.byteLength;
-    let response = yield typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], {
-      length
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0'
+      }
+    };
+  }
+
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const response = yield this.device.commands.typedCall('TronSignMessage', 'TronMessageSignature', Object.assign({}, this.params));
+      return Promise.resolve(response.message);
     });
+  }
 
-    while (response.type !== 'Success') {
-      const start = response.message.offset;
-      const end = response.message.offset + response.message.length;
-      const chunk = payload.slice(start, end);
+}
 
-      if (start > 0) {
-        postProgressMessage(device, Math.round(start / length * 100), postMessage);
+class TronSignTransaction extends BaseMethod {
+  parseTx(tx, address_n) {
+    const unSignTx = {
+      address_n,
+      data: tx.data,
+      timestamp: tx.timestamp,
+      fee_limit: tx.feeLimit,
+      ref_block_bytes: tx.refBlockBytes,
+      ref_block_hash: tx.refBlockHash,
+      expiration: tx.expiration,
+      contract: {}
+    };
+
+    if (tx.contract) {
+      if (tx.contract.transferContract) {
+        unSignTx.contract = {
+          transfer_contract: {
+            to_address: tx.contract.transferContract.toAddress,
+            amount: tx.contract.transferContract.amount
+          }
+        };
       }
 
-      response = yield typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
-        payload: chunk
-      });
+      if (tx.contract.triggerSmartContract) {
+        unSignTx.contract = {
+          trigger_smart_contract: {
+            contract_address: tx.contract.triggerSmartContract.contractAddress,
+            call_value: tx.contract.triggerSmartContract.callValue,
+            data: tx.contract.triggerSmartContract.data,
+            call_token_value: tx.contract.triggerSmartContract.callTokenValue,
+            asset_id: tx.contract.triggerSmartContract.assetId
+          }
+        };
+      }
     }
 
-    postProgressMessage(device, 100, postMessage);
-    return response.message;
+    return unSignTx;
   }
 
-  throw HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
-});
-
-class FirmwareUpdate extends BaseMethod {
   init() {
-    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.INITIALIZE];
-    this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
-    this.useDevicePassphraseState = false;
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    validateParams(this.payload, [{
+      name: 'path',
+      required: true
+    }, {
+      name: 'transaction',
+      type: 'object',
+      required: true
+    }]);
     const {
-      payload
-    } = this;
-    validateParams(payload, [{
-      name: 'version',
-      type: 'array'
+      path,
+      transaction
+    } = this.payload;
+    const addressN = validatePath(path, 3);
+    validateParams(transaction, [{
+      name: 'refBlockBytes',
+      type: 'hexString',
+      required: true
     }, {
-      name: 'binary',
-      type: 'buffer'
+      name: 'refBlockHash',
+      type: 'hexString',
+      required: true
+    }, {
+      name: 'expiration',
+      type: 'number',
+      required: true
+    }, {
+      name: 'timestamp',
+      type: 'number',
+      required: true
+    }, {
+      name: 'contract',
+      type: 'object',
+      required: true
     }]);
+    this.params = this.parseTx(formatAnyHex(transaction), addressN);
+  }
 
-    if (!payload.updateType) {
-      throw HardwareError$1.TypedError(dist_HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
-    }
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0'
+      }
+    };
+  }
 
-    this.params = {
-      updateType: payload.updateType
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const response = yield this.device.commands.typedCall('TronSignTx', 'TronSignedTx', Object.assign({}, this.params));
+      return Promise.resolve(response.message);
+    });
+  }
+
+}
+
+class NearGetAddress extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.hasBundle = false;
+  }
+
+  init() {
+    var _a;
+
+    this.checkDeviceId = true;
+    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;
 
-    if ('version' in payload) {
-      this.params = Object.assign(Object.assign({}, this.params), {
-        version: payload.version
+      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
       });
-    }
+    });
+  }
 
-    if ('binary' in payload) {
-      this.params = Object.assign(Object.assign({}, this.params), {
-        binary: payload.binary
-      });
-    }
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0'
+      }
+    };
   }
 
   run() {
-    var _a;
-
     return dist_awaiter(this, void 0, void 0, function* () {
-      const {
-        device,
-        params
-      } = this;
-      let binary;
-
-      try {
-        if (params.binary) {
-          binary = this.params.binary;
-        } else {
-          if (!device.features) {
-            throw HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'no features found for this device');
-          }
+      const responses = [];
 
-          const firmware = yield getBinary({
-            features: device.features,
-            version: params.version,
-            updateType: params.updateType
-          });
-          binary = firmware.binary;
-        }
-      } catch (err) {
-        throw HardwareError$1.TypedError(dist_HardwareErrorCode.FirmwareUpdateDownloadFailed, (_a = err.message) !== null && _a !== void 0 ? _a : err);
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const res = yield this.device.commands.typedCall('NearGetAddress', 'NearAddress', Object.assign({}, param));
+        const {
+          address
+        } = res.message;
+        responses.push({
+          path: serializedPath(param.address_n),
+          address
+        });
       }
 
-      return uploadFirmware(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, {
-        payload: binary
-      });
+      return Promise.resolve(this.hasBundle ? responses : responses[0]);
     });
   }
 
 }
 
-const Log$2 = getLogger(LoggerNames.Method);
-
-class RequestWebUsbDevice extends BaseMethod {
+class NearSignTransaction extends BaseMethod {
   init() {
-    this.useDevice = false;
-    this.useDevicePassphraseState = false;
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    validateParams(this.payload, [{
+      name: 'path',
+      required: true
+    }, {
+      name: 'rawTx',
+      type: 'hexString',
+      required: true
+    }]);
+    const {
+      path,
+      rawTx
+    } = this.payload;
+    const addressN = validatePath(path, 3);
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx)
+    };
   }
 
-  run() {
-    var _a, _b;
-
-    return dist_awaiter(this, void 0, void 0, function* () {
-      yield TransportManager.configure();
-      const env = DataManager.getSettings('env');
-
-      if (env !== 'webusb') {
-        return Promise.reject(HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Not webusb environment'));
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0'
       }
+    };
+  }
 
-      try {
-        const deviceDiff = yield (_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate();
-        const devicesDescriptor = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
-        const {
-          deviceList
-        } = yield DevicePool.getDevices(devicesDescriptor);
-
-        if (deviceList.length > 0) {
-          return {
-            device: deviceList[0].toMessageObject()
-          };
-        }
-
-        return yield Promise.reject(HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
-      } catch (error) {
-        Log$2.debug(error);
-        return Promise.reject(HardwareError$1.TypedError(dist_HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
-      }
+  run() {
+    return dist_awaiter(this, void 0, void 0, function* () {
+      const res = yield this.device.commands.typedCall('NearSignTx', 'NearSignedTx', Object.assign({}, this.params));
+      return Promise.resolve(res.message);
     });
   }
 
 }
 
-class GetPassphraseState extends BaseMethod {
+class AptosGetAddress extends BaseMethod {
+  constructor() {
+    super(...arguments);
+    this.hasBundle = false;
+  }
+
   init() {
+    var _a;
+
+    this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
-    this.useDevicePassphraseState = false;
+    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() {
-    var _a, _b;
-
     return dist_awaiter(this, void 0, void 0, function* () {
-      if (!this.device.features) return Promise.reject(HardwareError$1.TypedError(dist_HardwareErrorCode.DeviceInitializeFailed));
-      let {
-        features
-      } = this.device;
-      const locked = ((_b = (_a = this.device) === null || _a === void 0 ? void 0 : _a.features) === null || _b === void 0 ? void 0 : _b.unlocked) === true;
-      const passphraseState = yield getPassphraseState(this.device.features, this.device.commands);
-      const isModeT = getDeviceType(features) === 'touch' || getDeviceType(features) === 'pro';
+      const responses = [];
 
-      if (isModeT && locked) {
+      for (let i = 0; i < this.params.length; i++) {
+        const param = this.params[i];
+        const res = yield this.device.commands.typedCall('AptosGetAddress', 'AptosAddress', Object.assign({}, param));
         const {
-          message
-        } = yield this.device.commands.typedCall('GetFeatures', 'Features', {});
-        features = message;
-      }
-
-      if (features && features.passphrase_protection === true) {
-        return Promise.resolve(passphraseState);
+          address
+        } = res.message;
+        responses.push({
+          path: serializedPath(param.address_n),
+          address
+        });
       }
 
-      return Promise.resolve(undefined);
+      return Promise.resolve(this.hasBundle ? responses : responses[0]);
     });
   }
 
 }
 
-class CheckBridgeStatus extends BaseMethod {
+class AptosSignTransaction extends BaseMethod {
   init() {
-    this.useDevice = false;
-    this.useDevicePassphraseState = false;
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    validateParams(this.payload, [{
+      name: 'path',
+      required: true
+    }, {
+      name: 'rawTx',
+      type: 'hexString',
+      required: true
+    }]);
+    const {
+      path,
+      rawTx
+    } = this.payload;
+    const addressN = validatePath(path, 3);
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx)
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.4.0'
+      }
+    };
   }
 
   run() {
     return dist_awaiter(this, void 0, void 0, function* () {
-      const logs = getLog();
-      return Promise.resolve(logs);
+      const res = yield this.device.commands.typedCall('AptosSignTx', 'AptosSignedTx', Object.assign({}, this.params));
+      return Promise.resolve(res.message);
     });
   }
 
@@ -43435,16 +44700,12 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   __proto__: null,
   searchDevices: SearchDevices,
   getFeatures: GetFeatures,
-  cipherKeyValue: CipherKeyValue,
-  btcGetAddress: BTCGetAddress,
-  btcGetPublicKey: BTCGetPublicKey,
-  btcSignMessage: BTCSignMessage,
-  btcSignTransaction: BTCSignTransaction,
-  btcVerifyMessage: BTCVerifyMessage,
+  getPassphraseState: GetPassphraseState,
+  getLogs: CheckBridgeStatus$1,
   checkFirmwareRelease: CheckFirmwareRelease,
   checkBLEFirmwareRelease: CheckBLEFirmwareRelease,
   checkTransportRelease: CheckTransportRelease,
-  checkBridgeStatus: CheckBridgeStatus$1,
+  checkBridgeStatus: CheckBridgeStatus,
   deviceBackup: DeviceBackup,
   deviceChangePin: DeviceChangePin,
   deviceFlags: DeviceFlags,
@@ -43456,6 +44717,18 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   deviceSupportFeatures: DeviceSupportFeatures,
   deviceVerify: DeviceVerify,
   deviceWipe: DeviceWipe,
+  firmwareUpdate: FirmwareUpdate,
+  requestWebUsbDevice: RequestWebUsbDevice,
+  cipherKeyValue: CipherKeyValue,
+  btcGetAddress: BTCGetAddress,
+  btcGetPublicKey: BTCGetPublicKey,
+  btcSignMessage: BTCSignMessage,
+  btcSignTransaction: BTCSignTransaction,
+  btcVerifyMessage: BTCVerifyMessage,
+  confluxGetAddress: ConfluxGetAddress,
+  confluxSignMessage: ConfluxSignMessage,
+  confluxSignMessageCIP23: ConfluxSignMessageCIP23,
+  confluxSignTransaction: ConfluxSignTransaction,
   evmGetAddress: EvmGetAddress,
   evmGetPublicKey: EVMGetPublicKey,
   evmSignMessage: EVMSignMessage$2,
@@ -43474,10 +44747,13 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   solSignTransaction: SolSignTransaction,
   stellarGetAddress: StellarGetAddress,
   stellarSignTransaction: StellarSignTransaction,
-  firmwareUpdate: FirmwareUpdate,
-  requestWebUsbDevice: RequestWebUsbDevice,
-  getPassphraseState: GetPassphraseState,
-  getLogs: CheckBridgeStatus
+  tronGetAddress: TronGetAddress,
+  tronSignMessage: TronSignMessage,
+  tronSignTransaction: TronSignTransaction,
+  nearGetAddress: NearGetAddress,
+  nearSignTransaction: NearSignTransaction,
+  aptosGetAddress: AptosGetAddress,
+  aptosSignTransaction: AptosSignTransaction
 });
 
 function findMethod(message) {
@@ -44154,6 +45430,8 @@ const removeUiPromise = promise => {
 
 class Core extends dist_events.exports {
   handleMessage(message) {
+    var _a, _b, _c, _d;
+
     return dist_awaiter(this, void 0, void 0, function* () {
       switch (message.type) {
         case UI_RESPONSE.RECEIVE_PIN:
@@ -44178,7 +45456,21 @@ class Core extends dist_events.exports {
         case IFRAME.CALL:
           {
             const response = yield callAPI(message);
-            return response;
+            const {
+              success,
+              payload
+            } = response;
+
+            if (success) {
+              return response;
+            }
+
+            return Object.assign(Object.assign({}, response), {
+              payload: Object.assign(Object.assign({}, payload), {
+                connectId: (_b = (_a = message.payload) === null || _a === void 0 ? void 0 : _a.connectId) !== null && _b !== void 0 ? _b : '',
+                deviceId: (_d = (_c = message.payload) === null || _c === void 0 ? void 0 : _c.deviceId) !== null && _d !== void 0 ? _d : ''
+              })
+            });
           }
 
         case IFRAME.CANCEL:
@@ -46688,7 +47980,7 @@ const src_init = async settings => {
 
   try {
     await builder_init({ ..._settings,
-      version: "0.1.43"
+      version: "0.1.44"
     });
     return true;
   } catch (e) {