@onekeyfe/hd-core 0.0.1

package/src/types/api/btcSignTransaction.ts

@@ -0,0 +1,98 @@
+import {
+  TxInput as OrigTxInput,
+  PrevInput,
+  Success,
+  TxOutputBinType,
+  TxOutputType,
+  TxInputType,
+} from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type SignedTransaction = {
+  signatures: string[];
+  serializedTx: string;
+  txid?: string;
+};
+
+export type TransactionOptions = {
+  version?: number;
+  lock_time?: number;
+  expiry?: number;
+  overwintered?: boolean;
+  version_group_id?: number;
+  timestamp?: number;
+  branch_id?: number;
+};
+
+export type RefTransaction =
+  | {
+      hash: string;
+      version: number;
+      inputs: PrevInput[];
+      bin_outputs: TxOutputBinType[];
+      outputs?: typeof undefined;
+      lock_time: number;
+      extra_data?: string;
+      expiry?: number;
+      overwintered?: boolean;
+      version_group_id?: number;
+      timestamp?: number;
+      branch_id?: number;
+    }
+  | {
+      hash: string;
+      version: number;
+      inputs: OrigTxInput[];
+      bin_outputs?: typeof undefined;
+      outputs: TxOutputType[];
+      lock_time: number;
+      extra_data?: string;
+      expiry?: number;
+      overwintered?: boolean;
+      version_group_id?: number;
+      timestamp?: number;
+      branch_id?: number;
+    };
+
+export type AccountAddress = {
+  address: string;
+  path: string;
+  transfers?: number;
+  balance?: string;
+  sent?: string;
+  received?: string;
+};
+
+export type AccountAddresses = {
+  change: AccountAddress[];
+  used: AccountAddress[];
+  unused: AccountAddress[];
+};
+
+export type BTCSignTransactionParams = {
+  coin: string;
+  inputs: TxInputType[];
+  outputs: TxOutputType[];
+  refTxs: RefTransaction[];
+  account?: {
+    // Partial account (addresses)
+    addresses: AccountAddresses;
+  };
+  locktime?: number;
+  version?: number;
+  // Only available for Decred and Zcash
+  expiry?: number;
+  // Only available for Zcash
+  overwintered?: boolean;
+  // Only available for Zcash, set overwintered to nVersionGroupId
+  versionGroupId?: number;
+  // Only available for Zcash when overwintered is true
+  branchId?: number;
+  // Only available for Capricoin
+  timestamp?: number;
+};
+
+export declare function btcSignTransaction(
+  connectId: string,
+  params: CommonParams & BTCSignTransactionParams
+): Response<Success>;

package/src/types/api/btcVerifyMessage.ts

@@ -0,0 +1,14 @@
+import { Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type BTCVerifyMessageParams = {
+  address: string;
+  messageHex: string;
+  signature: string;
+  coin: string;
+};
+
+export declare function btcVerifyMessage(
+  connectId: string,
+  params: CommonParams & BTCVerifyMessageParams
+): Response<Success>;

package/src/types/api/checkBLEFirmwareRelease.ts

@@ -0,0 +1,6 @@
+import type { Response } from '../params';
+import type { IDeviceFirmwareStatus } from '../device';
+
+export declare function checkBLEFirmwareRelease(
+  connectId?: string
+): Response<IDeviceFirmwareStatus>;

package/src/types/api/checkFirmwareRelease.ts

@@ -0,0 +1,4 @@
+import type { Response } from '../params';
+import type { IDeviceFirmwareStatus } from '../device';
+
+export declare function checkFirmwareRelease(connectId?: string): Response<IDeviceFirmwareStatus>;

package/src/types/api/checkTransportRelease.ts

@@ -0,0 +1,4 @@
+import type { Response } from '../params';
+import { TransportReleaseStatus } from '../firmware';
+
+export declare function checkTransportRelease(): Response<TransportReleaseStatus>;

package/src/types/api/deviceBackup.ts

@@ -0,0 +1,4 @@
+import { Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { Response } from '../params';
+
+export declare function deviceBackup(connectId: string): Response<Success>;

package/src/types/api/deviceChangePin.ts

@@ -0,0 +1,11 @@
+import { Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type DeviceChangePinParams = {
+  remove?: boolean;
+};
+
+export declare function deviceChangePin(
+  connectId: string,
+  params: CommonParams & DeviceChangePinParams
+): Response<Success>;

package/src/types/api/deviceFlags.ts

@@ -0,0 +1,11 @@
+import { Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type DeviceFlagsParams = {
+  flags?: number;
+};
+
+export declare function deviceFlags(
+  connectId: string,
+  params: CommonParams & DeviceFlagsParams
+): Response<Success>;

package/src/types/api/deviceRebootToBootloader.ts

@@ -0,0 +1,4 @@
+import { Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { Response } from '../params';
+
+export declare function deviceRebootToBootloader(connectId: string): Response<Success>;

package/src/types/api/deviceRecovery.ts

@@ -0,0 +1,19 @@
+import { RecoveryDeviceType, Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type DeviceRecoveryParams = {
+  wordCount?: number;
+  passphraseProtection?: boolean;
+  pinProtection?: boolean;
+  language?: string;
+  label?: string;
+  enforceWordlist?: boolean;
+  type?: RecoveryDeviceType;
+  u2fCounter?: number;
+  dryRun?: boolean;
+};
+
+export declare function deviceRecovery(
+  connectId: string,
+  params: CommonParams & DeviceRecoveryParams
+): Response<Success>;

package/src/types/api/deviceReset.ts

@@ -0,0 +1,20 @@
+import { Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type DeviceResetParams = {
+  displayRandom?: boolean;
+  strength?: number;
+  passphraseProtection?: boolean;
+  pinProtection?: boolean;
+  language?: string;
+  label?: string;
+  u2fCounter?: number;
+  skipBackup?: boolean;
+  noBackup?: boolean;
+  backupType?: string | number;
+};
+
+export declare function deviceReset(
+  connectId: string,
+  params: CommonParams & DeviceResetParams
+): Response<Success>;

package/src/types/api/deviceSettings.ts

@@ -0,0 +1,17 @@
+import { SafetyCheckLevel, Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { Response } from '../params';
+
+export type DeviceSettingsParams = {
+  language?: string;
+  label?: string;
+  usePassphrase?: boolean;
+  homescreen?: string;
+  passphraseSource?: number;
+  autoLockDelayMs?: number;
+  displayRotation?: number;
+  passphraseAlwaysOnDevice?: boolean;
+  safetyChecks?: SafetyCheckLevel;
+  experimentalFeatures?: boolean;
+};
+
+export declare function deviceSettings(connectId: string): Response<Success>;

package/src/types/api/deviceUpdateReboot.ts

@@ -0,0 +1,4 @@
+import { Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { Response } from '../params';
+
+export declare function deviceUpdateReboot(connectId: string): Response<Success>;

package/src/types/api/deviceWipe.ts

@@ -0,0 +1,4 @@
+import { Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { Response } from '../params';
+
+export declare function deviceWipe(connectId: string): Response<Success>;

package/src/types/api/event.ts

@@ -0,0 +1,8 @@
+export declare const on: <T extends string, P extends (...args: any[]) => any>(
+  type: T,
+  fn: P
+) => void;
+
+export declare const off: (type: any, fn: any) => void;
+
+export declare const removeAllListeners: (type: any) => void;

package/src/types/api/evmGetAddress.ts

@@ -0,0 +1,17 @@
+import { EthereumAddress } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type EVMGetAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function evmGetAddress(
+  connectId: string,
+  params: CommonParams & EVMGetAddressParams
+): Response<EthereumAddress>;
+
+export declare function evmGetAddress(
+  connectId: string,
+  params: CommonParams & { bundle?: EVMGetAddressParams[] }
+): Response<Array<EthereumAddress>>;

package/src/types/api/evmGetPublicKey.ts

@@ -0,0 +1,17 @@
+import { EthereumPublicKey } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type EVMGetPublicKeyParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function evmGetPublicKey(
+  connectId: string,
+  params: CommonParams & EVMGetPublicKeyParams
+): Response<EthereumPublicKey>;
+
+export declare function evmGetPublicKey(
+  connectId: string,
+  params: CommonParams & { bundle?: EVMGetPublicKeyParams[] }
+): Response<Array<EthereumPublicKey>>;

package/src/types/api/evmSignMessage.ts

@@ -0,0 +1,12 @@
+import { EthereumMessageSignature } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type EVMSignMessageParams = {
+  path: string | number[];
+  messageHex: string;
+};
+
+export declare function evmSignMessage(
+  connectId: string,
+  params: CommonParams & EVMSignMessageParams
+): Response<EthereumMessageSignature>;

package/src/types/api/evmSignMessageEIP712.ts

@@ -0,0 +1,13 @@
+import { EthereumMessageSignature } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type EVMSignMessageEIP712Params = {
+  path: string | number[];
+  domainHash: string;
+  messageHash: string;
+};
+
+export declare function evmSignMessageEIP712(
+  connectId: string,
+  params: CommonParams & EVMSignMessageEIP712Params
+): Response<EthereumMessageSignature>;

package/src/types/api/evmSignTransaction.ts

@@ -0,0 +1,43 @@
+import { EthereumMessageSignature } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export interface EVMTransaction {
+  to: string;
+  value: string;
+  gasPrice: string;
+  gasLimit: string;
+  maxFeePerGas?: typeof undefined;
+  maxPriorityFeePerGas?: typeof undefined;
+  nonce: string;
+  data?: string;
+  chainId: number;
+  txType?: number;
+}
+
+export type EVMAccessList = {
+  address: string;
+  storageKeys: string[];
+};
+
+export type EVMTransactionEIP1559 = {
+  to: string;
+  value: string;
+  gasLimit: string;
+  gasPrice?: typeof undefined;
+  nonce: string;
+  data?: string;
+  chainId: number;
+  maxFeePerGas: string;
+  maxPriorityFeePerGas: string;
+  accessList?: EVMAccessList[];
+};
+
+export type EVMSignTransactionParams = {
+  path: string | number[];
+  transaction: EVMTransaction | EVMTransactionEIP1559;
+};
+
+export declare function evmSignTransaction(
+  connectId: string,
+  params: CommonParams & EVMSignTransactionParams
+): Response<EthereumMessageSignature>;

package/src/types/api/evmSignTypedData.ts

@@ -0,0 +1,40 @@
+import { EthereumMessageSignature } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type EthereumSignTypedDataTypeProperty = {
+  name: string;
+  type: string;
+};
+
+// EthereumSignTypedDataTypes
+export type EthereumSignTypedDataTypes = {
+  EIP712Domain: EthereumSignTypedDataTypeProperty[];
+  [additionalProperties: string]: EthereumSignTypedDataTypeProperty[];
+};
+
+// EthereumSignTypedDataMessage
+export type EthereumSignTypedDataMessage<T extends EthereumSignTypedDataTypes> = {
+  types: T;
+  primaryType: keyof T;
+  domain: {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: string;
+    salt?: ArrayBuffer;
+  };
+  message: { [fieldName: string]: any };
+};
+
+export type EVMSignTypedDataParams = {
+  path: string | number[];
+  metamaskV4Compat: boolean;
+  data: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
+  domainHash?: string;
+  messageHash?: string;
+};
+
+export declare function evmSignTypedData(
+  connectId: string,
+  params: CommonParams & EVMSignTypedDataParams
+): Response<EthereumMessageSignature>;

package/src/types/api/evmVerifyMessage.ts

@@ -0,0 +1,13 @@
+import { Success } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type EVMVerifyMessageParams = {
+  address: string;
+  messageHex: string;
+  signature: string;
+};
+
+export declare function evmVerifyMessage(
+  connectId: string,
+  params: CommonParams & EVMVerifyMessageParams
+): Response<Success>;

package/src/types/api/getFeatures.ts

@@ -0,0 +1,4 @@
+import type { Response } from '../params';
+import type { Features } from '../device';
+
+export declare function getFeatures(connectId?: string): Response<Features>;

package/src/types/api/index.ts

@@ -0,0 +1,80 @@
+import { on, off, removeAllListeners } from './event';
+import { searchDevices } from './searchDevices';
+import { getFeatures } from './getFeatures';
+import { checkFirmwareRelease } from './checkFirmwareRelease';
+import { init } from './init';
+import { checkBLEFirmwareRelease } from './checkBLEFirmwareRelease';
+import { checkTransportRelease } from './checkTransportRelease';
+import { evmGetAddress } from './evmGetAddress';
+import { evmGetPublicKey } from './evmGetPublicKey';
+import { evmSignMessage } from './evmSignMessage';
+import { evmSignMessageEIP712 } from './evmSignMessageEIP712';
+import { evmSignTransaction } from './evmSignTransaction';
+import { evmSignTypedData } from './evmSignTypedData';
+import { evmVerifyMessage } from './evmVerifyMessage';
+import { btcGetAddress } from './btcGetAddress';
+import { btcGetPublicKey } from './btcGetPublicKey';
+import { btcSignMessage } from './btcSignMessage';
+import { btcSignTransaction } from './btcSignTransaction';
+import { btcVerifyMessage } from './btcVerifyMessage';
+import { uiResponse } from './uiResponse';
+import { deviceReset } from './deviceReset';
+import { deviceRecovery } from './deviceRecovery';
+import { deviceWipe } from './deviceWipe';
+import { deviceRebootToBootloader } from './deviceRebootToBootloader';
+import { deviceBackup } from './deviceBackup';
+import { deviceChangePin } from './deviceChangePin';
+import { deviceSettings } from './deviceSettings';
+import { deviceFlags } from './deviceFlags';
+import { deviceUpdateReboot } from './deviceUpdateReboot';
+
+export type CoreApi = {
+  /**
+   * Inject function
+   */
+  init: typeof init;
+  on: typeof on;
+  off: typeof off;
+  removeAllListeners: typeof removeAllListeners;
+  dispose: () => void;
+  call: (params: any) => Promise<any>;
+  uiResponse: typeof uiResponse;
+  cancel: (params?: string) => void;
+
+  /**
+   * Core function
+   */
+  searchDevices: typeof searchDevices;
+
+  getFeatures: typeof getFeatures;
+
+  checkFirmwareRelease: typeof checkFirmwareRelease;
+
+  checkBLEFirmwareRelease: typeof checkBLEFirmwareRelease;
+
+  checkTransportRelease: typeof checkTransportRelease;
+
+  deviceBackup: typeof deviceBackup;
+  deviceChangePin: typeof deviceChangePin;
+  deviceFlags: typeof deviceFlags;
+  deviceRebootToBootloader: typeof deviceRebootToBootloader;
+  deviceRecovery: typeof deviceRecovery;
+  deviceReset: typeof deviceReset;
+  deviceSettings: typeof deviceSettings;
+  deviceUpdateReboot: typeof deviceUpdateReboot;
+  deviceWipe: typeof deviceWipe;
+
+  evmGetAddress: typeof evmGetAddress;
+  evmGetPublicKey: typeof evmGetPublicKey;
+  evmSignMessage: typeof evmSignMessage;
+  evmSignMessageEIP712: typeof evmSignMessageEIP712;
+  evmSignTransaction: typeof evmSignTransaction;
+  evmSignTypedData: typeof evmSignTypedData;
+  evmVerifyMessage: typeof evmVerifyMessage;
+
+  btcGetAddress: typeof btcGetAddress;
+  btcGetPublicKey: typeof btcGetPublicKey;
+  btcSignMessage: typeof btcSignMessage;
+  btcSignTransaction: typeof btcSignTransaction;
+  btcVerifyMessage: typeof btcVerifyMessage;
+};

package/src/types/api/init.ts

@@ -0,0 +1,3 @@
+import type { ConnectSettings } from '../settings';
+
+export declare function init(settings: Partial<ConnectSettings>): Promise<void> | void;

package/src/types/api/searchDevices.ts

@@ -0,0 +1,4 @@
+import { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+import { Response } from '../params';
+
+export declare function searchDevices(): Response<DeviceDescriptor[]>;

package/src/types/api/uiResponse.ts

@@ -0,0 +1,3 @@
+import type { UiResponseEvent } from '../../events';
+
+export declare function uiResponse(response: UiResponseEvent): void;

package/src/types/device.ts

@@ -0,0 +1,71 @@
+import type { PROTO } from '../constants';
+import { IVersionArray } from './settings';
+
+export type DeviceStatus = 'available' | 'occupied' | 'used';
+
+export type DeviceMode = 'normal' | 'bootloader' | 'initialize' | 'seedless';
+
+export type UnavailableCapability =
+  | 'no-capability'
+  | 'no-support'
+  | 'update-required'
+  | 'trezor-connect-outdated';
+
+export type UnavailableCapabilities = { [key: string]: UnavailableCapability };
+
+export type KnownDevice = {
+  connectId: string | null;
+  uuid: string;
+  deviceId: string | null;
+  deviceType: IDeviceType;
+  path: string;
+  label: string;
+  error?: typeof undefined;
+  mode: DeviceMode;
+  features: PROTO.Features;
+  unavailableCapabilities: UnavailableCapabilities;
+  bleFirmwareVersion: IVersionArray | null;
+  firmwareVersion: IVersionArray | null;
+};
+
+// export type UnknownDevice = {
+//   type: 'unacquired';
+//   id?: null;
+//   path: string;
+//   label: string;
+//   error?: typeof undefined;
+//   features?: typeof undefined;
+//   firmware?: typeof undefined;
+//   firmwareRelease?: typeof undefined;
+//   status?: typeof undefined;
+//   mode?: typeof undefined;
+//   state?: typeof undefined;
+//   unavailableCapabilities?: typeof undefined;
+// };
+
+// export type UnreadableDevice = {
+//   type: 'unreadable';
+//   id?: null;
+//   path: string;
+//   label: string;
+//   error: string;
+//   features?: typeof undefined;
+//   firmware?: typeof undefined;
+//   firmwareRelease?: typeof undefined;
+//   status?: typeof undefined;
+//   mode?: typeof undefined;
+//   state?: typeof undefined;
+//   unavailableCapabilities?: typeof undefined;
+// };
+
+export type Device = KnownDevice;
+
+export type Features = PROTO.Features;
+
+export type IDeviceType = 'classic' | 'mini' | 'touch' | 'pro';
+
+export type IDeviceFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'none';
+
+export type IDeviceBLEFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'none';
+
+export type ITransportStatus = 'valid' | 'outdated';

package/src/types/firmware.ts

@@ -0,0 +1,40 @@
+export interface FirmwareRange {
+  '1': {
+    min: string;
+    max: string;
+  };
+  '2': {
+    min: string;
+    max: string;
+  };
+}
+
+export type VersionArray = [1 | 2, number, number];
+
+export type FirmwareRelease = {
+  required: boolean;
+  url: string;
+  fingerprint: string;
+  changelog: string;
+  min_bridge_version: [number, number, number];
+  version: VersionArray;
+  min_firmware_version: VersionArray;
+  min_bootloader_version: VersionArray;
+  bootloader_version?: VersionArray;
+  url_bitcoinonly?: string;
+  fingerprint_bitcoinonly?: string;
+  notes?: string;
+  rollout?: number;
+  channel?: string;
+};
+
+export type ReleaseInfo = {
+  changelog: FirmwareRelease[] | null;
+  release: FirmwareRelease;
+  isLatest: boolean;
+  latest: FirmwareRelease;
+  isRequired: boolean | null;
+  isNewer: boolean | null;
+};
+
+export type TransportReleaseStatus = 'valid' | 'outdated';

package/src/types/global.d.ts

@@ -0,0 +1,3 @@
+interface Window {
+  ONEKEY_CONNECT_SRC?: string;
+}

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './device';
+export * from './firmware';
+export * from './settings';
+export * from './params';

package/src/types/params.ts

@@ -0,0 +1,15 @@
+export interface CommonParams {
+  keepSession?: boolean;
+}
+
+export interface Unsuccessful {
+  success: false;
+  payload: { error: string; code?: string };
+}
+
+export interface Success<T> {
+  success: true;
+  payload: T;
+}
+
+export type Response<T> = Promise<Success<T> | Unsuccessful>;