@onekeyfe/hd-core 1.1.25-alpha.1 → 1.1.26-alpha.0

package/src/api/stellar/StellarSignTransaction.ts

@@ -12,9 +12,22 @@ import type {
 } from '@onekeyfe/hd-transport';
 import type { StellarOperation, StellarSignTransactionParams } from '../../types';
 
+// Firmware accepts up to 1024 bytes per chunk; 1 byte = 2 hex chars
+const SOROBAN_CHUNK_BYTES = 1024;
+const SOROBAN_CHUNK_HEX_CHARS = SOROBAN_CHUNK_BYTES * 2;
+
 export default class StellarSignTransaction extends BaseMethod<HardwareStellarSignTx> {
   operations: any[] = [];
 
+  private sorobanState?: {
+    callArgs: string;
+    callArgsSent: number;
+    auth: string;
+    authSent: number;
+    ext: string;
+    extSent: number;
+  };
+
   parseOperation = (op: StellarOperation) => {
     switch (op.type) {
       case 'createAccount':
@@ -144,6 +157,59 @@ export default class StellarSignTransaction extends BaseMethod<HardwareStellarSi
           source_account: op.source,
           bump_to: op.bumpTo,
         };
+
+      case 'invokeHostFunctionOneKey': {
+        const callArgs = op.callArgsXDRHex ?? '';
+        const auth = op.sorobanAuthXDRHex ?? '';
+
+        if (!this.sorobanState) {
+          throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'sorobanState not initialized');
+        }
+        this.sorobanState.callArgs = callArgs;
+        this.sorobanState.callArgsSent = Math.min(callArgs.length, SOROBAN_CHUNK_HEX_CHARS);
+        this.sorobanState.auth = auth;
+        this.sorobanState.authSent = Math.min(auth.length, SOROBAN_CHUNK_HEX_CHARS);
+
+        return {
+          type: 'StellarInvokeHostFunctionOp',
+          source_account: op.source,
+          contract_address: op.contract,
+          function_name: op.functionName,
+          call_args_xdr_size: callArgs.length / 2,
+          call_args_xdr_initial_chunk: callArgs.slice(0, SOROBAN_CHUNK_HEX_CHARS),
+          soroban_auth_xdr_size: auth.length / 2,
+          soroban_auth_xdr_initial_chunk: auth.slice(0, SOROBAN_CHUNK_HEX_CHARS),
+        };
+      }
+
+      case 'pathPaymentStrictReceive':
+        validateParams(op, [{ name: 'sendMax', type: 'bigNumber', required: true }]);
+        validateParams(op, [{ name: 'destAmount', type: 'bigNumber', required: true }]);
+        return {
+          type: 'StellarPathPaymentStrictReceiveOp',
+          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 'pathPaymentStrictSend':
+        validateParams(op, [{ name: 'sendAmount', type: 'bigNumber', required: true }]);
+        validateParams(op, [{ name: 'destMin', type: 'bigNumber', required: true }]);
+        return {
+          type: 'StellarPathPaymentStrictSendOp',
+          source_account: op.source,
+          send_asset: op.sendAsset,
+          send_amount: op.sendAmount,
+          destination_account: op.destination,
+          destination_asset: op.destAsset,
+          destination_min: op.destMin,
+          paths: op.path,
+        };
+
       default:
         return {};
     }
@@ -171,6 +237,31 @@ export default class StellarSignTransaction extends BaseMethod<HardwareStellarSi
     // init params
     const addressN = validatePath(this.payload.path, 3);
 
+    const isSoroban = transaction.operations.some(op => op.type === 'invokeHostFunctionOneKey');
+
+    if (isSoroban) {
+      if (transaction.operations.length !== 1) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.CallMethodInvalidParameter,
+          'Soroban transactions must contain exactly one operation'
+        );
+      }
+      if (!transaction.sorobanDataXDR) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.CallMethodInvalidParameter,
+          'sorobanDataXDR is required for Soroban transactions'
+        );
+      }
+      this.sorobanState = {
+        callArgs: '',
+        callArgsSent: 0,
+        auth: '',
+        authSent: 0,
+        ext: transaction.sorobanDataXDR,
+        extSent: 0,
+      };
+    }
+
     this.params = {
       address_n: addressN,
       network_passphrase: networkPassphrase,
@@ -181,6 +272,7 @@ export default class StellarSignTransaction extends BaseMethod<HardwareStellarSi
       memo_type: StellarMemoType.NONE,
       timebounds_start: transaction.timebounds.minTime,
       timebounds_end: transaction.timebounds.maxTime,
+      ...(this.sorobanState ? { soroban_data_size: this.sorobanState.ext.length / 2 } : {}),
     };
 
     if (transaction.memo) {
@@ -198,23 +290,85 @@ export default class StellarSignTransaction extends BaseMethod<HardwareStellarSi
     });
   }
 
-  processTxRequest = async (operations: any, index: number): Promise<StellarSignedTx> => {
-    const isLastOp = index + 1 >= operations.length;
-    const { type, ...op } = operations[index];
+  processTxRequest = async (
+    response: { type: string; message: any },
+    operations: any[],
+    index: number
+  ): Promise<StellarSignedTx> => {
+    switch (response.type) {
+      case 'StellarSignedTx':
+        return response.message;
 
-    if (isLastOp) {
-      const response = await this.device.commands.typedCall(type, 'StellarSignedTx', op);
-      return response.message;
-    }
+      case 'StellarSorobanDataRequest': {
+        if (!this.sorobanState) {
+          throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'sorobanState not initialized');
+        }
 
-    await this.device.commands.typedCall(type, 'StellarTxOpRequest', op);
+        const reqType = response.message.type as string;
+        // data_length 是字节数，转为 hex 字符数
+        const hexLen = (response.message.data_length as number) * 2;
+        let chunk: string;
+
+        switch (reqType) {
+          // CALL: invoke contract call_args
+          case 'CALL': {
+            const { callArgs, callArgsSent } = this.sorobanState;
+            chunk = callArgs.slice(callArgsSent, callArgsSent + hexLen);
+            this.sorobanState.callArgsSent += chunk.length;
+            break;
+          }
+          // AUTH: soroban authorization entries
+          case 'AUTH': {
+            const { auth, authSent } = this.sorobanState;
+            chunk = auth.slice(authSent, authSent + hexLen);
+            this.sorobanState.authSent += chunk.length;
+            break;
+          }
+          // EXT: soroban transaction extension data
+          case 'EXT': {
+            const { ext, extSent } = this.sorobanState;
+            chunk = ext.slice(extSent, extSent + hexLen);
+            this.sorobanState.extSent += chunk.length;
+            break;
+          }
+          default:
+            throw ERRORS.TypedError(
+              HardwareErrorCode.RuntimeError,
+              `unknown soroban request type: ${reqType}`
+            );
+        }
+
+        const sorobanRes = await this.device.commands.typedCall(
+          'StellarSorobanDataAck',
+          ['StellarSorobanDataRequest', 'StellarSignedTx'],
+          { data_xdr: chunk }
+        );
+        return this.processTxRequest(sorobanRes, operations, index);
+      }
 
-    return this.processTxRequest(operations, index + 1);
+      case 'StellarTxOpRequest': {
+        const { type, ...op } = operations[index];
+        const nextRes = await this.device.commands.typedCall(
+          type,
+          ['StellarTxOpRequest', 'StellarSorobanDataRequest', 'StellarSignedTx'],
+          op
+        );
+        return this.processTxRequest(nextRes, operations, index + 1);
+      }
+
+      default:
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `unexpected response type: ${response.type}`
+        );
+    }
   };
 
   async run() {
-    await this.device.commands.typedCall('StellarSignTx', 'StellarTxOpRequest', { ...this.params });
+    const response = await this.device.commands.typedCall('StellarSignTx', 'StellarTxOpRequest', {
+      ...this.params,
+    });
 
-    return this.processTxRequest(this.operations, 0);
+    return this.processTxRequest(response, this.operations, 0);
   }
 }

package/src/data/messages/messages.json

@@ -10274,6 +10274,13 @@
           "rule": "required",
           "type": "uint32",
           "id": 14
+        },
+        "soroban_data_size": {
+          "type": "uint32",
+          "id": 60,
+          "options": {
+            "default": 0
+          }
         }
       },
       "nested": {
@@ -10666,6 +10673,76 @@
         }
       }
     },
+    "StellarInvokeHostFunctionOp": {
+      "fields": {
+        "source_account": {
+          "type": "string",
+          "id": 1
+        },
+        "contract_address": {
+          "rule": "required",
+          "type": "string",
+          "id": 2
+        },
+        "function_name": {
+          "rule": "required",
+          "type": "string",
+          "id": 3
+        },
+        "call_args_xdr_size": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 4
+        },
+        "call_args_xdr_initial_chunk": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 5
+        },
+        "soroban_auth_xdr_size": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 6
+        },
+        "soroban_auth_xdr_initial_chunk": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 7
+        }
+      }
+    },
+    "StellarSorobanDataRequest": {
+      "fields": {
+        "type": {
+          "rule": "required",
+          "type": "StellarRequestType",
+          "id": 1
+        },
+        "data_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 2
+        }
+      },
+      "nested": {
+        "StellarRequestType": {
+          "values": {
+            "CALL": 0,
+            "AUTH": 1,
+            "EXT": 2
+          }
+        }
+      }
+    },
+    "StellarSorobanDataAck": {
+      "fields": {
+        "data_xdr": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
     "StellarSignedTx": {
       "fields": {
         "public_key": {
@@ -12201,6 +12278,9 @@
         "MessageType_StellarManageBuyOfferOp": 222,
         "MessageType_StellarPathPaymentStrictSendOp": 223,
         "MessageType_StellarSignedTx": 230,
+        "MessageType_StellarInvokeHostFunctionOp": 260,
+        "MessageType_StellarSorobanDataRequest": 261,
+        "MessageType_StellarSorobanDataAck": 262,
         "MessageType_CardanoGetPublicKey": 305,
         "MessageType_CardanoPublicKey": 306,
         "MessageType_CardanoGetAddress": 307,

package/src/data-manager/TransportManager.ts

@@ -14,6 +14,7 @@ const Log = getLogger(LoggerNames.Transport);
 const BleLogger = getLogger(LoggerNames.HdBleTransport);
 const HttpLogger = getLogger(LoggerNames.HdTransportHttp);
 const LowLevelLogger = getLogger(LoggerNames.HdTransportLowLevel);
+const NodeUsbLogger = getLogger(LoggerNames.HdTransportNodeUsb);
 const WebBleLogger = getLogger(LoggerNames.HdWebBleTransport);
 const WebUsbLogger = getLogger(LoggerNames.HdTransportWebUsb);
 
@@ -53,11 +54,14 @@ export default class TransportManager {
         } else {
           Log.debug('React Native Do Not Initializing transports');
         }
+      } else if (env === 'node-usb') {
+        // NodeUsbTransport handles USB I/O directly — no plugin needed
+        await this.transport.init(NodeUsbLogger, DevicePool.emitter);
       } else if (env === 'lowlevel') {
         if (!this.plugin) {
           throw ERRORS.TypedError(
             HardwareErrorCode.TransportNotConfigured,
-            'Lowlevel transport mast have plugin'
+            'Lowlevel transport must have plugin'
           );
         }
         await this.transport.init(LowLevelLogger, DevicePool.emitter, this.plugin);

package/src/device/Device.ts

@@ -839,6 +839,7 @@ export class Device extends EventEmitter {
     skipPassphraseCheck?: boolean
   ) {
     if (!this.features) return false;
+
     const { passphraseState: newPassphraseState, unlockedAttachPin } =
       await getPassphraseStateWithRefreshDeviceInfo(this, {
         expectPassphraseState: passphraseState,

package/src/types/api/stellarSignTransaction.ts

@@ -110,6 +110,37 @@ type StellarInflationOperation = {
   source?: string;
 };
 
+export type StellarPathPaymentStrictReceiveOperation = {
+  type: 'pathPaymentStrictReceive';
+  source?: string;
+  sendAsset: StellarAsset;
+  sendMax: string;
+  destination: string;
+  destAsset: StellarAsset;
+  destAmount: string;
+  path?: StellarAsset[];
+};
+
+export type StellarPathPaymentStrictSendOperation = {
+  type: 'pathPaymentStrictSend';
+  source?: string;
+  sendAsset: StellarAsset;
+  sendAmount: string;
+  destination: string;
+  destAsset: StellarAsset;
+  destMin: string;
+  path?: StellarAsset[];
+};
+
+export type StellarInvokeHostFunctionOperation = {
+  type: 'invokeHostFunctionOneKey';
+  source?: string;
+  contract: string;
+  functionName: string;
+  callArgsXDRHex: string;
+  sorobanAuthXDRHex: string;
+};
+
 export type StellarOperation =
   | StellarCreateAccountOperation
   | StellarPaymentOperation
@@ -122,7 +153,10 @@ export type StellarOperation =
   | StellarAccountMergeOperation
   | StellarInflationOperation
   | StellarManageDataOperation
-  | StellarBumpSequenceOperation;
+  | StellarBumpSequenceOperation
+  | StellarPathPaymentStrictReceiveOperation
+  | StellarPathPaymentStrictSendOperation
+  | StellarInvokeHostFunctionOperation;
 
 export type StellarTransaction = {
   source: string;
@@ -139,6 +173,7 @@ export type StellarTransaction = {
     hash?: string | Buffer;
   };
   operations: StellarOperation[];
+  sorobanDataXDR?: string;
 };
 
 export type StellarSignTransactionParams = {

package/src/types/settings.ts

@@ -11,7 +11,8 @@ export type transportEnv =
   | 'desktop-webusb'
   | 'desktop-web-ble'
   | 'emulator'
-  | 'lowlevel';
+  | 'lowlevel'
+  | 'node-usb';
 export type ConnectSettings = {
   connectSrc?: string;
   debug?: boolean;

package/src/utils/logger.ts

@@ -160,6 +160,7 @@ export enum LoggerNames {
   HdBleTransport = '@onekey/hd-ble-transport',
   HdWebBleTransport = '@onekey/hd-web-ble-transport',
   HdTransportWebUsb = '@onekey/hd-transport-webusb',
+  HdTransportNodeUsb = '@onekey/hd-transport-node-usb',
   Connect = '@onekey/connect',
   Iframe = 'IFrame',
   SendMessage = '[SendMessage]',
@@ -180,6 +181,7 @@ export const LoggerMap = {
   [LoggerNames.HdWebBleTransport]: initLog(LoggerNames.HdWebBleTransport),
   [LoggerNames.HdTransportLowLevel]: initLog(LoggerNames.HdTransportLowLevel),
   [LoggerNames.HdTransportWebUsb]: initLog(LoggerNames.HdTransportWebUsb),
+  [LoggerNames.HdTransportNodeUsb]: initLog(LoggerNames.HdTransportNodeUsb),
   [LoggerNames.Connect]: initLog(LoggerNames.Connect),
   [LoggerNames.Iframe]: initLog(LoggerNames.Iframe),
   [LoggerNames.SendMessage]: initLog(LoggerNames.SendMessage),