@ukeyfe/hardware-core 1.1.13

package/src/types/api/deviceRebootToBootloader.ts

@@ -0,0 +1,4 @@
+import { Success } from '@ukeyfe/hardware-transport';
+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 '@ukeyfe/hardware-transport';
+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 '@ukeyfe/hardware-transport';
+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,20 @@
+import { SafetyCheckLevel, Success } from '@ukeyfe/hardware-transport';
+import type { CommonParams, 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,
+  params: CommonParams & DeviceSettingsParams
+): Response<Success>;

package/src/types/api/deviceSupportFeatures.ts

@@ -0,0 +1,6 @@
+import type { Response } from '../params';
+import type { Device, SupportFeatures } from '../device';
+
+export type DeviceSupportFeatures = SupportFeatures & { device: Device | null };
+
+export declare function deviceSupportFeatures(connectId?: string): Response<DeviceSupportFeatures>;

package/src/types/api/deviceUnlock.ts

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

package/src/types/api/deviceUpdateBootloader.ts

@@ -0,0 +1,9 @@
+import { Success } from '@ukeyfe/hardware-transport';
+import type { Response } from '../params';
+
+export declare function deviceUpdateBootloader(
+  connectId: string,
+  params?: {
+    binary?: ArrayBuffer;
+  }
+): Response<Success>;

package/src/types/api/deviceUpdateReboot.ts

@@ -0,0 +1,3 @@
+import type { Response } from '../params';
+
+export declare function deviceUpdateReboot(connectId: string): Response<boolean>;

package/src/types/api/deviceUploadResource.ts

@@ -0,0 +1,16 @@
+import { ResourceType, Success } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type DeviceUploadResourceParams = {
+  suffix: string;
+  dataHex: string;
+  thumbnailDataHex: string;
+  resType: ResourceType;
+  nftMetaData: string;
+  fileNameNoExt?: string;
+};
+
+export declare function deviceUploadResource(
+  connectId: string,
+  params: CommonParams & DeviceUploadResourceParams
+): Response<Success>;

package/src/types/api/deviceVerify.ts

@@ -0,0 +1,15 @@
+import type { CommonParams, Response } from '../params';
+
+export type DeviceVerifyParams = {
+  dataHex: string;
+};
+
+export type DeviceVerifySignature = {
+  cert: string;
+  signature: string;
+};
+
+export declare function deviceVerify(
+  connectId: string,
+  params: CommonParams & DeviceVerifyParams
+): Response<DeviceVerifySignature>;

package/src/types/api/deviceWipe.ts

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

package/src/types/api/dnxGetAddress.ts

@@ -0,0 +1,23 @@
+import type { DnxAddress as HardwareDnxAddress } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type DnxAddress = {
+  path: string;
+} & HardwareDnxAddress;
+
+export type DnxGetAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+};
+
+export declare function dnxGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & DnxGetAddressParams
+): Response<DnxAddress>;
+
+export declare function dnxGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: DnxGetAddressParams[] }
+): Response<Array<DnxAddress>>;

package/src/types/api/dnxSignTransaction.ts

@@ -0,0 +1,36 @@
+import { UintType } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type DnxTxKey = {
+  ephemeralTxSecKey: string;
+  ephemeralTxPubKey: string;
+};
+
+export type DnxSignTransactionParams = {
+  path: string | number[];
+  inputs: {
+    prevIndex: number;
+    globalIndex: number;
+    txPubkey: string;
+    prevOutPubkey: string;
+    amount: UintType;
+  }[];
+  toAddress: string;
+  amount: UintType;
+  fee: UintType;
+  paymentIdHex?: string;
+};
+
+export type DnxSignature = {
+  path: string;
+  txKey: DnxTxKey;
+  computedKeyImages: string[];
+  signatures: string[];
+  outputKeys: string[];
+};
+
+export declare function dnxSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & DnxSignTransactionParams
+): Response<DnxSignature>;

package/src/types/api/emmcFileWrite.ts

@@ -0,0 +1,12 @@
+import type { Params, Response } from '../params';
+
+export interface EmmcFileWriteParams {
+  payload: ArrayBuffer;
+  filePath: string; // e.g. '0:boot/bootloader.bin'
+  hash?: string;
+}
+
+export declare function emmcFileWrite(
+  connectId: string | undefined,
+  params: Params<EmmcFileWriteParams>
+): Response<number>;

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,24 @@
+import type { CommonParams, Response } from '../params';
+
+export type EVMAddress = {
+  path: string;
+  address: string;
+};
+
+export type EVMGetAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+  chainId?: number;
+};
+
+export declare function evmGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & EVMGetAddressParams
+): Response<EVMAddress>;
+
+export declare function evmGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: EVMGetAddressParams[] }
+): Response<Array<EVMAddress>>;

package/src/types/api/evmGetPublicKey.ts

@@ -0,0 +1,36 @@
+import { EthereumPublicKey } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type EVMPublicKey = {
+  path: string;
+  pub: string;
+  /**
+   * @deprecated Use `pub` instead.
+   */
+  publicKey?: string;
+} & EthereumPublicKey;
+
+export type EVMGetPublicKeyParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+  chainId?: number;
+  useBatch?: boolean;
+};
+
+export declare function evmGetPublicKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & EVMGetPublicKeyParams
+): Response<EVMPublicKey>;
+
+export declare function evmGetPublicKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: EVMGetPublicKeyParams[] }
+): Response<Array<EVMPublicKey>>;
+
+export declare function evmGetPublicKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: EVMGetPublicKeyParams[] }
+): Response<Omit<EVMPublicKey, 'node' | 'xpub'>>;

package/src/types/api/evmSignMessage.ts

@@ -0,0 +1,14 @@
+import { EthereumMessageSignature } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type EVMSignMessageParams = {
+  path: string | number[];
+  messageHex: string;
+  chainId?: number;
+};
+
+export declare function evmSignMessage(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & EVMSignMessageParams
+): Response<EthereumMessageSignature>;

package/src/types/api/evmSignMessageEIP712.ts

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

package/src/types/api/evmSignTransaction.ts

@@ -0,0 +1,80 @@
+import type { CommonParams, Response } from '../params';
+
+export type EVMSignedTx = {
+  v: string;
+  r: string;
+  s: string;
+  authorizationSignatures?: EVMAuthorizationSignature[];
+};
+
+export type 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 EVMAuthorizationSignature = {
+  yParity: number;
+  r: string;
+  s: string;
+};
+
+export type EVMAuthorization = {
+  chainId: number;
+  address: string;
+  nonce: string;
+  addressN?: number[];
+  yParity?: number;
+  r?: string;
+  s?: string;
+};
+
+export type EVMTransactionEIP7702 = {
+  to: string;
+  value: string;
+  gasLimit: string;
+  gasPrice?: typeof undefined;
+  nonce: string;
+  data?: string;
+  chainId: number;
+  maxFeePerGas: string;
+  maxPriorityFeePerGas: string;
+  accessList?: EVMAccessList[];
+  authorizationList: EVMAuthorization[];
+};
+
+export type EVMSignTransactionParams = {
+  path: string | number[];
+  transaction: EVMTransaction | EVMTransactionEIP1559 | EVMTransactionEIP7702;
+};
+
+export declare function evmSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & EVMSignTransactionParams
+): Response<EVMSignedTx>;

package/src/types/api/evmSignTypedData.ts

@@ -0,0 +1,42 @@
+import { EthereumMessageSignature } from '@ukeyfe/hardware-transport';
+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;
+  chainId?: number;
+};
+
+export declare function evmSignTypedData(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & EVMSignTypedDataParams
+): Response<EthereumMessageSignature>;

package/src/types/api/evmVerifyMessage.ts

@@ -0,0 +1,15 @@
+import { Success } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type EVMVerifyMessageParams = {
+  address: string;
+  messageHex: string;
+  signature: string;
+  chainId?: number;
+};
+
+export declare function evmVerifyMessage(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & EVMVerifyMessageParams
+): Response<Success>;

package/src/types/api/export.ts

@@ -0,0 +1,191 @@
+export type { BTCAddress, BTCGetAddressParams } from './btcGetAddress';
+export type { BTCPublicKey, BTCGetPublicKeyParams } from './btcGetPublicKey';
+export type { BTCSignMessageParams } from './btcSignMessage';
+export type { BTCVerifyMessageParams } from './btcVerifyMessage';
+export type {
+  RefTransaction,
+  AccountAddress,
+  AccountAddresses,
+  BTCSignTransactionParams,
+  SignedTransaction,
+  TransactionOptions,
+} from './btcSignTransaction';
+
+export type { CipheredKeyValue, CipheredKeyValueParams } from './cipherKeyValue';
+
+export type { DeviceChangePinParams } from './deviceChangePin';
+export type { DeviceFlagsParams } from './deviceFlags';
+export type { DeviceRecoveryParams } from './deviceRecovery';
+export type { DeviceResetParams } from './deviceReset';
+export type { DeviceSettingsParams } from './deviceSettings';
+export type { DeviceVerifyParams, DeviceVerifySignature } from './deviceVerify';
+export type { DeviceSupportFeatures } from './deviceSupportFeatures';
+export type { DeviceUploadResourceParams } from './deviceUploadResource';
+export type {
+  FirmwareUpdateParams,
+  FirmwareUpdateBinaryParams,
+  FirmwareUpdateV3Params,
+} from './firmwareUpdate';
+export type { EmmcFileWriteParams } from './emmcFileWrite';
+
+export type { AllNetworkAddressParams, AllNetworkGetAddressParams } from './allNetworkGetAddress';
+
+export type { EVMAddress, EVMGetAddressParams } from './evmGetAddress';
+export type { EVMPublicKey, EVMGetPublicKeyParams } from './evmGetPublicKey';
+export type { EVMSignMessageParams } from './evmSignMessage';
+export type { EVMSignMessageEIP712Params } from './evmSignMessageEIP712';
+export type {
+  EVMTransaction,
+  EVMTransactionEIP1559,
+  EVMTransactionEIP7702,
+  EVMAuthorization,
+  EVMAuthorizationSignature,
+  EVMSignedTx,
+  EVMSignTransactionParams,
+  EVMAccessList,
+} from './evmSignTransaction';
+export type {
+  EthereumSignTypedDataTypes,
+  EthereumSignTypedDataTypeProperty,
+  EthereumSignTypedDataMessage,
+  EVMSignTypedDataParams,
+} from './evmSignTypedData';
+export type { EVMVerifyMessageParams } from './evmVerifyMessage';
+
+export type { StarcoinAddress, StarcoinGetAddressParams } from './starcoinGetAddress';
+export type { StarcoinPublicKey, StarcoinGetPublicKeyParams } from './starcoinGetPublicKey';
+export type { StarcoinSignMessageParams } from './starcoinSignMessage';
+export type { StarcoinSignTransactionParams } from './starcoinSignTransaction';
+export type { StarcoinVerifyMessageParams } from './starcoinVerifyMessage';
+
+export type { NEMAddress, NEMGetAddressParams } from './nemGetAddress';
+export type {
+  NEMAggregateModificationTransaction,
+  NEMImportanceTransaction,
+  NEMMosaic,
+  NEMMosaicCreationTransaction,
+  NEMMultisigTransaction,
+  NEMProvisionNamespaceTransaction,
+  NEMSupplyChangeTransaction,
+  NEMTransferTransaction,
+  NEMTransaction,
+  NEMSignTransactionParams,
+} from './nemSignTransaction';
+
+export type { SolanaAddress, SolanaGetAddressParams } from './solGetAddress';
+export type { SolanaSignedTx, SolanaSignTransactionParams } from './solSignTransaction';
+export type {
+  SolSignOffchainMessageResponse,
+  SolSignOffchainMessageParams,
+} from './solSignOffchainMessage';
+export type { SolSignMessageResponse, SolSignMessageParams } from './solSignMessage';
+
+export type { StellarAddress, StellarGetAddressParams } from './stellarGetAddress';
+export type {
+  StellarAsset,
+  StellarOperation,
+  StellarTransaction,
+  StellarSignTransactionParams,
+} from './stellarSignTransaction';
+
+export type { TronAddress, TronGetAddressParams } from './tronGetAddress';
+export type { TronSignMessageParams } from './tronSignMessage';
+export type {
+  TronTransaction,
+  TronSignTransactionParams,
+  TronTransactionContract,
+  TronTransferContract,
+  TronTriggerSmartContract,
+  TronFreezeBalanceV2Contract,
+  TronUnfreezeBalanceV2Contract,
+  TronDelegateResourceContract,
+  TronUnDelegateResourceContract,
+  TronWithdrawBalanceContract,
+  TronWithdrawExpireUnfreezeContract,
+} from './tronSignTransaction';
+
+export type { ConfluxAddress, ConfluxGetAddressParams } from './confluxGetAddress';
+export type { ConfluxSignMessageParams } from './confluxSignMessage';
+export type { ConfluxSignMessageCIP23Params } from './confluxSignMessageCIP23';
+export type {
+  ConfluxSignTransactionParams,
+  ConfluxSignedTx,
+  ConfluxTransaction,
+} from './confluxSignTransaction';
+
+export type { NearAddress, NearGetAddressParams } from './nearGetAddress';
+export type { NearSignTransactionParams } from './nearSignTransaction';
+
+export type { AptosAddress, AptosGetAddressParams } from './aptosGetAddress';
+export type { AptosPublicKey, AptosGetPublicKeyParams } from './aptosGetPublicKey';
+export type { AptosMessageSignature, AptosSignMessageParams } from './aptosSignMessage';
+export type { AptosSignInMessageSignature, AptosSignInMessageParams } from './aptosSignInMessage';
+export type { AptosSignedTx, AptosSignTransactionParams } from './aptosSignTransaction';
+
+export type { AlgoAddress, AlgoGetAddressParams } from './algoGetAddress';
+export type { AlgoSignedTx, AlgoSignTransactionParams } from './algoSignTransaction';
+
+export type { CosmosAddress, CosmosGetAddressParams } from './cosmosGetAddress';
+export type { CosmosPublicKey, CosmosGetPublicKeyParams } from './cosmosGetPublicKey';
+export type { CosmosSignedTx, CosmosSignTransactionParams } from './cosmosSignTransaction';
+
+export type { SuiAddress, SuiGetAddressParams } from './suiGetAddress';
+export type { SuiPublicKey, SuiGetPublicKeyParams } from './suiGetPublicKey';
+export type { SuiSignMessageParams } from './suiSignMessage';
+export type { SuiSignedTx, SuiSignTransactionParams } from './suiSignTransaction';
+
+export type {
+  CardanoGetAddressMethodParams,
+  CardanoAddress,
+  CardanoGetAddressParams,
+} from './cardanoGetAddress';
+export type {
+  CardanoSignMessageMethodParams,
+  CardanoSignMessageParams,
+} from './cardanoSignMessage';
+export type { CardanoSignTransaction, CardanoSignedTxData } from './cardano';
+
+export type { FilecoinAddress, FilecoinGetAddressParams } from './filecoinGetAddress';
+export type { FilecoinSignTransactionParams, FilecoinSignedTx } from './filecoinSignTransaction';
+
+export type { PolkadotAddress, PolkadotGetAddressParams } from './polkadotGetAddress';
+export type { PolkadotSignedTx, PolkadotSignTransactionParams } from './polkadotSignTransaction';
+
+export type { KaspaAddress, KaspaGetAddressParams } from './kaspaGetAddress';
+export type {
+  KaspaSignature,
+  KaspaSignTransactionParams,
+  KaspaSignInputParams,
+  KaspaSignOutputParams,
+} from './kaspaSignTransaction';
+
+export type { NexaAddress, NexaGetAddressParams } from './nexaGetAddress';
+export type {
+  NexaSignature,
+  NexaSignTransactionParams,
+  NexaSignInputParams,
+  NexaSignOutputParams,
+} from './nexaSignTransaction';
+
+export type { NervosAddress, NervosGetAddressParams } from './nervosGetAddress';
+export type { NervosSignedTx, NervosSignTransactionParams } from './nervosSignTransaction';
+
+export type { DnxAddress, DnxGetAddressParams } from './dnxGetAddress';
+export type { DnxTxKey, DnxSignTransactionParams, DnxSignature } from './dnxSignTransaction';
+
+export type { TonAddress, TonGetAddressParams } from './tonGetAddress';
+export type { TonSignMessageParams } from './tonSignMessage';
+export type { TonSignProofParams } from './tonSignProof';
+
+export type { ScdoAddress, ScdoGetAddressParams } from './scdoGetAddress';
+export type { ScdoSignMessageParams } from './scdoSignMessage';
+export type { ScdoSignTransactionParams, ScdoSignedTx } from './scdoSignTransaction';
+
+export type { AlephiumAddress, AlephiumGetAddressParams } from './alephiumGetAddress';
+export type { AlephiumSignMessageParams } from './alephiumSignMessage';
+export type { AlephiumSignTransactionParams, AlephiumSignedTx } from './alephiumSignTransaction';
+
+export type { BenfenAddress, BenfenGetAddressParams } from './benfenGetAddress';
+export type { BenfenPublicKey, BenfenGetPublicKeyParams } from './benfenGetPublicKey';
+export type { BenfenSignMessageParams } from './benfenSignMessage';
+export type { BenfenSignedTx, BenfenSignTransactionParams } from './benfenSignTransaction';

package/src/types/api/filecoinGetAddress.ts

@@ -0,0 +1,24 @@
+import { FilecoinAddress as HardwareFilecoinAddress } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type FilecoinAddress = {
+  path: string;
+} & HardwareFilecoinAddress;
+
+export type FilecoinGetAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+  isTestnet?: boolean;
+};
+
+export declare function filecoinGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & FilecoinGetAddressParams
+): Response<FilecoinAddress>;
+
+export declare function filecoinGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: FilecoinGetAddressParams[] }
+): Response<Array<FilecoinAddress>>;