@onekeyfe/hd-core 1.2.0-alpha.55 → 1.2.0-alpha.57

package/__tests__/device-state-contract.test.ts

@@ -1,4 +1,5 @@
 import { DEVICE } from '../src/events';
+
 import type { DeviceState, DeviceStateEvent } from '../src/types';
 
 describe('DeviceState contract', () => {

package/__tests__/device-state-mapper.test.ts

@@ -1,6 +1,6 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
-
 import { DeviceType, Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+
 import {
   mapApplySettingsToState,
   mapDeviceSettingsToState,

package/__tests__/deviceSettings.test.ts

@@ -1,13 +1,13 @@
 import { EDeviceType } from '@onekeyfe/hd-shared';
 
 import {
+  PROTOCOL_V2_NEVER_TIMEOUT_MS,
   getAutoLockOptions,
   getAutoShutDownOptions,
   getDeviceSettingsCapabilities,
   getLanguageConfig,
   mapLanguageFromProtocolV2,
   mapLanguageToProtocolV2,
-  PROTOCOL_V2_NEVER_TIMEOUT_MS,
 } from '../src/utils/deviceSettings';
 
 describe('Pro 2 device settings options', () => {

package/__tests__/protocol-v2.test.ts

@@ -14,6 +14,9 @@ import DirList from '../src/api/DirList';
 import FileRead from '../src/api/FileRead';
 import FileWrite from '../src/api/FileWrite';
 import UploadPortfolio from '../src/api/UploadPortfolio';
+import DeviceFactoryCertificateRead from '../src/api/protocol-v2/DeviceFactoryCertificateRead';
+import DeviceFactoryCertificateWrite from '../src/api/protocol-v2/DeviceFactoryCertificateWrite';
+import DeviceFactoryChallengeSign from '../src/api/protocol-v2/DeviceFactoryChallengeSign';
 import DeviceFactoryInfoGet from '../src/api/protocol-v2/DeviceFactoryInfoGet';
 import DeviceFactoryInfoSet from '../src/api/protocol-v2/DeviceFactoryInfoSet';
 import DeviceFirmwareUpdate from '../src/api/protocol-v2/DeviceFirmwareUpdate';
@@ -6071,6 +6074,10 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 1800]);
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1800, 1]);
     expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 100]);
+    expect(typedCall.mock.calls.map(call => call[3])).toEqual([
+      { writeWithResponse: true },
+      { writeWithResponse: true },
+    ]);
   });
 
   test('ends device confirmation and starts install progress only after Protocol V2 ACK', async () => {
@@ -7221,26 +7228,39 @@ describe('Protocol V2 current low-level methods', () => {
 
   test('sends DeviceFactoryInfoSet and DeviceFactoryInfoGet', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: {} });
+    const manufactureTime = {
+      year: 2026,
+      month: 8,
+      day: 1,
+      hour: 10,
+      minute: 20,
+      second: 30,
+    };
     const setMethod = new DeviceFactoryInfoSet({
       id: 1,
       payload: {
         method: 'deviceFactoryInfoSet',
+        version: 1,
         serial_number: 'PR2SERIAL',
         burn_in_completed: true,
+        factory_test_completed: true,
+        manufacture_time: manufactureTime,
       },
     });
     setMethod.init();
+    expect(setMethod.getSupportedProtocols()).toEqual(['V2']);
+    expect(setMethod.requireDeviceMode).toEqual([UI_REQUEST.BOOTLOADER]);
     (setMethod as any).device = stubDevice({ commands: { typedCall } });
 
     await setMethod.run();
 
     expect(typedCall).toHaveBeenCalledWith('DeviceFactoryInfoSet', 'Success', {
       info: {
-        version: undefined,
+        version: 1,
         serial_number: 'PR2SERIAL',
         burn_in_completed: true,
-        factory_test_completed: undefined,
-        manufacture_time: undefined,
+        factory_test_completed: true,
+        manufacture_time: manufactureTime,
       },
     });
 
@@ -7250,6 +7270,7 @@ describe('Protocol V2 current low-level methods', () => {
       payload: { method: 'deviceFactoryInfoGet' },
     });
     getMethod.init();
+    expect(getMethod.getSupportedProtocols()).toEqual(['V2']);
     (getMethod as any).device = stubDevice({ commands: { typedCall } });
 
     await getMethod.run();
@@ -7257,6 +7278,111 @@ describe('Protocol V2 current low-level methods', () => {
     expect(typedCall).toHaveBeenLastCalledWith('DeviceFactoryInfoGet', 'DeviceFactoryInfo', {});
   });
 
+  test('validates the write-once DeviceFactoryInfoSet payload before sending', () => {
+    expect(() =>
+      new DeviceFactoryInfoSet({
+        id: 1,
+        payload: {
+          method: 'deviceProvisionFactoryInfo',
+          serial_number: 'PR2SERIAL',
+        },
+      }).init()
+    ).toThrow('Parameter [manufacture_time] is required.');
+
+    expect(() =>
+      new DeviceFactoryInfoSet({
+        id: 1,
+        payload: {
+          method: 'deviceProvisionFactoryInfo',
+          version: 1,
+          serial_number: 'P'.repeat(25),
+          burn_in_completed: true,
+          factory_test_completed: true,
+          manufacture_time: {
+            year: 2026,
+            month: 8,
+            day: 1,
+            hour: 0,
+            minute: 0,
+            second: 0,
+          },
+        },
+      }).init()
+    ).toThrow('must not exceed 24 UTF-8 bytes');
+  });
+
+  test('writes, reads and signs with the Protocol V2 factory certificate API', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: {} });
+    const write = new DeviceFactoryCertificateWrite({
+      id: 1,
+      payload: {
+        method: 'deviceWriteFactoryCertificate',
+        certificate: 'aabbcc',
+      },
+    });
+    write.init();
+    expect(write.getSupportedProtocols()).toEqual(['V2']);
+    expect(write.requireDeviceMode).toEqual([UI_REQUEST.BOOTLOADER]);
+    (write as any).device = stubDevice({ commands: { typedCall } });
+    await write.run();
+
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceCertificateWrite', 'Success', {
+      cert: {
+        cert_and_pubkey: 'aabbcc',
+        private_key: undefined,
+      },
+    });
+
+    const read = new DeviceFactoryCertificateRead({
+      id: 2,
+      payload: { method: 'deviceReadFactoryCertificate' },
+    });
+    read.init();
+    expect(read.getSupportedProtocols()).toEqual(['V2']);
+    (read as any).device = stubDevice({ commands: { typedCall } });
+    await read.run();
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceCertificateRead', 'DeviceCertificate', {});
+
+    const sign = new DeviceFactoryChallengeSign({
+      id: 3,
+      payload: {
+        method: 'deviceSignFactoryChallenge',
+        digest: '22'.repeat(32),
+      },
+    });
+    sign.init();
+    expect(sign.getSupportedProtocols()).toEqual(['V2']);
+    (sign as any).device = stubDevice({ commands: { typedCall } });
+    await sign.run();
+    expect(typedCall).toHaveBeenLastCalledWith(
+      'DeviceCertificateSign',
+      'DeviceCertificateSignature',
+      { data: '22'.repeat(32) }
+    );
+  });
+
+  test('rejects malformed Protocol V2 factory certificate fields', () => {
+    expect(() =>
+      new DeviceFactoryCertificateWrite({
+        id: 1,
+        payload: {
+          method: 'deviceWriteFactoryCertificate',
+          certificate: 'xyz',
+        },
+      }).init()
+    ).toThrow('even-length hexadecimal string');
+
+    expect(() =>
+      new DeviceFactoryChallengeSign({
+        id: 2,
+        payload: {
+          method: 'deviceSignFactoryChallenge',
+          digest: '11',
+        },
+      }).init()
+    ).toThrow('exactly 32 bytes');
+  });
+
   test('marks explicit Protocol V2 unlock as an on-device PIN interaction', () => {
     const method = new DeviceUnlock({
       id: 1,

package/__tests__/protocolV2FileWrite.test.ts

@@ -89,4 +89,43 @@ describe('writeProtocolV2File', () => {
     expect(typedCall.mock.calls[1][2]).toEqual(typedCall.mock.calls[0][2]);
     expect(onProgress).toHaveBeenCalledTimes(1);
   });
+
+  test('按确认分片的时间窗口记录实时传输速率', async () => {
+    const data = new Uint8Array(4097);
+    const typedCall = jest.fn().mockResolvedValue({ message: {} });
+    const onProgress = jest.fn();
+    const dateNowSpy = jest
+      .spyOn(Date, 'now')
+      .mockReturnValueOnce(1_000)
+      .mockReturnValueOnce(2_000)
+      .mockReturnValueOnce(3_000);
+
+    try {
+      await writeProtocolV2File({
+        commands: { typedCall } as any,
+        path: 'vol1:/wallpapers/test.bin',
+        data,
+        onProgress,
+      });
+    } finally {
+      dateNowSpy.mockRestore();
+    }
+
+    expect(onProgress).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        transferredBytes: 4000,
+        rateBytesPerSecond: 4000,
+        elapsedMs: 1000,
+      })
+    );
+    expect(onProgress).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        transferredBytes: 4097,
+        rateBytesPerSecond: 97,
+        elapsedMs: 2000,
+      })
+    );
+  });
 });

package/__tests__/public-pro2-api-boundary.test.ts

@@ -1,8 +1,10 @@
 import * as publicMethods from '../src/api';
+import { FACTORY_API_METHOD_NAMES } from '../src/api/extensionMethodNames';
+import { factoryApiMethodExtension } from '../src/api/methodExtension';
 import { findMethod } from '../src/api/utils';
-import { createCoreApi } from '../src/inject';
+import { createCoreApi, createFactoryApi } from '../src/inject';
 
-import type { CoreApi } from '../src/types/api';
+import type { CoreApi, TestApi } from '../src/types/api';
 
 jest.mock('../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://example.com/',
@@ -49,9 +51,16 @@ describe('public Pro2 API boundary', () => {
 
     expect(api.deviceGetOnboardingStatus).toBeInstanceOf(Function);
     expect(api.deviceUploadNft).toBeInstanceOf(Function);
+    expect(api.deviceReadFactoryInfo).toBeInstanceOf(Function);
+    expect(api.deviceReadFactoryCertificate).toBeInstanceOf(Function);
+    expect(api.deviceSignFactoryChallenge).toBeInstanceOf(Function);
     expect(api.uploadPortfolio).toBeInstanceOf(Function);
     expect(api.testProtocolV2Ping).toBeInstanceOf(Function);
     expect(publicMethods.testProtocolV2Ping).toBeInstanceOf(Function);
+    expect(api).not.toHaveProperty('deviceProvisionFactoryInfo');
+    expect(api).not.toHaveProperty('deviceWriteFactoryCertificate');
+    expect(publicMethods).not.toHaveProperty('deviceProvisionFactoryInfo');
+    expect(publicMethods).not.toHaveProperty('deviceWriteFactoryCertificate');
 
     expect(api).not.toHaveProperty('deviceSessionOpen');
     expect(publicMethods).not.toHaveProperty('deviceSessionOpen');
@@ -65,6 +74,93 @@ describe('public Pro2 API boundary', () => {
     });
   });
 
+  test('routes semantic Pro2 factory APIs without publishing raw message names', async () => {
+    const call = jest.fn().mockResolvedValue({ success: true, payload: {} });
+    const api = {
+      ...createCoreApi(call as CoreApi['call']),
+      ...createFactoryApi(call as CoreApi['call']),
+    } as TestApi;
+    const manufactureTime = {
+      year: 2026,
+      month: 8,
+      day: 1,
+      hour: 10,
+      minute: 20,
+      second: 30,
+    };
+
+    await api.deviceProvisionFactoryInfo('pro2', {
+      version: 1,
+      serial_number: 'P2A00000001',
+      burn_in_completed: true,
+      factory_test_completed: true,
+      manufacture_time: manufactureTime,
+      connectProtocol: 'V2',
+    });
+    await api.deviceReadFactoryInfo('pro2', { connectProtocol: 'V2' });
+    await api.deviceWriteFactoryCertificate('pro2', {
+      certificate: 'aabb',
+      connectProtocol: 'V2',
+    });
+    await api.deviceReadFactoryCertificate('pro2', { connectProtocol: 'V2' });
+    await api.deviceSignFactoryChallenge('pro2', {
+      digest: '22'.repeat(32),
+      connectProtocol: 'V2',
+    });
+
+    expect(call).toHaveBeenNthCalledWith(1, {
+      method: 'deviceProvisionFactoryInfo',
+      connectId: 'pro2',
+      version: 1,
+      serial_number: 'P2A00000001',
+      burn_in_completed: true,
+      factory_test_completed: true,
+      manufacture_time: manufactureTime,
+      connectProtocol: 'V2',
+    });
+    expect(call).toHaveBeenNthCalledWith(2, {
+      method: 'deviceReadFactoryInfo',
+      connectId: 'pro2',
+      connectProtocol: 'V2',
+    });
+    expect(call).toHaveBeenNthCalledWith(3, {
+      method: 'deviceWriteFactoryCertificate',
+      connectId: 'pro2',
+      certificate: 'aabb',
+      connectProtocol: 'V2',
+    });
+    expect(call).toHaveBeenNthCalledWith(4, {
+      method: 'deviceReadFactoryCertificate',
+      connectId: 'pro2',
+      connectProtocol: 'V2',
+    });
+    expect(call).toHaveBeenNthCalledWith(5, {
+      method: 'deviceSignFactoryChallenge',
+      connectId: 'pro2',
+      digest: '22'.repeat(32),
+      connectProtocol: 'V2',
+    });
+  });
+
+  test('requires explicit destructive authorization for Pro2 factory writes', () => {
+    expect(Object.keys(factoryApiMethodExtension.methods)).toEqual(FACTORY_API_METHOD_NAMES);
+    const message = {
+      id: 1,
+      payload: { method: 'deviceProvisionFactoryInfo' },
+    } as any;
+
+    expect(() => findMethod(message)).toThrow('Method deviceProvisionFactoryInfo is not set');
+    expect(() => findMethod(message, { extensions: [factoryApiMethodExtension] })).toThrow(
+      'requires allowDestructiveOperations'
+    );
+    expect(
+      findMethod(message, {
+        extensions: [factoryApiMethodExtension],
+        allowDestructiveOperations: true,
+      }).name
+    ).toBe('deviceProvisionFactoryInfo');
+  });
+
   test('routes the diagnostic Protocol V2 Ping without publishing the raw ping command', async () => {
     const call = jest.fn().mockResolvedValue({ success: true, payload: { message: 'benchmark' } });
     const api = createCoreApi(call as CoreApi['call']) as CoreApi;

package/__tests__/public-test-api-boundary.test.ts

@@ -0,0 +1,167 @@
+import * as publicMethods from '../src/api';
+import * as methods from '../src/api/testMethods';
+import DeviceWipe from '../src/api/device/DeviceWipe';
+import { TEST_API_METHOD_NAMES } from '../src/api/extensionMethodNames';
+import { testApiMethodExtension } from '../src/api/methodExtension';
+import { findMethod } from '../src/api/utils';
+import { createCoreApi, createTestApi } from '../src/inject';
+
+import type { BaseMethod } from '../src/api/BaseMethod';
+import type { CoreApi } from '../src/types/api';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+const testApiNames = [
+  'btcGetOwnershipId',
+  'btcGetOwnershipProof',
+  'btcAuthorizeCoinJoin',
+  'cryptoBatchGetPublickeys',
+  'cryptoCipherKeyValue',
+  'cryptoCosiCommit',
+  'cryptoCosiSign',
+  'cryptoGetECDHSessionKey',
+  'cryptoSignIdentity',
+  'evmGetAddressTrezor',
+  'evmGetPublicKeyTrezor',
+  'evmSignMessageTrezor',
+  'evmSignTransactionTrezor',
+  'evmSignTypedDataTrezor',
+  'evmVerifyMessageTrezor',
+  'nemDecryptMessage',
+  'deviceSpiFlashWrite',
+  'deviceSpiFlashRead',
+  'deviceInfoSettings',
+  'deviceGetInfo',
+  'deviceReadSEPublicCert',
+  'deviceWriteSEPrivateKey',
+  'deviceWriteSEPublicCert',
+  'deviceSESignMessage',
+  'devicePing',
+  'deviceGetEntropy',
+  'deviceGetFirmwareHash',
+  'deviceUnlockPath',
+  'deviceSdProtect',
+  'deviceChangeWipeCode',
+  'deviceEndSession',
+  'deviceLoad',
+  'deviceDoPreauthorized',
+  'deviceCancelAuthorization',
+  'emmcDirList',
+  'emmcDirMake',
+  'emmcDirRemove',
+  'emmcFileDelete',
+  'emmcFileRead',
+  'emmcFileWrite',
+  'emmcFixPermission',
+  'emmcPathInfo',
+  'debugLinkDecision',
+  'debugLinkEraseSdCard',
+  'debugLinkFlashErase',
+  'debugLinkGetState',
+  'debugLinkMemoryRead',
+  'debugLinkMemoryWrite',
+  'debugLinkRecordScreen',
+  'debugLinkReseedRandom',
+  'debugLinkStop',
+  'debugLinkWatchLayout',
+  'firmwareErase',
+  'firmwareEraseEx',
+  'firmwareUpdateEmmcTest',
+  'firmwareUploadTest',
+  'reboot',
+  'selfTest',
+  'tezosGetAddress',
+  'tezosGetPublicKey',
+  'tezosSignTx',
+  'moneroGetAddress',
+  'moneroGetWatchKey',
+  'eosGetPublicKey',
+  'eosSignTx',
+  'binanceGetAddress',
+  'binanceGetPublicKey',
+  'binanceSignTx',
+  'webAuthnAddResidentCredential',
+  'webAuthnListResidentCredentials',
+  'webAuthnRemoveResidentCredential',
+  'getPublicKeyMultiple',
+  'listResDir',
+  'nftWriteData',
+  'nftWriteInfo',
+  'readSEPublicKey',
+  'resourceUpdate',
+  'bixinBackupDevice',
+  'bixinLoadDevice',
+  'bixinMessageSE',
+  'bixinVerifyDeviceRequest',
+] as const;
+
+describe('public test API boundary', () => {
+  test('keeps every test API behind the explicit extension', () => {
+    expect(testApiNames).toEqual(TEST_API_METHOD_NAMES);
+    expect(Object.keys(testApiMethodExtension.methods).sort()).toEqual(
+      [...TEST_API_METHOD_NAMES].sort()
+    );
+    const call = jest.fn() as CoreApi['call'];
+    const publicApi = createCoreApi(call) as Record<string, unknown>;
+    const api = createTestApi(call) as Record<string, unknown>;
+
+    testApiNames.forEach(name => {
+      expect(typeof methods[name]).toBe('function');
+      expect(typeof api[name]).toBe('function');
+      expect(publicMethods).not.toHaveProperty(name);
+      expect(publicApi).not.toHaveProperty(name);
+    });
+  });
+
+  test('keeps imported test methods on Protocol V1', () => {
+    testApiNames.forEach(name => {
+      const Method = methods[name] as new (message: {
+        id?: number;
+        payload: unknown;
+      }) => BaseMethod;
+      const instance = new Method({ id: 1, payload: { method: name } });
+
+      expect(instance.getSupportedProtocols()).toEqual(['V1']);
+    });
+  });
+
+  test('preserves the current shared wipe behavior for Protocol V1 and V2', () => {
+    const wipe = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
+
+    expect(wipe.getSupportedProtocols()).toEqual(['V1', 'V2']);
+  });
+
+  test('routes representative calls through the current public call boundary', async () => {
+    const call = jest.fn().mockResolvedValue({ success: true });
+    const api = createTestApi(call as CoreApi['call']);
+
+    await api.devicePing('usb:1', { message: 'ping' });
+    await api.evmGetAddressTrezor('usb:1', 'device:1', {
+      path: "m/44'/60'/0'/0/0",
+      showOnOneKey: false,
+    });
+
+    expect(call).toHaveBeenNthCalledWith(1, {
+      connectId: 'usb:1',
+      message: 'ping',
+      method: 'devicePing',
+    });
+    expect(call).toHaveBeenNthCalledWith(2, {
+      connectId: 'usb:1',
+      deviceId: 'device:1',
+      method: 'evmGetAddressTrezor',
+      path: "m/44'/60'/0'/0/0",
+      showOnOneKey: false,
+    });
+  });
+
+  test('resolves test methods only for the configured Core instance', () => {
+    const message = { id: 1, payload: { method: 'devicePing' } } as any;
+
+    expect(() => findMethod(message)).toThrow('Method devicePing is not set');
+    expect(findMethod(message, { extensions: [testApiMethodExtension] }).name).toBe('devicePing');
+  });
+});

package/dist/api/BixinBackupDevice.d.ts

@@ -0,0 +1,7 @@
+import { BaseMethod } from './BaseMethod';
+import type { BixinBackupDevice } from '@onekeyfe/hd-transport';
+export default class DeviceBackup extends BaseMethod<BixinBackupDevice> {
+    init(): void;
+    run(): Promise<import("@onekeyfe/hd-transport").Success>;
+}
+//# sourceMappingURL=BixinBackupDevice.d.ts.map

package/dist/api/BixinBackupDevice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BixinBackupDevice.d.ts","sourceRoot":"","sources":["../../src/api/BixinBackupDevice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,UAAU,CAAC,iBAAiB,CAAC;IACrE,IAAI;IAIE,GAAG;CAKV"}

package/dist/api/BixinLoadDevice.d.ts

@@ -0,0 +1,7 @@
+import { BaseMethod } from './BaseMethod';
+import type { BixinLoadDevice as HardwareBixinLoadDevice } from '@onekeyfe/hd-transport';
+export default class BixinLoadDevice extends BaseMethod<HardwareBixinLoadDevice> {
+    init(): void;
+    run(): Promise<import("@onekeyfe/hd-transport").Success>;
+}
+//# sourceMappingURL=BixinLoadDevice.d.ts.map

package/dist/api/BixinLoadDevice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BixinLoadDevice.d.ts","sourceRoot":"","sources":["../../src/api/BixinLoadDevice.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,eAAe,IAAI,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEzF,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,UAAU,CAAC,uBAAuB,CAAC;IAC9E,IAAI;IAWE,GAAG;CAKV"}

package/dist/api/BixinMessageSE.d.ts

@@ -0,0 +1,8 @@
+import { BaseMethod } from './BaseMethod';
+import type { BixinMessageSE as HardwareBixinMessageSE } from '@onekeyfe/hd-transport';
+export default class BixinMessageSE extends BaseMethod<HardwareBixinMessageSE> {
+    hasBundle: boolean;
+    init(): void;
+    run(): Promise<import("../device/DeviceCommands").TypedResponseMessage<"BixinOutMessageSE">>;
+}
+//# sourceMappingURL=BixinMessageSE.d.ts.map

package/dist/api/BixinMessageSE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BixinMessageSE.d.ts","sourceRoot":"","sources":["../../src/api/BixinMessageSE.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,cAAc,IAAI,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEvF,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,UAAU,CAAC,sBAAsB,CAAC;IAC5E,SAAS,UAAS;IAElB,IAAI;IASE,GAAG;CAKV"}

package/dist/api/BixinVerifyDeviceRequest.d.ts

@@ -0,0 +1,8 @@
+import { BaseMethod } from './BaseMethod';
+import type { BixinVerifyDeviceRequest as HardwareBixinVerifyDeviceRequest } from '@onekeyfe/hd-transport';
+export default class BixinVerifyDeviceRequest extends BaseMethod<HardwareBixinVerifyDeviceRequest> {
+    hasBundle: boolean;
+    init(): void;
+    run(): Promise<import("../device/DeviceCommands").TypedResponseMessage<"BixinVerifyDeviceAck">>;
+}
+//# sourceMappingURL=BixinVerifyDeviceRequest.d.ts.map

package/dist/api/BixinVerifyDeviceRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BixinVerifyDeviceRequest.d.ts","sourceRoot":"","sources":["../../src/api/BixinVerifyDeviceRequest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,wBAAwB,IAAI,gCAAgC,EAAE,MAAM,wBAAwB,CAAC;AAE3G,MAAM,CAAC,OAAO,OAAO,wBAAyB,SAAQ,UAAU,CAAC,gCAAgC,CAAC;IAChG,SAAS,UAAS;IAElB,IAAI;IASE,GAAG;CAKV"}

package/dist/api/FirmwareUpdateV4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAkB/E,OAAO,KAAK,EAAE,sBAAsB,EAA0B,MAAM,6BAA6B,CAAC;AAmUlG,eAAO,MAAM,oCAAoC,WACvC,WAAW,GAAG,UAAU,eACnB,MAAM,GAAG,SAAS,YAKhC,CAAC;AAEF,eAAO,MAAM,iCAAiC,0BACrB,MAAM,uBACR,MAAM,SAa5B,CAAC;AAUF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IAC5F,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,qBAAqB;IAIrB,IAAI;IA6DJ,OAAO,CAAC,8BAA8B;IAiBhC,GAAG;;;;;YAKK,aAAa;YAwGb,2BAA2B;IAWzC,OAAO,CAAC,yBAAyB;IAKjC,OAAO,CAAC,kCAAkC;IAO1C,OAAO,CAAC,8BAA8B;YAMxB,iCAAiC;YAOjC,iCAAiC;YAOjC,iCAAiC;IAM/C,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,4BAA4B;IASpC,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,yBAAyB;IAiBjC,OAAO,CAAC,wBAAwB;YAkBlB,iCAAiC;YAmCjC,+BAA+B;IAqD7C,OAAO,CAAC,qCAAqC;YAuB/B,8BAA8B;IAyB5C,OAAO,CAAC,wCAAwC;YAgBlC,gCAAgC;YAqChC,0BAA0B;YAe1B,6BAA6B;IAkC3C,OAAO,CAAC,0BAA0B;IAUlC,OAAO,CAAC,yBAAyB;IAU3B,6BAA6B;YA4BrB,+BAA+B;IAkD7C,OAAO,CAAC,6BAA6B;YAkCvB,uBAAuB;IA4GrC,OAAO,CAAC,mCAAmC;YAI7B,0BAA0B;IAaxC,OAAO,CAAC,4BAA4B;IAgEpC,OAAO,CAAC,6BAA6B;YAcvB,uCAAuC;YAoJvC,gCAAgC;YAchC,yBAAyB;YAQzB,8BAA8B;IAQ5C,OAAO,CAAC,0BAA0B;YAiBpB,qCAAqC;YAgDrC,yBAAyB;YA8DzB,8BAA8B;IAU5C,OAAO,CAAC,kCAAkC;YAI5B,6BAA6B;YAwB7B,wBAAwB;IAoDtC,OAAO,CAAC,sCAAsC;YAchC,cAAc;YA+Bd,6BAA6B;YAW7B,0BAA0B;YAS1B,6BAA6B;YAmB7B,gBAAgB;IAiB9B,OAAO,CAAC,qBAAqB;CAM9B"}
+{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAkB/E,OAAO,KAAK,EAAE,sBAAsB,EAA0B,MAAM,6BAA6B,CAAC;AAmUlG,eAAO,MAAM,oCAAoC,WACvC,WAAW,GAAG,UAAU,eACnB,MAAM,GAAG,SAAS,YAKhC,CAAC;AAEF,eAAO,MAAM,iCAAiC,0BACrB,MAAM,uBACR,MAAM,SAa5B,CAAC;AAUF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IAC5F,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,qBAAqB;IAIrB,IAAI;IA6DJ,OAAO,CAAC,8BAA8B;IAiBhC,GAAG;;;;;YAKK,aAAa;YAwGb,2BAA2B;IAWzC,OAAO,CAAC,yBAAyB;IAKjC,OAAO,CAAC,kCAAkC;IAO1C,OAAO,CAAC,8BAA8B;YAMxB,iCAAiC;YAOjC,iCAAiC;YAOjC,iCAAiC;IAM/C,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,4BAA4B;IASpC,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,yBAAyB;IAiBjC,OAAO,CAAC,wBAAwB;YAkBlB,iCAAiC;YAmCjC,+BAA+B;IAqD7C,OAAO,CAAC,qCAAqC;YAuB/B,8BAA8B;IAyB5C,OAAO,CAAC,wCAAwC;YAgBlC,gCAAgC;YAqChC,0BAA0B;YAe1B,6BAA6B;IAkC3C,OAAO,CAAC,0BAA0B;IAUlC,OAAO,CAAC,yBAAyB;IAU3B,6BAA6B;YA4BrB,+BAA+B;IAkD7C,OAAO,CAAC,6BAA6B;YAkCvB,uBAAuB;IA4GrC,OAAO,CAAC,mCAAmC;YAI7B,0BAA0B;IAaxC,OAAO,CAAC,4BAA4B;IAgEpC,OAAO,CAAC,6BAA6B;YAcvB,uCAAuC;YAoJvC,gCAAgC;YAchC,yBAAyB;YAQzB,8BAA8B;IAQ5C,OAAO,CAAC,0BAA0B;YAiBpB,qCAAqC;YAgDrC,yBAAyB;YA8DzB,8BAA8B;IAU5C,OAAO,CAAC,kCAAkC;YAI5B,6BAA6B;YAwB7B,wBAAwB;IAoDtC,OAAO,CAAC,sCAAsC;YAchC,cAAc;YAoCd,6BAA6B;YAW7B,0BAA0B;YAS1B,6BAA6B;YAmB7B,gBAAgB;IAiB9B,OAAO,CAAC,qBAAqB;CAM9B"}

package/dist/api/WebAuthnAddResidentCredential.d.ts

@@ -0,0 +1,8 @@
+import { BaseMethod } from './BaseMethod';
+import type { WebAuthnAddResidentCredential as HardwareWebAuthnAddResidentCredential } from '@onekeyfe/hd-transport';
+export default class WebAuthnAddResidentCredential extends BaseMethod<HardwareWebAuthnAddResidentCredential> {
+    hasBundle: boolean;
+    init(): void;
+    run(): Promise<import("../device/DeviceCommands").TypedResponseMessage<"Success">>;
+}
+//# sourceMappingURL=WebAuthnAddResidentCredential.d.ts.map

package/dist/api/WebAuthnAddResidentCredential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebAuthnAddResidentCredential.d.ts","sourceRoot":"","sources":["../../src/api/WebAuthnAddResidentCredential.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,6BAA6B,IAAI,qCAAqC,EAAE,MAAM,wBAAwB,CAAC;AAErH,MAAM,CAAC,OAAO,OAAO,6BAA8B,SAAQ,UAAU,CAAC,qCAAqC,CAAC;IAC1G,SAAS,UAAS;IAElB,IAAI;IASE,GAAG;CAKV"}

package/dist/api/WebAuthnListResidentCredentials.d.ts

@@ -0,0 +1,8 @@
+import { BaseMethod } from './BaseMethod';
+import type { WebAuthnListResidentCredentials as HardwareWebAuthnListResidentCredentials } from '@onekeyfe/hd-transport';
+export default class WebAuthnListResidentCredentials extends BaseMethod<HardwareWebAuthnListResidentCredentials> {
+    hasBundle: boolean;
+    init(): void;
+    run(): Promise<import("../device/DeviceCommands").TypedResponseMessage<"WebAuthnCredentials">>;
+}
+//# sourceMappingURL=WebAuthnListResidentCredentials.d.ts.map

package/dist/api/WebAuthnListResidentCredentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebAuthnListResidentCredentials.d.ts","sourceRoot":"","sources":["../../src/api/WebAuthnListResidentCredentials.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,+BAA+B,IAAI,uCAAuC,EAAE,MAAM,wBAAwB,CAAC;AAEzH,MAAM,CAAC,OAAO,OAAO,+BAAgC,SAAQ,UAAU,CAAC,uCAAuC,CAAC;IAC9G,SAAS,UAAS;IAElB,IAAI;IAOE,GAAG;CASV"}

package/dist/api/WebAuthnRemoveResidentCredential.d.ts

@@ -0,0 +1,8 @@
+import { BaseMethod } from './BaseMethod';
+import type { WebAuthnRemoveResidentCredential as HardwareWebAuthnRemoveResidentCredential } from '@onekeyfe/hd-transport';
+export default class WebAuthnRemoveResidentCredential extends BaseMethod<HardwareWebAuthnRemoveResidentCredential> {
+    hasBundle: boolean;
+    init(): void;
+    run(): Promise<import("../device/DeviceCommands").TypedResponseMessage<"Success">>;
+}
+//# sourceMappingURL=WebAuthnRemoveResidentCredential.d.ts.map

package/dist/api/WebAuthnRemoveResidentCredential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebAuthnRemoveResidentCredential.d.ts","sourceRoot":"","sources":["../../src/api/WebAuthnRemoveResidentCredential.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,gCAAgC,IAAI,wCAAwC,EAAE,MAAM,wBAAwB,CAAC;AAE3H,MAAM,CAAC,OAAO,OAAO,gCAAiC,SAAQ,UAAU,CAAC,wCAAwC,CAAC;IAChH,SAAS,UAAS;IAElB,IAAI;IASE,GAAG;CAKV"}

package/dist/api/binance/BinanceGetAddress.d.ts

@@ -0,0 +1,8 @@
+import { BaseMethod } from '../BaseMethod';
+import type { BinanceGetAddress as HardwareBinanceGetAddress } from '@onekeyfe/hd-transport';
+export default class BinanceGetAddress extends BaseMethod<HardwareBinanceGetAddress> {
+    hasBundle: boolean;
+    init(): void;
+    run(): Promise<import("../../device/DeviceCommands").TypedResponseMessage<"BinanceAddress">>;
+}
+//# sourceMappingURL=BinanceGetAddress.d.ts.map

package/dist/api/binance/BinanceGetAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinanceGetAddress.d.ts","sourceRoot":"","sources":["../../../src/api/binance/BinanceGetAddress.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,KAAK,EAAE,iBAAiB,IAAI,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAE7F,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,UAAU,CAAC,yBAAyB,CAAC;IAClF,SAAS,UAAS;IAElB,IAAI;IAWE,GAAG;CAKV"}