@onekeyfe/hd-core 1.2.0-alpha.13 → 1.2.0-alpha.130

package/src/data/messages/messages.json

@@ -6082,7 +6082,6 @@
           }
         },
         "raw_message": {
-          "rule": "required",
           "type": "bytes",
           "id": 2
         },
@@ -6113,6 +6112,42 @@
           "options": {
             "default": true
           }
+        },
+        "output_count": {
+          "type": "uint32",
+          "id": 7
+        },
+        "version": {
+          "type": "uint32",
+          "id": 8,
+          "options": {
+            "default": 0
+          }
+        },
+        "lock_time": {
+          "type": "uint64",
+          "id": 9,
+          "options": {
+            "default": 0
+          }
+        },
+        "subnetwork_id": {
+          "type": "bytes",
+          "id": 10
+        },
+        "gas": {
+          "type": "uint64",
+          "id": 11,
+          "options": {
+            "default": 0
+          }
+        },
+        "payload_length": {
+          "type": "uint32",
+          "id": 12,
+          "options": {
+            "default": 0
+          }
         }
       }
     },
@@ -6146,6 +6181,249 @@
         }
       }
     },
+    "KaspaOutpoint": {
+      "fields": {
+        "tx_id": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        },
+        "index": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        }
+      }
+    },
+    "KaspaInputScriptType": {
+      "values": {
+        "KASPA_SPEND_P2PK_SCHNORR": 0,
+        "KASPA_SPEND_P2PK_ECDSA": 1
+      }
+    },
+    "KaspaOutputScriptType": {
+      "values": {
+        "KASPA_PAYTOADDRESS": 0,
+        "KASPA_PAYTOCHANGE": 1
+      }
+    },
+    "KaspaRequestType": {
+      "values": {
+        "KASPA_TX_INPUT": 0,
+        "KASPA_TX_OUTPUT": 1,
+        "KASPA_TX_PAYLOAD": 2,
+        "KASPA_TX_FINISHED": 3,
+        "KASPA_TX_PREV_META": 4
+      }
+    },
+    "KaspaTxRequestSignature": {
+      "fields": {
+        "signature_index": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        },
+        "signature": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "KaspaTxRequest": {
+      "fields": {
+        "request_type": {
+          "rule": "required",
+          "type": "KaspaRequestType",
+          "id": 1
+        },
+        "request_index": {
+          "type": "uint32",
+          "id": 2
+        },
+        "signature": {
+          "type": "KaspaTxRequestSignature",
+          "id": 3
+        },
+        "request_payload_length": {
+          "type": "uint32",
+          "id": 4
+        },
+        "prev_tx_id": {
+          "type": "bytes",
+          "id": 5
+        }
+      }
+    },
+    "KaspaTxAckInput": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "previous_outpoint": {
+          "rule": "required",
+          "type": "KaspaOutpoint",
+          "id": 2
+        },
+        "amount": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 3
+        },
+        "sequence": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 4
+        },
+        "sig_op_count": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 5
+        },
+        "script_type": {
+          "type": "KaspaInputScriptType",
+          "id": 6,
+          "options": {
+            "default": "KASPA_SPEND_P2PK_SCHNORR"
+          }
+        },
+        "use_tweak": {
+          "type": "bool",
+          "id": 9,
+          "options": {
+            "default": true
+          }
+        }
+      }
+    },
+    "KaspaTxAckOutput": {
+      "fields": {
+        "script_type": {
+          "type": "KaspaOutputScriptType",
+          "id": 1,
+          "options": {
+            "default": "KASPA_PAYTOADDRESS"
+          }
+        },
+        "amount": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 2
+        },
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 3,
+          "options": {
+            "packed": false
+          }
+        },
+        "address": {
+          "type": "string",
+          "id": 4
+        },
+        "scheme": {
+          "type": "string",
+          "id": 7,
+          "options": {
+            "default": "schnorr"
+          }
+        },
+        "use_tweak": {
+          "type": "bool",
+          "id": 8,
+          "options": {
+            "default": true
+          }
+        }
+      }
+    },
+    "KaspaTxAckPayloadChunk": {
+      "fields": {
+        "payload_chunk": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
+    "KaspaTxAckPrevMeta": {
+      "fields": {
+        "version": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        },
+        "input_count": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        },
+        "output_count": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 3
+        },
+        "lock_time": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 4
+        },
+        "subnetwork_id": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 5
+        },
+        "gas": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 6
+        },
+        "payload_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 7
+        }
+      }
+    },
+    "KaspaTxAckPrevInput": {
+      "fields": {
+        "previous_outpoint": {
+          "rule": "required",
+          "type": "KaspaOutpoint",
+          "id": 1
+        },
+        "sequence": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 2
+        }
+      }
+    },
+    "KaspaTxAckPrevOutput": {
+      "fields": {
+        "amount": {
+          "rule": "required",
+          "type": "uint64",
+          "id": 1
+        },
+        "script_version": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        },
+        "script_public_key": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 3
+        }
+      }
+    },
     "KaspaSignedTx": {
       "fields": {
         "signature": {
@@ -12559,6 +12837,13 @@
         "MessageType_KaspaSignedTx": 11303,
         "MessageType_KaspaTxInputRequest": 11304,
         "MessageType_KaspaTxInputAck": 11305,
+        "MessageType_KaspaTxRequest": 11306,
+        "MessageType_KaspaTxAckInput": 11307,
+        "MessageType_KaspaTxAckOutput": 11308,
+        "MessageType_KaspaTxAckPayloadChunk": 11309,
+        "MessageType_KaspaTxAckPrevMeta": 11310,
+        "MessageType_KaspaTxAckPrevInput": 11311,
+        "MessageType_KaspaTxAckPrevOutput": 11312,
         "MessageType_NexaGetAddress": 11400,
         "MessageType_NexaAddress": 11401,
         "MessageType_NexaSignTx": 11402,

package/src/data-manager/DataManager.ts

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import semver from 'semver';
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import MessagesJSON from '../data/messages/messages.json';
 import MessagesLegacyV1JSON from '../data/messages/messages_legacy_v1.json';
@@ -17,6 +17,7 @@ import {
 } from '../utils';
 import { DeviceModelToTypes } from '../types';
 import { findLatestRelease, getReleaseChangelog, getReleaseStatus } from '../utils/release';
+import { parseProtocolV2Resources } from '../protocols/protocol-v2/resources';
 
 import type {
   AssetsMap,
@@ -25,11 +26,14 @@ import type {
   Features,
   IDeviceBLEFirmwareStatus,
   IDeviceFirmwareStatus,
+  IFirmwareReleaseInfo,
   ITransportStatus,
   IVersionArray,
   RemoteConfigResponse,
 } from '../types';
 
+const FIRMWARE_UPDATE_CONFIG_FRESHNESS_MS = 5 * 60 * 1000;
+
 const Log = getLogger(LoggerNames.Core);
 
 export const FIRMWARE_FIELDS = [
@@ -67,7 +71,7 @@ function getFirmwareTypeFromField(firmwareField: IFirmwareField): EFirmwareType
 
 export default class DataManager {
   static deviceMap: DeviceTypeMap & {
-    [k: string]: DeviceTypeMap[keyof DeviceTypeMap] | undefined;
+    [k: string]: NonNullable<DeviceTypeMap[keyof DeviceTypeMap]> | undefined;
   } = {
     [EDeviceType.Classic]: {
       firmware: [],
@@ -90,8 +94,10 @@ export default class DataManager {
       ble: [],
     },
     [EDeviceType.Pro2]: {
-      firmware: [],
-      ble: [],
+      'firmware-v1': [],
+    },
+    [EDeviceType.Neo]: {
+      'firmware-v1': [],
     },
     [EDeviceType.ClassicPure]: {
       firmware: [],
@@ -111,6 +117,10 @@ export default class DataManager {
 
   static lastCheckTimestamp = 0;
 
+  static protocolV2ResourcesConfigError: Error | undefined;
+
+  private static protocolV2NeoResourcesConfigError: Error | undefined;
+
   static getFirmwareStatus = (
     features: Features,
     firmwareType: EFirmwareType
@@ -309,15 +319,15 @@ export default class DataManager {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) return 'unknown';
 
-    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+    const deviceBleFirmwareVersion = getDeviceBLEFirmwareVersion(features);
 
     /** mini has no device ble_ver */
-    if (!deviceBLEFirmwareVersion) {
+    if (!deviceBleFirmwareVersion) {
       return 'none';
     }
 
     const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
-    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    const currentVersion = deviceBleFirmwareVersion.join('.');
     return getReleaseStatus(targetDeviceConfigList, currentVersion);
   };
 
@@ -325,14 +335,14 @@ export default class DataManager {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) return [];
 
-    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+    const deviceBleFirmwareVersion = getDeviceBLEFirmwareVersion(features);
 
-    if (!deviceBLEFirmwareVersion) {
+    if (!deviceBleFirmwareVersion) {
       return [];
     }
 
     const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
-    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    const currentVersion = deviceBleFirmwareVersion.join('.');
     return getReleaseChangelog(targetDeviceConfigList, currentVersion);
   };
 
@@ -355,7 +365,7 @@ export default class DataManager {
 
   private static enrichFirmwareReleaseInfo(
     deviceData: DeviceTypeMap[keyof DeviceTypeMap] | undefined
-  ): DeviceTypeMap[keyof DeviceTypeMap] {
+  ): NonNullable<DeviceTypeMap[keyof DeviceTypeMap]> {
     // Safety check: return default structure if input is undefined/null
     if (!deviceData || typeof deviceData !== 'object') {
       return {
@@ -397,10 +407,56 @@ export default class DataManager {
     return enrichedData;
   }
 
-  static async load(settings: ConnectSettings) {
+  private static enrichProtocolV2FirmwareReleaseInfo(
+    deviceData: DeviceTypeMap[keyof DeviceTypeMap] | undefined,
+    onResourcesError: (error: Error) => void
+  ): NonNullable<DeviceTypeMap[keyof DeviceTypeMap]> {
+    const enrichedData = this.enrichFirmwareReleaseInfo(deviceData);
+    const releases = enrichedData['firmware-v1'];
+    if (!Array.isArray(releases)) {
+      return enrichedData;
+    }
+    const latestRelease = findLatestRelease(releases);
+
+    return {
+      ...enrichedData,
+      'firmware-v1': releases.map(release => {
+        const { resources: rawResources, ...releaseWithoutResources } = release;
+        try {
+          const resources = parseProtocolV2Resources(rawResources);
+          return {
+            ...releaseWithoutResources,
+            ...(resources ? { resources } : undefined),
+          };
+        } catch (error) {
+          if (release === latestRelease) {
+            onResourcesError(error instanceof Error ? error : new Error(String(error)));
+          }
+          return releaseWithoutResources;
+        }
+      }),
+    };
+  }
+
+  static async load(settings: ConnectSettings): Promise<boolean> {
     this.settings = settings;
-    if (!settings.fetchConfig) {
-      return;
+    this.protocolV2ResourcesConfigError = undefined;
+    this.protocolV2NeoResourcesConfigError = undefined;
+    const manifestMode =
+      settings.firmwareManifestMode ?? (settings.fetchConfig ? 'sdk-managed' : undefined);
+    if (settings.preloadedConfig) {
+      this.applyRemoteConfig(settings.preloadedConfig);
+      Log.log('[DataConfig] Preloaded firmware config loaded');
+      return true;
+    }
+    if (manifestMode === 'external-only') {
+      Log.warn(
+        '[DataConfig] External firmware config is unavailable; SDK-managed networking remains disabled'
+      );
+      return false;
+    }
+    if (manifestMode !== 'sdk-managed') {
+      return false;
     }
 
     const url = settings.preRelease
@@ -410,57 +466,66 @@ export default class DataManager {
     const urlWithCache = `${url}?noCache=${getTimeStamp()}`;
     let data: RemoteConfigResponse | null = null;
     let fetchMethod: 'configFetcher' | 'axios' | 'none' = 'none';
-
-    // 1. Try custom configFetcher first (client-side IP direct connection support)
     if (settings.configFetcher) {
-      Log.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
+      Log.debug('[DataConfig] Trying client configFetcher...');
       try {
         data = await settings.configFetcher(urlWithCache);
         if (data) {
           fetchMethod = 'configFetcher';
-          Log.log('[DataConfig] ConfigFetcher success');
-        } else {
-          Log.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
         }
       } catch (e) {
-        Log.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
+        Log.warn('[DataConfig] Client configFetcher failed:', e);
       }
     }
-
-    // 2. Fallback to default axios request
     if (!data) {
-      Log.debug('[DataConfig] Trying axios (SDK default fetcher)...');
+      Log.debug('[DataConfig] Trying SDK-managed config request...');
       try {
         const response = await axios.get<RemoteConfigResponse>(urlWithCache, {
-          // because of iframe timeout is 10000
+          // Keep the config request below the 20-second iframe initialization timeout.
           timeout: 7000,
         });
         data = response.data;
         fetchMethod = 'axios';
-        Log.log('[DataConfig] Axios fetch success');
+        Log.log('[DataConfig] SDK-managed config request succeeded');
       } catch (e) {
-        Log.warn('[DataConfig] Axios fetch error:', e);
+        Log.warn('[DataConfig] SDK-managed config request failed:', e);
       }
     }
 
-    // 3. Apply config if available
     if (data) {
+      this.applyRemoteConfig(data);
       Log.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
-      this.deviceMap = {
-        [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
-        [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
-        [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
-        [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
-        [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
-        [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
-        [EDeviceType.Pro2]: this.enrichFirmwareReleaseInfo(data.pro2),
-      };
-      this.assets = {
-        bridge: data.bridge,
-      };
-    } else {
-      Log.warn('[DataConfig] All fetch methods failed, using built-in default config');
+      return true;
     }
+    Log.warn('[DataConfig] All fetch methods failed, using built-in default config');
+    return false;
+  }
+
+  private static applyRemoteConfig(data: RemoteConfigResponse) {
+    const pro2Config = this.enrichProtocolV2FirmwareReleaseInfo(data.pro2, error => {
+      // Firmware resource metadata is not required for base communication. If the
+      // The selected release is incomplete, so disable its resource update only.
+      this.protocolV2ResourcesConfigError = error;
+      Log.warn('[DataConfig] Ignoring invalid Pro2 release resources config:', error);
+    });
+    const neoConfig = this.enrichProtocolV2FirmwareReleaseInfo(data.neo, error => {
+      this.protocolV2NeoResourcesConfigError = error;
+      Log.warn('[DataConfig] Ignoring invalid Neo release resources config:', error);
+    });
+    this.deviceMap = {
+      [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
+      [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
+      [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
+      [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
+      [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
+      [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
+      [EDeviceType.Pro2]: pro2Config,
+      [EDeviceType.Neo]: neoConfig,
+    };
+    this.assets = {
+      bridge: data.bridge,
+    };
+    this.lastCheckTimestamp = getTimeStamp();
   }
 
   static updateEnv(newEnv: ConnectSettings['env']) {
@@ -478,10 +543,63 @@ export default class DataManager {
 
   static async checkAndReloadData() {
     if (getTimeStamp() - this.lastCheckTimestamp > 1000 * 60 * 60 * 3) {
-      await this.load(this.settings).then(() => {
+      const loaded = await this.load(this.settings);
+      if (loaded) {
         this.lastCheckTimestamp = getTimeStamp();
-      });
+      }
+    }
+  }
+
+  /** Force a fresh remote config before an update is allowed to mutate the device. */
+  static async forceReloadData({
+    requireResources = false,
+    resourceDeviceType = EDeviceType.Pro2,
+  }: {
+    requireResources?: boolean;
+    resourceDeviceType?: EDeviceType.Pro2 | EDeviceType.Neo;
+  } = {}): Promise<void> {
+    const resourceDeviceName = resourceDeviceType === EDeviceType.Pro2 ? 'Pro2' : 'Neo';
+    if (!this.settings) {
+      throw new Error('Remote config settings are not initialized');
     }
+    const hasFreshConfig =
+      this.lastCheckTimestamp > 0 &&
+      getTimeStamp() - this.lastCheckTimestamp <= FIRMWARE_UPDATE_CONFIG_FRESHNESS_MS;
+    if (hasFreshConfig) {
+      const resourcesConfigError =
+        resourceDeviceType === EDeviceType.Pro2
+          ? this.protocolV2ResourcesConfigError
+          : this.protocolV2NeoResourcesConfigError;
+      if (requireResources && resourcesConfigError) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.FirmwareUpdateDownloadFailed,
+          `Invalid ${resourceDeviceName} resources config: ${resourcesConfigError.message}`
+        );
+      }
+      return;
+    }
+    const loaded = await this.load(this.settings);
+    if (!loaded) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.NetworkError,
+        'Unable to refresh the latest remote config'
+      );
+    }
+    const resourcesConfigError =
+      resourceDeviceType === EDeviceType.Pro2
+        ? this.protocolV2ResourcesConfigError
+        : this.protocolV2NeoResourcesConfigError;
+    if (requireResources && resourcesConfigError) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.FirmwareUpdateDownloadFailed,
+        `Invalid ${resourceDeviceName} resources config: ${resourcesConfigError.message}`
+      );
+    }
+    this.lastCheckTimestamp = getTimeStamp();
+  }
+
+  static getProtocolV2ResourceSource(release: IFirmwareReleaseInfo | undefined) {
+    return release?.resources?.source;
   }
 
   static getProtobufMessages(schema: ProtobufMessageSchema = 'v1CurrentSchema'): JSON {

package/src/data-manager/TransportManager.ts

@@ -17,7 +17,7 @@ const LowLevelLogger = getLogger(LoggerNames.HdTransportLowLevel);
 const NodeUsbLogger = getLogger(LoggerNames.HdTransportNodeUsb);
 const WebBleLogger = getLogger(LoggerNames.HdWebBleTransport);
 const WebUsbLogger = getLogger(LoggerNames.HdTransportWebUsb);
-const REACT_NATIVE_BLE_SCAN_TIMEOUT_MS = 8000;
+const REACT_NATIVE_BLE_SCAN_TIMEOUT_MS = 3000;
 
 /**
  * transport 在同一个环境中只会存在一个
@@ -121,6 +121,12 @@ export default class TransportManager {
   }
 
   static setTransport(TransportConstructor: any, plugin?: LowlevelTransportSharedPlugin) {
+    if (typeof TransportConstructor !== 'function') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.TransportNotConfigured,
+        'Transport constructor is not available'
+      );
+    }
     const env = DataManager.getSettings('env');
     if (env === 'react-native') {
       /** Actually initializes the ReactNativeTransport */

package/src/data-manager/connectSettings.ts

@@ -115,10 +115,21 @@ export const parseConnectSettings = (input: Partial<ConnectSettings> = {}) => {
     settings.fetchConfig = input.fetchConfig;
   }
 
+  if (
+    input.firmwareManifestMode === 'sdk-managed' ||
+    input.firmwareManifestMode === 'external-only'
+  ) {
+    settings.firmwareManifestMode = input.firmwareManifestMode;
+  }
+
   if (input.configFetcher) {
     settings.configFetcher = input.configFetcher;
   }
 
+  if (input.preloadedConfig) {
+    settings.preloadedConfig = input.preloadedConfig;
+  }
+
   return settings;
 };