@onekeyfe/hd-core 0.0.7 → 0.0.10

package/dist/index.js

@@ -2,15 +2,15 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var semver = require('semver');
 var hdTransport = require('@onekeyfe/hd-transport');
 var axios = require('axios');
-var semver = require('semver');
 var BigNumber = require('bignumber.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var semver__default = /*#__PURE__*/_interopDefaultLegacy(semver);
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
 
 const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
@@ -34,6 +34,7 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
         checkFirmwareRelease: connectId => call({ connectId, method: 'checkFirmwareRelease' }),
         checkBLEFirmwareRelease: connectId => call({ connectId, method: 'checkBLEFirmwareRelease' }),
         checkTransportRelease: () => call({ method: 'checkTransportRelease' }),
+        cipherKeyValue: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'cipherKeyValue' })),
         deviceBackup: connectId => call({ connectId, method: 'deviceBackup' }),
         deviceChangePin: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceChangePin' })),
         deviceFlags: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceFlags' })),
@@ -60,6 +61,12 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
         starcoinSignMessage: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'starcoinSignMessage' })),
         starcoinSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'starcoinSignTransaction' })),
         starcoinVerifyMessage: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'starcoinVerifyMessage' })),
+        nemGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'nemGetAddress' })),
+        nemSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'nemSignTransaction' })),
+        solGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'solGetAddress' })),
+        solSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'solSignTransaction' })),
+        stellarGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'stellarGetAddress' })),
+        stellarSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'stellarSignTransaction' })),
     };
     return api;
 };
@@ -79,6 +86,18 @@ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -808,6 +827,15 @@ function create(arg, data) {
     };
 }
 
+const getDeviceModel = (features) => {
+    if (!features || typeof features !== 'object') {
+        return 'model_mini';
+    }
+    if (features.model === '1') {
+        return 'model_mini';
+    }
+    return 'model_touch';
+};
 const getDeviceType = (features) => {
     if (!features || typeof features !== 'object' || !features.serial_no) {
         return 'classic';
@@ -853,6 +881,8 @@ const getDeviceLabel = (features) => {
     return `My OneKey ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
 };
 const getDeviceFirmwareVersion = (features) => {
+    if (!features)
+        return [0, 0, 0];
     if (features.onekey_version) {
         return features.onekey_version.split('.');
     }
@@ -10125,7 +10155,7 @@ const UI_REQUEST = {
 };
 
 const VERSION = '1.0.0-alpha.1';
-const DEFAULT_DOMAIN = `https://localhost:8088/`;
+const DEFAULT_DOMAIN = `https://hardware-sdk.onekey.so/`;
 
 const DEFAULT_PRIORITY = 2;
 const initialSettings = {
@@ -10562,6 +10592,9 @@ class BaseMethod {
         this.allowDeviceMode = [UI_REQUEST.INITIALIZE];
         this.requireDeviceMode = [];
     }
+    getVersionRange() {
+        return {};
+    }
     setDevice(device) {
         this.device = device;
         this.connectId = device.originalDescriptor.path;
@@ -10653,7 +10686,6 @@ const formatAnyHex = value => {
     if (typeof value === 'object') {
         return modifyValues(value, value => formatAnyHex(value));
     }
-    console.log('unexpected value', value);
     return value;
 };
 
@@ -10710,6 +10742,53 @@ const validateParams = (values, fields) => {
     });
 };
 
+class CipherKeyValue extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
+    init() {
+        var _a;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            const addressN = validatePath(batch.path);
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'key', type: 'string' },
+                { name: 'value', type: 'hexString' },
+                { name: 'encrypt', type: 'boolean' },
+                { name: 'askOnEncrypt', type: 'boolean' },
+                { name: 'askOnDecrypt', type: 'boolean' },
+                { name: 'iv', type: 'hexString' },
+            ]);
+            this.params.push({
+                address_n: addressN,
+                key: batch.key,
+                value: formatAnyHex(batch.value),
+                encrypt: batch.encrypt,
+                ask_on_encrypt: batch.askOnEncrypt,
+                ask_on_decrypt: batch.askOnDecrypt,
+                iv: formatAnyHex(batch.iv),
+            });
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('CipherKeyValue', 'CipheredKeyValue', Object.assign({}, param));
+                responses.push(Object.assign({ path: serializedPath(param.address_n) }, res.message));
+            }
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
+        });
+    }
+}
+
 var bitcoin = [
 	{
 		name: "Bitcoin",
@@ -11551,6 +11630,16 @@ class DeviceFlags extends BaseMethod {
 
 class DeviceRebootToBootloader extends BaseMethod {
     init() { }
+    getVersionRange() {
+        return {
+            classic: {
+                min: '2.1.11',
+            },
+            mini: {
+                min: '2.1.11',
+            },
+        };
+    }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.device.commands.typedCall('RebootToBootloader', 'Success');
@@ -11787,7 +11876,7 @@ class EVMSignMessage$2 extends BaseMethod {
     }
 }
 
-class EVMSignMessageEIP712$1 extends BaseMethod {
+class EVMSignMessageEIP712 extends BaseMethod {
     init() {
         this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
         validateParams(this.payload, [
@@ -11803,6 +11892,13 @@ class EVMSignMessageEIP712$1 extends BaseMethod {
             message_hash: formatAnyHex(messageHash),
         };
     }
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.1.9',
+            },
+        };
+    }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.device.commands.typedCall('EthereumSignMessageEIP712', 'EthereumMessageSignature', Object.assign({}, this.params));
@@ -11923,6 +12019,20 @@ class EVMSignTransaction extends BaseMethod {
         validateParams(tx, schema);
         this.formattedTx = formatAnyHex(tx);
     }
+    getVersionRange() {
+        if (this.isEIP1559) {
+            return {
+                model_mini: {
+                    min: '2.1.11',
+                },
+            };
+        }
+        return {
+            model_mini: {
+                min: '1.0.0',
+            },
+        };
+    }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             const { addressN, isEIP1559, formattedTx } = this;
@@ -11934,13 +12044,13 @@ class EVMSignTransaction extends BaseMethod {
     }
 }
 
-class EVMSignMessageEIP712 extends BaseMethod {
+class EVMSignTypedData extends BaseMethod {
     init() {
         this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
         validateParams(this.payload, [
             { name: 'path', required: true },
-            { name: 'metamaskV4Compat', type: 'boolean', required: true },
-            { name: 'data', type: 'object', required: true },
+            { name: 'metamaskV4Compat', type: 'boolean' },
+            { name: 'data', type: 'object' },
             { name: 'domainHash', type: 'hexString' },
             { name: 'messageHash', type: 'hexString' },
         ]);
@@ -11956,28 +12066,57 @@ class EVMSignMessageEIP712 extends BaseMethod {
             if (messageHash) {
                 this.params.messageHash = formatAnyHex(messageHash);
             }
-            else if (!data.primaryType || data.primaryType !== 'EIP712Domain') {
+            else if (!!data && (!data.primaryType || data.primaryType !== 'EIP712Domain')) {
                 throw TypedError('Method_InvalidParameter', 'message_hash should only be empty when data.primaryType=EIP712Domain');
             }
         }
     }
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.1.9',
+            },
+        };
+    }
+    supportSignTyped() {
+        const deviceType = getDeviceType(this.device.features);
+        if (deviceType === 'classic' || deviceType === 'mini') {
+            const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+            const supportSignTypedVersion = '2.2.0';
+            if (semver__default["default"].lt(currentVersion, supportSignTypedVersion)) {
+                return false;
+            }
+        }
+        return true;
+    }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.device.features) {
                 throw TypedError('Device_InitializeFailed', 'Device initialization failed. Please try again.');
             }
             const { addressN } = this.params;
-            if (this.device.features.model === '1') {
+            const deviceType = getDeviceType(this.device.features);
+            if (deviceType === 'classic' || deviceType === 'mini') {
                 validateParams(this.params, [
                     { name: 'domainHash', type: 'hexString', required: true },
-                    { name: 'messageHash', type: 'hexString' },
+                    { name: 'messageHash', type: 'hexString', required: true },
                 ]);
                 const { domainHash, messageHash } = this.params;
-                const response = yield this.device.commands.typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', {
-                    address_n: addressN,
-                    domain_separator_hash: domainHash !== null && domainHash !== void 0 ? domainHash : '',
-                    message_hash: messageHash,
-                });
+                let response;
+                if (this.supportSignTyped()) {
+                    response = yield this.device.commands.typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', {
+                        address_n: addressN,
+                        domain_separator_hash: domainHash !== null && domainHash !== void 0 ? domainHash : '',
+                        message_hash: messageHash,
+                    });
+                }
+                else {
+                    response = yield this.device.commands.typedCall('EthereumSignMessageEIP712', 'EthereumMessageSignature', {
+                        address_n: addressN,
+                        domain_hash: domainHash !== null && domainHash !== void 0 ? domainHash : '',
+                        message_hash: messageHash !== null && messageHash !== void 0 ? messageHash : '',
+                    });
+                }
                 return Promise.resolve(response.message);
             }
             return Promise.resolve(TypedError('Runtime', 'Not implemented'));
@@ -12153,10 +12292,549 @@ class EVMSignMessage extends BaseMethod {
     }
 }
 
+const MAINNET = 0x68;
+class NEMGetAddress extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
+    init() {
+        var _a;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            var _a;
+            const addressN = validatePath(batch.path, 3);
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'network', type: 'number' },
+                { name: 'showOnOneKey', type: 'boolean' },
+            ]);
+            const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+            this.params.push({
+                address_n: addressN,
+                network: batch.network || MAINNET,
+                show_display: showOnOneKey,
+            });
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('NEMGetAddress', 'NEMAddress', Object.assign({}, param));
+                responses.push(Object.assign({ path: serializedPath(param.address_n) }, res.message));
+            }
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
+        });
+    }
+}
+
+const NEM_TRANSFER = 0x0101;
+const NEM_COSIGNING = 0x0102;
+const NEM_IMPORTANCE_TRANSFER = 0x0801;
+const NEM_AGGREGATE_MODIFICATION = 0x1001;
+const NEM_MULTISIG_SIGNATURE = 0x1002;
+const NEM_MULTISIG = 0x1004;
+const NEM_PROVISION_NAMESPACE = 0x2001;
+const NEM_MOSAIC_CREATION = 0x4001;
+const NEM_SUPPLY_CHANGE = 0x4002;
+class NEMSignTransaction extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.NEM_MOSAIC_LEVY_TYPES = {
+            1: 'MosaicLevy_Absolute',
+            2: 'MosaicLevy_Percentile',
+        };
+        this.NEM_SUPPLY_CHANGE_TYPES = {
+            1: 'SupplyChange_Increase',
+            2: 'SupplyChange_Decrease',
+        };
+        this.NEM_AGGREGATE_MODIFICATION_TYPES = {
+            1: 'CosignatoryModification_Add',
+            2: 'CosignatoryModification_Delete',
+        };
+        this.NEM_IMPORTANCE_TRANSFER_MODES = {
+            1: 'ImportanceTransfer_Activate',
+            2: 'ImportanceTransfer_Deactivate',
+        };
+        this.getCommon = (tx, address_n) => {
+            var _a;
+            return ({
+                address_n,
+                network: (tx.version >> 24) & 0xff,
+                timestamp: tx.timeStamp,
+                fee: tx.fee,
+                deadline: (_a = tx.deadline) !== null && _a !== void 0 ? _a : 0,
+                signer: address_n ? undefined : tx.signer,
+            });
+        };
+        this.transferMessage = (tx) => {
+            const mosaics = tx.mosaics
+                ? tx.mosaics.map(mosaic => ({
+                    namespace: mosaic.mosaicId.namespaceId,
+                    mosaic: mosaic.mosaicId.name,
+                    quantity: mosaic.quantity,
+                }))
+                : undefined;
+            return {
+                recipient: tx.recipient,
+                amount: tx.amount,
+                payload: tx.message ? tx.message.payload : undefined,
+                public_key: tx.message && tx.message.type === 0x02 ? tx.message.publicKey : undefined,
+                mosaics,
+            };
+        };
+        this.importanceTransferMessage = (tx) => ({
+            mode: this.NEM_IMPORTANCE_TRANSFER_MODES[tx.importanceTransfer.mode],
+            public_key: tx.importanceTransfer.publicKey,
+        });
+        this.aggregateModificationMessage = (tx) => {
+            const modifications = tx.modifications
+                ? tx.modifications.map(modification => ({
+                    type: this.NEM_AGGREGATE_MODIFICATION_TYPES[modification.modificationType],
+                    public_key: modification.cosignatoryAccount,
+                }))
+                : undefined;
+            return {
+                modifications,
+                relative_change: tx.minCosignatories.relativeChange,
+            };
+        };
+        this.provisionNamespaceMessage = (tx) => {
+            var _a, _b, _c;
+            return ({
+                namespace: (_a = tx.newPart) !== null && _a !== void 0 ? _a : '',
+                parent: tx.parent || undefined,
+                sink: (_b = tx.rentalFeeSink) !== null && _b !== void 0 ? _b : '',
+                fee: (_c = tx.rentalFee) !== null && _c !== void 0 ? _c : 0,
+            });
+        };
+        this.mosaicCreationMessage = (tx) => {
+            var _a, _b;
+            const { levy } = tx.mosaicDefinition;
+            const definition = {
+                namespace: tx.mosaicDefinition.id.namespaceId,
+                mosaic: tx.mosaicDefinition.id.name,
+                levy: levy && levy.type ? this.NEM_MOSAIC_LEVY_TYPES[levy.type] : undefined,
+                fee: levy && levy.fee,
+                levy_address: levy && levy.recipient,
+                levy_namespace: levy && levy.mosaicId && levy.mosaicId.namespaceId,
+                levy_mosaic: levy && levy.mosaicId && levy.mosaicId.name,
+                description: tx.mosaicDefinition.description,
+            };
+            const { properties } = tx.mosaicDefinition;
+            if (Array.isArray(properties)) {
+                properties.forEach(property => {
+                    const { name, value } = property;
+                    switch (name) {
+                        case 'divisibility':
+                            definition.divisibility = parseInt(value);
+                            break;
+                        case 'initialSupply':
+                            definition.supply = parseInt(value);
+                            break;
+                        case 'supplyMutable':
+                            definition.mutable_supply = value === 'true';
+                            break;
+                        case 'transferable':
+                            definition.transferable = value === 'true';
+                            break;
+                    }
+                });
+            }
+            return {
+                definition,
+                sink: (_a = tx.creationFeeSink) !== null && _a !== void 0 ? _a : '',
+                fee: (_b = tx.creationFee) !== null && _b !== void 0 ? _b : 0,
+            };
+        };
+        this.supplyChangeMessage = (tx) => {
+            var _a;
+            return ({
+                namespace: tx.mosaicId.namespaceId,
+                mosaic: tx.mosaicId.name,
+                type: this.NEM_SUPPLY_CHANGE_TYPES[tx.supplyType],
+                delta: (_a = tx.delta) !== null && _a !== void 0 ? _a : 0,
+            });
+        };
+        this.parseTx = (tx, address_n) => {
+            let transaction = tx;
+            const message = {
+                transaction: this.getCommon(tx, address_n),
+                transfer: undefined,
+                importance_transfer: undefined,
+                aggregate_modification: undefined,
+                provision_namespace: undefined,
+                mosaic_creation: undefined,
+                supply_change: undefined,
+            };
+            if (tx.type === NEM_COSIGNING ||
+                tx.type === NEM_MULTISIG ||
+                tx.type === NEM_MULTISIG_SIGNATURE) {
+                message.cosigning = tx.type === NEM_COSIGNING || tx.type === NEM_MULTISIG_SIGNATURE;
+                transaction = tx.otherTrans;
+                message.multisig = this.getCommon(transaction);
+            }
+            switch (transaction.type) {
+                case NEM_TRANSFER:
+                    message.transfer = this.transferMessage(transaction);
+                    break;
+                case NEM_IMPORTANCE_TRANSFER:
+                    message.importance_transfer = this.importanceTransferMessage(transaction);
+                    break;
+                case NEM_AGGREGATE_MODIFICATION:
+                    message.aggregate_modification = this.aggregateModificationMessage(transaction);
+                    break;
+                case NEM_PROVISION_NAMESPACE:
+                    message.provision_namespace = this.provisionNamespaceMessage(transaction);
+                    break;
+                case NEM_MOSAIC_CREATION:
+                    message.mosaic_creation = this.mosaicCreationMessage(transaction);
+                    break;
+                case NEM_SUPPLY_CHANGE:
+                    message.supply_change = this.supplyChangeMessage(transaction);
+                    break;
+                default:
+                    throw TypedError('Method_InvalidParameter', 'Unknown transaction type');
+            }
+            return message;
+        };
+    }
+    init() {
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        validateParams(this.payload, [
+            { name: 'path', required: true },
+            { name: 'transaction', type: 'object', required: true },
+        ]);
+        const { path, transaction } = this.payload;
+        const addressN = validatePath(path, 3);
+        this.params = this.parseTx(transaction, addressN);
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('NEMSignTx', 'NEMSignedTx', Object.assign({}, this.params));
+            return Promise.resolve(res);
+        });
+    }
+}
+
+class SolGetAddress extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
+    init() {
+        var _a;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            var _a;
+            const addressN = validatePath(batch.path, 3);
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'showOnOneKey', type: 'boolean' },
+            ]);
+            const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+            this.params.push({
+                address_n: addressN,
+                show_display: showOnOneKey,
+            });
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('SolanaGetAddress', 'SolanaAddress', Object.assign({}, param));
+                const { address } = res.message;
+                responses.push({
+                    path: serializedPath(param.address_n),
+                    address,
+                });
+            }
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
+        });
+    }
+}
+
+class SolSignTransaction extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
+    init() {
+        var _a;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            const addressN = validatePath(batch.path, 3);
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'rawTx', type: 'hexString', required: true },
+            ]);
+            this.params.push({
+                address_n: addressN,
+                raw_tx: formatAnyHex(batch.rawTx),
+            });
+        });
+    }
+    getVersionRange() {
+        return {
+            classic: {
+                min: '2.1.9',
+            },
+            mini: {
+                min: '2.1.9',
+            },
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('SolanaSignTx', 'SolanaSignedTx', Object.assign({}, param));
+                const { signature } = res.message;
+                responses.push({
+                    path: serializedPath(param.address_n),
+                    signature,
+                });
+            }
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
+        });
+    }
+}
+
+class StellarGetAddress extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
+    init() {
+        var _a;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            var _a;
+            const addressN = validatePath(batch.path, 3);
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'showOnOneKey', type: 'boolean' },
+            ]);
+            const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+            this.params.push({
+                address_n: addressN,
+                show_display: showOnOneKey,
+            });
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('StellarGetAddress', 'StellarAddress', Object.assign({}, param));
+                const { address } = res.message;
+                responses.push({
+                    path: serializedPath(param.address_n),
+                    address,
+                });
+            }
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
+        });
+    }
+}
+
+class StellarSignTransaction extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.operations = [];
+        this.parseOperation = (op) => {
+            switch (op.type) {
+                case 'createAccount':
+                    validateParams(op, [
+                        { name: 'destination', type: 'string', required: true },
+                        { name: 'startingBalance', type: 'bigNumber', required: true },
+                    ]);
+                    return {
+                        type: 'StellarCreateAccountOp',
+                        source_account: op.source,
+                        new_account: op.destination,
+                        starting_balance: op.startingBalance,
+                    };
+                case 'payment':
+                    validateParams(op, [
+                        { name: 'destination', type: 'string', required: true },
+                        { name: 'amount', type: 'bigNumber', required: true },
+                        { name: 'asset', required: true },
+                    ]);
+                    return {
+                        type: 'StellarPaymentOp',
+                        source_account: op.source,
+                        destination_account: op.destination,
+                        asset: op.asset,
+                        amount: op.amount,
+                    };
+                case 'pathPayment':
+                    validateParams(op, [{ name: 'destAmount', type: 'bigNumber', required: true }]);
+                    return {
+                        type: 'StellarPathPaymentOp',
+                        source_account: op.source,
+                        send_asset: op.sendAsset,
+                        send_max: op.sendMax,
+                        destination_account: op.destination,
+                        destination_asset: op.destAsset,
+                        destination_amount: op.destAmount,
+                        paths: op.path,
+                    };
+                case 'createPassiveOffer':
+                    validateParams(op, [{ name: 'amount', type: 'bigNumber', required: true }]);
+                    return {
+                        type: 'StellarCreatePassiveOfferOp',
+                        source_account: op.source,
+                        buying_asset: op.buying,
+                        selling_asset: op.selling,
+                        amount: op.amount,
+                        price_n: op.price.n,
+                        price_d: op.price.d,
+                    };
+                case 'manageOffer':
+                    validateParams(op, [{ name: 'amount', type: 'bigNumber', required: true }]);
+                    return {
+                        type: 'StellarManageOfferOp',
+                        source_account: op.source,
+                        buying_asset: op.buying,
+                        selling_asset: op.selling,
+                        amount: op.amount,
+                        offer_id: op.offerId,
+                        price_n: op.price.n,
+                        price_d: op.price.d,
+                    };
+                case 'setOptions': {
+                    const signer = op.signer
+                        ? {
+                            signer_type: op.signer.type,
+                            signer_key: op.signer.key,
+                            signer_weight: op.signer.weight,
+                        }
+                        : undefined;
+                    return Object.assign({ type: 'StellarSetOptionsOp', source_account: op.source, clear_flags: op.clearFlags, set_flags: op.setFlags, master_weight: op.masterWeight, low_threshold: op.lowThreshold, medium_threshold: op.medThreshold, high_threshold: op.highThreshold, home_domain: op.homeDomain, inflation_destination_account: op.inflationDest }, signer);
+                }
+                case 'changeTrust':
+                    validateParams(op, [{ name: 'limit', type: 'bigNumber' }]);
+                    return {
+                        type: 'StellarChangeTrustOp',
+                        source_account: op.source,
+                        asset: op.line,
+                        limit: op.limit,
+                    };
+                case 'allowTrust':
+                    return {
+                        type: 'StellarAllowTrustOp',
+                        source_account: op.source,
+                        trusted_account: op.trustor,
+                        asset_type: op.assetType,
+                        asset_code: op.assetCode,
+                        is_authorized: op.authorize ? 1 : 0,
+                    };
+                case 'accountMerge':
+                    return {
+                        type: 'StellarAccountMergeOp',
+                        source_account: op.source,
+                        destination_account: op.destination,
+                    };
+                case 'manageData':
+                    return {
+                        type: 'StellarManageDataOp',
+                        source_account: op.source,
+                        key: op.name,
+                        value: op.value,
+                    };
+                case 'bumpSequence':
+                    return {
+                        type: 'StellarBumpSequenceOp',
+                        source_account: op.source,
+                        bump_to: op.bumpTo,
+                    };
+                default:
+                    return {};
+            }
+        };
+        this.processTxRequest = (operations, index) => __awaiter(this, void 0, void 0, function* () {
+            const isLastOp = index + 1 >= operations.length;
+            const _a = operations[index], { type } = _a, op = __rest(_a, ["type"]);
+            if (isLastOp) {
+                const response = yield this.device.commands.typedCall(type, 'StellarSignedTx', op);
+                return response.message;
+            }
+            yield this.device.commands.typedCall(type, 'StellarTxOpRequest', op);
+            return this.processTxRequest(operations, index + 1);
+        });
+    }
+    init() {
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        validateParams(this.payload, [
+            { name: 'path', required: true },
+            { name: 'networkPassphrase', type: 'string', required: true },
+            { name: 'transaction', type: 'object', required: true },
+        ]);
+        const addressN = validatePath(this.payload.path, 3);
+        const { transaction, networkPassphrase } = this.payload;
+        this.params = {
+            address_n: addressN,
+            network_passphrase: networkPassphrase,
+            source_account: transaction.source,
+            fee: transaction.fee,
+            sequence_number: transaction.sequence,
+            num_operations: transaction.operations.length,
+        };
+        if (transaction.timebounds) {
+            this.params.timebounds_start = transaction.timebounds.minTime;
+            this.params.timebounds_end = transaction.timebounds.maxTime;
+        }
+        if (transaction.memo) {
+            this.params.memo_type = transaction.memo.type;
+            this.params.memo_text = transaction.memo.text;
+            this.params.memo_id = transaction.memo.id;
+            this.params.memo_hash = transaction.memo.hash;
+        }
+        transaction.operations.forEach(op => {
+            const transformed = this.parseOperation(op);
+            if (transformed) {
+                this.operations.push(transformed);
+            }
+        });
+        console.log('StellarSignTransactionParams', this.params);
+        console.log('StellarSignTransactionOperations', this.operations);
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.device.commands.typedCall('StellarSignTx', 'StellarTxOpRequest', Object.assign({}, this.params));
+            return this.processTxRequest(this.operations, 0);
+        });
+    }
+}
+
 var ApiMethods = /*#__PURE__*/Object.freeze({
     __proto__: null,
     searchDevices: SearchDevices,
     getFeatures: GetFeatures,
+    cipherKeyValue: CipherKeyValue,
     btcGetAddress: BTCGetAddress,
     btcGetPublicKey: BTCGetPublicKey,
     btcSignMessage: BTCSignMessage,
@@ -12177,15 +12855,21 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     evmGetAddress: EvmGetAddress,
     evmGetPublicKey: EVMGetPublicKey,
     evmSignMessage: EVMSignMessage$2,
-    evmSignMessageEIP712: EVMSignMessageEIP712$1,
+    evmSignMessageEIP712: EVMSignMessageEIP712,
     evmSignTransaction: EVMSignTransaction,
-    evmSignTypedData: EVMSignMessageEIP712,
+    evmSignTypedData: EVMSignTypedData,
     evmVerifyMessage: EVMSignMessage$1,
     starcoinGetAddress: StarcoinGetAddress,
     starcoinGetPublicKey: StarcoinGetPublicKey,
     starcoinSignMessage: StarcoinSignMessage,
     starcoinSignTransaction: StarcoinSignTransaction,
-    starcoinVerifyMessage: EVMSignMessage
+    starcoinVerifyMessage: EVMSignMessage,
+    nemGetAddress: NEMGetAddress,
+    nemSignTransaction: NEMSignTransaction,
+    solGetAddress: SolGetAddress,
+    solSignTransaction: SolSignTransaction,
+    stellarGetAddress: StellarGetAddress,
+    stellarSignTransaction: StellarSignTransaction
 });
 
 function findMethod(message) {
@@ -12403,6 +13087,22 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
     });
     try {
         const inner = () => __awaiter(void 0, void 0, void 0, function* () {
+            const deviceType = getDeviceType(device.features);
+            const deviceModel = getDeviceModel(device.features);
+            const versionRangeType = method.getVersionRange()[deviceType];
+            const versionRangeModel = method.getVersionRange()[deviceModel];
+            const versionRange = versionRangeType !== null && versionRangeType !== void 0 ? versionRangeType : versionRangeModel;
+            if (versionRange && device.features) {
+                const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+                if (semver__default["default"].valid(versionRange.min) && semver__default["default"].lt(currentVersion, versionRange.min)) {
+                    return Promise.reject(TypedError('Device_FwException', `Device firmware version is too low, please update to ${versionRange.min}`));
+                }
+                if (versionRange.max &&
+                    semver__default["default"].valid(versionRange.max) &&
+                    semver__default["default"].gt(currentVersion, versionRange.max)) {
+                    return Promise.reject(TypedError('Device_FwException', `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`));
+                }
+            }
             const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
             if (unexpectedMode) {
                 return Promise.reject(TypedError('Device_UnexpectedMode', unexpectedMode));
@@ -12436,6 +13136,7 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
     catch (error) {
         messageResponse = createResponseMessage(method.responseID, false, error);
         _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.reject(TypedError('Call_API', error));
+        Log.debug('Call API - Run Error: ', error);
     }
     finally {
         const response = messageResponse;
@@ -12514,7 +13215,15 @@ const onDevicePinHandler = (...[device, type, callback]) => __awaiter(void 0, vo
 });
 const onDeviceButtonHandler = (...[device, request]) => {
     postMessage(createDeviceMessage(DEVICE.BUTTON, Object.assign(Object.assign({}, request), { device: device.toMessageObject() })));
-    postMessage(createUiMessage(UI_REQUEST$1.REQUEST_BUTTON, { device: device.toMessageObject() }));
+    if (request.code === 'ButtonRequest_PinEntry') {
+        postMessage(createUiMessage(UI_REQUEST$1.REQUEST_PIN, {
+            device: device.toMessageObject(),
+            type: 'ButtonRequest_PinEntry',
+        }));
+    }
+    else {
+        postMessage(createUiMessage(UI_REQUEST$1.REQUEST_BUTTON, { device: device.toMessageObject() }));
+    }
 };
 const postMessage = (message) => {
     _core.emit(CORE_EVENT, message);