@onekeyfe/hd-core 1.2.8-alpha.11 → 1.2.8-alpha.111

package/src/api/index.ts

@@ -175,3 +175,5 @@ export { default as benfenSignTransaction } from './benfen/BenfenSignTransaction
 
 export { default as neoGetAddress } from './neo/NeoGetAddress';
 export { default as neoSignTransaction } from './neo/NeoSignTransaction';
+export { default as zcashGetAddress } from './zcash/ZcashGetAddress';
+export { default as zcashSignPczt } from './zcash/ZcashSignPczt';

package/src/api/zcash/ZcashGetAddress.ts

@@ -0,0 +1,121 @@
+import { ZcashAddressScope, ZcashAddressType } from '@onekeyfe/hd-transport';
+
+import { BaseMethod } from '../BaseMethod';
+import { serializedPath, toHardened, validatePath } from '../helpers/pathUtils';
+import { invalidParameter, validateParams, validateResult } from '../helpers/paramsValidator';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { ZcashGetAddress as HardwareZcashGetAddress } from '@onekeyfe/hd-transport';
+import type { ZcashGetAddressParams, ZcashAddress } from '../../types/api/zcashGetAddress';
+import type { DeviceFirmwareRange } from '../../types';
+
+export default class ZcashGetAddress extends BaseMethod<HardwareZcashGetAddress[]> {
+  hasBundle = false;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+    payload.bundle.forEach((batch: ZcashGetAddressParams) => {
+      // ZIP-32 account path: m/32'/133'/account'
+      const addressN = validatePath(batch.path, 3);
+      if (
+        addressN.length !== 3 ||
+        addressN[0] !== toHardened(32) ||
+        addressN[1] !== toHardened(133) ||
+        addressN[2] < toHardened(0) ||
+        addressN[2] > 0xffffffff
+      ) {
+        throw invalidParameter("Zcash requires a ZIP-32 account path m/32'/133'/account'");
+      }
+      const addressType = batch.addressType ?? ZcashAddressType.UNIFIED_ORCHARD_P2PKH;
+      const scope = batch.scope ?? ZcashAddressScope.EXTERNAL;
+      const diversifierIndex = batch.diversifierIndex ?? 0;
+      if (
+        ![
+          ZcashAddressType.UNIFIED_ORCHARD_P2PKH,
+          ZcashAddressType.TRANSPARENT_P2PKH,
+          ZcashAddressType.UNIFIED_ORCHARD,
+        ].includes(addressType) ||
+        ![ZcashAddressScope.EXTERNAL, ZcashAddressScope.INTERNAL].includes(scope)
+      ) {
+        throw invalidParameter('Invalid Zcash address type or scope');
+      }
+      const maxIndex = addressType === ZcashAddressType.UNIFIED_ORCHARD ? 0xffffffff : 0x7fffffff;
+      if (
+        !Number.isSafeInteger(diversifierIndex) ||
+        diversifierIndex < 0 ||
+        diversifierIndex > maxIndex
+      ) {
+        throw invalidParameter('Invalid Zcash diversifier index');
+      }
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'includeUfvk', type: 'boolean' },
+        { name: 'includeSeedFingerprint', type: 'boolean' },
+      ]);
+
+      this.params.push({
+        address_n: addressN,
+        address_type: addressType,
+        scope,
+        diversifier_index: diversifierIndex,
+        show_display: batch.showOnOneKey ?? true,
+        include_ufvk: batch.includeUfvk ?? false,
+        include_seed_fingerprint: batch.includeSeedFingerprint ?? false,
+      });
+    });
+  }
+
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      model_pro2: {
+        min: '0.0.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: ZcashAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('ZcashGetAddress', 'ZcashAddress', {
+        ...param,
+      });
+
+      const path = serializedPath(param.address_n);
+      responses.push({
+        path,
+        address: res.message.address,
+        ufvk: res.message.ufvk,
+        seedFingerprint: res.message.seed_fingerprint,
+      });
+
+      this.postPreviousAddressMessage({
+        address: res.message.address,
+        path,
+      });
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/zcash/ZcashSignPczt.ts

@@ -0,0 +1,155 @@
+import { bytesToHex } from '@noble/hashes/utils';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter, validateParams } from '../helpers/paramsValidator';
+import { stripHexPrefix } from '../helpers/hexUtils';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { ZcashSignPczt as HardwareZcashSignPczt } from '@onekeyfe/hd-transport';
+import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
+import type { ZcashSignedPczt } from '../../types/api/zcashSignPczt';
+import type { DeviceFirmwareRange } from '../../types';
+
+const CHUNK_BYTE_SIZE = 1024;
+// Host memory sanity bound on the device-announced length, not a device limit.
+const SIGNED_PCZT_SANITY_MAX_BYTES = 16 * 1024 * 1024;
+
+export default class ZcashSignPczt extends BaseMethod<HardwareZcashSignPczt> {
+  pczt: Buffer = Buffer.alloc(0);
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+
+    validateParams(this.payload, [{ name: 'pczt', type: 'hexString', required: true }]);
+
+    // Reject odd-length hex instead of left-padding it, which would shift every nibble.
+    const pcztHex = stripHexPrefix(this.payload.pczt);
+    if (pcztHex.length % 2 !== 0) {
+      throw invalidParameter('pczt hex must have an even length');
+    }
+    this.pczt = Buffer.from(pcztHex, 'hex');
+    if (this.pczt.length === 0) {
+      throw invalidParameter('pczt is empty');
+    }
+
+    this.params = {
+      pczt_length: this.pczt.length,
+      pczt_initial_chunk: bytesToHex(this.pczt.subarray(0, CHUNK_BYTE_SIZE)),
+    };
+  }
+
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      model_pro2: {
+        min: '0.0.0',
+      },
+    };
+  }
+
+  // Upload: the device decides every chunk length via ZcashPcztChunkRequest and
+  // the host must answer with exactly that many bytes.
+  uploadPczt = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'ZcashSignedPczt'> | TypedResponseMessage<'ZcashPcztChunkRequest'>,
+    offset: number
+  ): Promise<TypedResponseMessage<'ZcashSignedPczt'>> => {
+    if (res.type === 'ZcashSignedPczt') {
+      if (offset !== this.pczt.length) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.ResponseUnexpectTypeError,
+          'device completed signing before receiving the whole pczt'
+        );
+      }
+      return res;
+    }
+
+    const { chunk_length: chunkLength } = res.message;
+    if (
+      !Number.isSafeInteger(chunkLength) ||
+      chunkLength <= 0 ||
+      offset + chunkLength > this.pczt.length
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        `device requested ${chunkLength} bytes at offset ${offset} of ${this.pczt.length}`
+      );
+    }
+
+    const chunk = this.pczt.subarray(offset, offset + chunkLength);
+    const next = await typedCall(
+      'ZcashPcztChunkAck',
+      ['ZcashSignedPczt', 'ZcashPcztChunkRequest'],
+      {
+        data_chunk: bytesToHex(chunk),
+      }
+    );
+
+    return this.uploadPczt(typedCall, next, offset + chunkLength);
+  };
+
+  // Download: the host decides chunk lengths via ZcashSignedPcztChunkRequest
+  // until the announced pczt_length has been received.
+  downloadSignedPczt = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'ZcashSignedPczt'>
+  ): Promise<Buffer> => {
+    const { pczt_length: total, pczt_initial_chunk: initial } = res.message;
+    if (!Number.isSafeInteger(total) || total <= 0 || total > SIGNED_PCZT_SANITY_MAX_BYTES) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        `device announced invalid signed pczt length ${total}`
+      );
+    }
+
+    const parts: Buffer[] = [Buffer.from(initial ?? '', 'hex')];
+    let received = parts[0].length;
+    if (received > total) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        'device returned more initial pczt bytes than announced'
+      );
+    }
+
+    while (received < total) {
+      const chunkLength = Math.min(CHUNK_BYTE_SIZE, total - received);
+      const ack = await typedCall('ZcashSignedPcztChunkRequest', 'ZcashPcztChunkAck', {
+        chunk_length: chunkLength,
+      });
+      const chunk = Buffer.from(ack.message.data_chunk ?? '', 'hex');
+      if (chunk.length !== chunkLength) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.ResponseUnexpectTypeError,
+          `device returned ${chunk.length} of ${chunkLength} requested bytes at offset ${received} of ${total}`
+        );
+      }
+      parts.push(chunk);
+      received += chunk.length;
+    }
+
+    return Buffer.concat(parts);
+  };
+
+  async run(): Promise<ZcashSignedPczt> {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const first = await typedCall('ZcashSignPczt', ['ZcashSignedPczt', 'ZcashPcztChunkRequest'], {
+      ...this.params,
+    });
+
+    const signed = await this.uploadPczt(
+      typedCall,
+      first,
+      Math.min(CHUNK_BYTE_SIZE, this.pczt.length)
+    );
+    const pczt = await this.downloadSignedPczt(typedCall, signed);
+
+    return { pczt: bytesToHex(pczt) };
+  }
+}

package/src/core/index.ts

@@ -1,4 +1,5 @@
 import semver from 'semver';
+import { getOwnedUsbDeviceIdentity } from '../api/SearchDevices';
 import EventEmitter from 'events';
 import {
   DeviceSessionPinType,
@@ -125,6 +126,8 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
 });
 
 let _core: Core | undefined;
+let transportSwitchGeneration = 0;
+let pendingTransportSwitch: Promise<void> = Promise.resolve();
 let _deviceList: DeviceList | undefined;
 let _connector: DeviceConnector | undefined;
 let _uiPromises: UiPromise<UiPromiseResponse['type']>[] = []; // Waiting for ui response
@@ -990,15 +993,11 @@ function canSkipInitialize(method: BaseMethod, device: Device): boolean {
 }
 
 export function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
-  const typedError = error as { errorCode?: unknown; message?: unknown };
-  const message =
-    typeof typedError?.message === 'string' ? typedError.message : String(error ?? '');
+  const typedError = error as { errorCode?: unknown; params?: { expectedProtocol?: unknown } };
   return (
     method.payload.connectProtocol === 'V2' &&
-    typedError?.errorCode === HardwareErrorCode.RuntimeError &&
-    message.includes('Device protocol mismatch') &&
-    message.includes('expected V2') &&
-    message.includes('did not respond to expected protocol')
+    typedError?.errorCode === HardwareErrorCode.TransportProtocolProbeFailed &&
+    typedError.params?.expectedProtocol === 'V2'
   );
 }
 
@@ -1008,7 +1007,7 @@ export function isRetryableBleConnectionError(method: BaseMethod, error: unknown
   }
   const typedError = error as {
     errorCode?: unknown;
-    params?: { acquireDeadlineExceeded?: unknown };
+    params?: { acquireDeadlineExceeded?: unknown; expectedProtocol?: unknown };
   };
   if (
     typedError?.errorCode === HardwareErrorCode.BleTimeoutError &&
@@ -1019,6 +1018,8 @@ export function isRetryableBleConnectionError(method: BaseMethod, error: unknown
   return (
     typedError?.errorCode === HardwareErrorCode.BleTimeoutError ||
     typedError?.errorCode === HardwareErrorCode.BleConnectedError ||
+    (typedError?.errorCode === HardwareErrorCode.TransportProtocolProbeFailed &&
+      !typedError.params?.expectedProtocol) ||
     isRetryableBleProtocolV2ProbeError(method, error) ||
     isMissingDetectedProtocolV2Error(method, error)
   );
@@ -1273,6 +1274,8 @@ const ensureConnected = async (
             HardwareErrorCode.BridgeTimeoutError,
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.WebUsbDeviceAccessError,
+            HardwareErrorCode.TransportProtocolProbeFailed,
+            HardwareErrorCode.TransportProtocolMismatch,
           ].includes(error.errorCode)
         ) {
           _deviceList = undefined;
@@ -1360,6 +1363,8 @@ const ensureConnected = async (
             HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.WebUsbDeviceAccessError,
+            HardwareErrorCode.TransportProtocolProbeFailed,
+            HardwareErrorCode.TransportProtocolMismatch,
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
           ].includes(error.errorCode) ||
@@ -1826,6 +1831,10 @@ export default class Core extends EventEmitter {
 
   private requestQueue = new RequestQueue();
 
+  getOwnedUsbDeviceIdentity(descriptor: Parameters<typeof getOwnedUsbDeviceIdentity>[0]) {
+    return getOwnedUsbDeviceIdentity(descriptor, this.requestQueue);
+  }
+
   private disposePromise?: Promise<void>;
 
   // background task
@@ -1959,6 +1968,8 @@ export default class Core extends EventEmitter {
 
   private async disposeResources(): Promise<void> {
     Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
+    transportSwitchGeneration += 1;
+    pendingTransportSwitch = Promise.resolve();
     pollingManager.stopAll();
     this.requestQueue.abortAllRequests();
     cleanup();
@@ -1993,6 +2004,8 @@ export default class Core extends EventEmitter {
 }
 
 export const initCore = () => {
+  transportSwitchGeneration += 1;
+  pendingTransportSwitch = Promise.resolve();
   const core = new Core();
   _core = core;
   return core;
@@ -2022,6 +2035,8 @@ export const init = async (
   plugin?: LowlevelTransportSharedPlugin
 ) => {
   try {
+    transportSwitchGeneration += 1;
+    pendingTransportSwitch = Promise.resolve();
     await DataManager.load(settings);
     initTransport(Transport, plugin);
     enableLog(DataManager.getSettings('debug'));
@@ -2047,10 +2062,26 @@ export const switchTransport = ({
   Transport: any;
   plugin?: LowlevelTransportSharedPlugin;
 }) => {
-  DataManager.updateEnv(env);
-  TransportManager.setTransport(Transport, plugin);
-  _deviceList = undefined;
-  DevicePool.resetState();
-  _connector = undefined;
-  initConnector();
+  const generation = transportSwitchGeneration;
+  // Preserve request order while native transport cleanup is pending.
+  const switching = pendingTransportSwitch
+    .catch(() => undefined)
+    .then(async () => {
+      if (generation !== transportSwitchGeneration) {
+        throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
+      }
+      _connector?.stop();
+      await TransportManager.getTransport()?.stop?.();
+      if (generation !== transportSwitchGeneration) {
+        throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
+      }
+      DataManager.updateEnv(env);
+      TransportManager.setTransport(Transport, plugin);
+      _deviceList = undefined;
+      DevicePool.resetState();
+      _connector = undefined;
+      initConnector();
+    });
+  pendingTransportSwitch = switching;
+  return switching;
 };

package/src/data/messages/messages-protocol-v2.json

@@ -11034,6 +11034,61 @@
         }
       }
     },
+    "ZcashSignPczt": {
+      "fields": {
+        "pczt_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        },
+        "pczt_initial_chunk": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "ZcashPcztChunkRequest": {
+      "fields": {
+        "chunk_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        }
+      }
+    },
+    "ZcashPcztChunkAck": {
+      "fields": {
+        "data_chunk": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
+    "ZcashSignedPczt": {
+      "fields": {
+        "pczt_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        },
+        "pczt_initial_chunk": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "ZcashSignedPcztChunkRequest": {
+      "fields": {
+        "chunk_length": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        }
+      }
+    },
     "wire_in": {
       "type": "bool",
       "id": 50002,
@@ -11459,6 +11514,11 @@
         "MessageType_NeoAddress": 12302,
         "MessageType_NeoSignTx": 12303,
         "MessageType_NeoSignedTx": 12304,
+        "MessageType_ZcashSignPczt": 12402,
+        "MessageType_ZcashSignedPczt": 12403,
+        "MessageType_ZcashPcztChunkRequest": 12404,
+        "MessageType_ZcashPcztChunkAck": 12405,
+        "MessageType_ZcashSignedPcztChunkRequest": 12406,
         "MessageType_DeviceFactoryInfoSet": 60000,
         "MessageType_DeviceFactoryInfoGet": 60001,
         "MessageType_DeviceFactoryInfo": 60002,
@@ -11511,7 +11571,9 @@
         "MessageType_PortfolioUpdate": 61400,
         "MessageType_NftUpdate": 61500,
         "MessageType_OnboardingStatusGet": 61600,
-        "MessageType_OnboardingStatus": 61601
+        "MessageType_OnboardingStatus": 61601,
+        "MessageType_ZcashGetAddress": 12400,
+        "MessageType_ZcashAddress": 12401
       },
       "reserved": [
         [90, 92],
@@ -13730,6 +13792,81 @@
           }
         }
       }
+    },
+    "ZcashAddressType": {
+      "values": {
+        "UNIFIED_ORCHARD_P2PKH": 0,
+        "TRANSPARENT_P2PKH": 1,
+        "UNIFIED_ORCHARD": 2
+      }
+    },
+    "ZcashAddressScope": {
+      "values": {
+        "EXTERNAL": 0,
+        "INTERNAL": 1
+      }
+    },
+    "ZcashGetAddress": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "show_display": {
+          "type": "bool",
+          "id": 2
+        },
+        "include_seed_fingerprint": {
+          "type": "bool",
+          "id": 3
+        },
+        "include_ufvk": {
+          "type": "bool",
+          "id": 4
+        },
+        "diversifier_index": {
+          "type": "uint32",
+          "id": 5,
+          "options": {
+            "default": 0
+          }
+        },
+        "address_type": {
+          "type": "ZcashAddressType",
+          "id": 6,
+          "options": {
+            "default": "UNIFIED_ORCHARD_P2PKH"
+          }
+        },
+        "scope": {
+          "type": "ZcashAddressScope",
+          "id": 7,
+          "options": {
+            "default": "EXTERNAL"
+          }
+        }
+      }
+    },
+    "ZcashAddress": {
+      "fields": {
+        "address": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        },
+        "ufvk": {
+          "type": "string",
+          "id": 2
+        },
+        "seed_fingerprint": {
+          "type": "bytes",
+          "id": 3
+        }
+      }
     }
   }
 }

package/src/device/Device.ts

@@ -587,10 +587,12 @@ export class Device extends EventEmitter {
       try {
         // BLE releases even when keepSession is set, so forward the intent.
         await this.deviceConnector?.release(this.mainId, false, this.keepSession);
-        this.updateDescriptor({ session: null } as DeviceDescriptor);
       } catch (err) {
         Log.error('[Device] release error: ', err);
       } finally {
+        // Core no longer owns a logical transport session after release starts,
+        // even if native cleanup must be retried by the transport.
+        this.updateDescriptor({ session: null } as DeviceDescriptor);
         this.needReloadDevice = true;
       }
     }

package/src/device/DeviceConnector.ts

@@ -133,10 +133,10 @@ export default class DeviceConnector {
             : undefined;
         const detectedProtocol = acquiredProtocol ?? transport.getProtocolType(path);
         if (detectedProtocol !== expectedProtocol) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.RuntimeError,
-            `Device protocol mismatch: expected ${expectedProtocol}, detected ${detectedProtocol}`
-          );
+          throw ERRORS.TypedError(HardwareErrorCode.TransportProtocolMismatch, undefined, {
+            expectedProtocol,
+            detectedProtocol,
+          });
         }
       }
       return res;

package/src/events/logBlockEvent.ts

@@ -8,8 +8,8 @@ export const LogBlockEvent: Set<string> = new Set([
   UI_RESPONSE.RECEIVE_PASSPHRASE,
 ]);
 
-// These resource/file APIs did not exist in 1.1.32. Skip the payload so
-// the log layer does not copy huge Base64 or binary data.
+// Drop sensitive wallet payloads and large resource data before logger caches
+// or log events can retain them, regardless of whether debug output is enabled.
 const LogPayloadBlockMethod: Set<string> = new Set([
   'btcDeriveContextHash',
   'deviceUploadNft',
@@ -17,6 +17,8 @@ const LogPayloadBlockMethod: Set<string> = new Set([
   'uploadPortfolio',
   'fileWrite',
   'fileRead',
+  'zcashGetAddress',
+  'zcashSignPczt',
 ]);
 
 export function getLogBlockLabel(message: unknown): string | undefined {

package/src/index.ts

@@ -21,6 +21,7 @@ export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
 export { projectFeatures as projectDeviceStateFeatures } from './device/DeviceStateProjector';
 export { getMethodSupportedProtocols } from './api/utils';
+export { probeUsbDeviceIdentitiesWithTransport } from './api/SearchDevices';
 export {
   getFirmwareUpdateHostBindingGeneration,
   registerFirmwareUpdateHostBinding,

package/src/inject.ts

@@ -504,4 +504,8 @@ export const createCoreApi = (
     call({ ...params, connectId, deviceId, method: 'neoGetAddress' }),
   neoSignTransaction: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'neoSignTransaction' }),
+  zcashGetAddress: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'zcashGetAddress' }),
+  zcashSignPczt: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'zcashSignPczt' }),
 });

package/src/types/api/export.ts

@@ -227,3 +227,5 @@ export type { BenfenAddress, BenfenGetAddressParams } from './benfenGetAddress';
 export type { BenfenPublicKey, BenfenGetPublicKeyParams } from './benfenGetPublicKey';
 export type { BenfenSignMessageParams } from './benfenSignMessage';
 export type { BenfenSignedTx, BenfenSignTransactionParams } from './benfenSignTransaction';
+export type { ZcashAddress, ZcashGetAddressParams } from './zcashGetAddress';
+export type { ZcashSignedPczt, ZcashSignPcztParams } from './zcashSignPczt';

package/src/types/api/index.ts

@@ -154,6 +154,8 @@ import type { benfenSignTransaction } from './benfenSignTransaction';
 import type { benfenSignMessage } from './benfenSignMessage';
 import type { neoGetAddress } from './neoGetAddress';
 import type { neoSignTransaction } from './neoSignTransaction';
+import type { zcashGetAddress } from './zcashGetAddress';
+import type { zcashSignPczt } from './zcashSignPczt';
 import type { ConnectSettings } from '../settings';
 import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 
@@ -472,4 +474,10 @@ export type CoreApi = {
    */
   neoGetAddress: typeof neoGetAddress;
   neoSignTransaction: typeof neoSignTransaction;
+
+  /**
+   * Zcash
+   */
+  zcashGetAddress: typeof zcashGetAddress;
+  zcashSignPczt: typeof zcashSignPczt;
 };