@ukeyfe/hardware-core 1.1.13

package/src/types/api/cardano.ts

@@ -0,0 +1,212 @@
+import type { UintType } from '@ukeyfe/hardware-transport';
+import type { PROTO } from '../../constants';
+
+export interface CardanoAddressParameters {
+  addressType: PROTO.CardanoAddressType;
+  path?: string | number[];
+  stakingPath?: string | number[];
+  stakingKeyHash?: string;
+  certificatePointer?: CardanoCertificatePointer;
+  paymentScriptHash?: string;
+  stakingScriptHash?: string;
+}
+
+export interface CardanoCertificatePointer {
+  blockIndex: number;
+  txIndex: number;
+  certificateIndex: number;
+}
+
+export interface CardanoToken {
+  assetNameBytes: string;
+  amount?: string;
+  mintAmount?: string;
+}
+
+export interface CardanoAssetGroup {
+  policyId: string;
+  tokenAmounts: CardanoToken[];
+}
+
+export type AssetGroupWithTokens = {
+  policyId: string;
+  tokens: PROTO.CardanoToken[];
+};
+
+export interface CardanoDRep {
+  type: PROTO.CardanoDRepType;
+  keyHash?: string;
+  scriptHash?: string;
+}
+
+export interface CardanoCertificate {
+  type: PROTO.CardanoCertificateType;
+  path?: string | number[];
+  pool?: string;
+  poolParameters?: CardanoPoolParameters;
+  scriptHash?: string;
+  keyHash?: string;
+  deposit?: UintType;
+  dRep?: CardanoDRep;
+}
+
+export type CertificateWithPoolOwnersAndRelays = {
+  certificate: PROTO.CardanoTxCertificate;
+  poolOwners: PROTO.CardanoPoolOwner[];
+  poolRelays: PROTO.CardanoPoolRelayParameters[];
+};
+
+export interface CardanoPoolOwner {
+  stakingKeyPath?: string | number[];
+  stakingKeyHash?: string;
+}
+
+export interface CardanoPoolRelay {
+  type: PROTO.CardanoPoolRelayType;
+  ipv4Address?: string;
+  ipv6Address?: string;
+  port?: number;
+  hostName?: string;
+}
+
+export interface CardanoPoolMetadata {
+  url: string;
+  hash: string;
+}
+
+export interface CardanoPoolMargin {
+  numerator: string;
+  denominator: string;
+}
+
+export interface CardanoPoolParameters {
+  poolId: string;
+  vrfKeyHash: string;
+  pledge: string;
+  cost: string;
+  margin: CardanoPoolMargin;
+  rewardAccount: string;
+  owners: CardanoPoolOwner[];
+  relays: CardanoPoolRelay[];
+  metadata: CardanoPoolMetadata;
+}
+
+export interface CardanoInput {
+  path?: string | number[];
+  prev_hash: string;
+  prev_index: number;
+}
+
+export type CardanoOutput = (
+  | {
+      addressParameters: CardanoAddressParameters;
+    }
+  | {
+      address: string;
+    }
+) & {
+  amount: string;
+  tokenBundle?: CardanoAssetGroup[];
+  datumHash?: string;
+  format?: PROTO.CardanoTxOutputSerializationFormat;
+  inlineDatum?: string;
+  referenceScript?: string;
+};
+
+export interface CardanoWithdrawal {
+  path?: string | number[];
+  amount: string;
+  scriptHash?: string;
+  keyHash?: string;
+}
+
+export type CardanoMint = CardanoAssetGroup[];
+
+export interface CardanoCollateralInput {
+  path?: string | number[];
+  prev_hash: string;
+  prev_index: number;
+}
+
+export interface CardanoRequiredSigner {
+  keyPath?: string | number[];
+  keyHash?: string;
+}
+
+export interface CardanoReferenceInput {
+  prev_hash: string;
+  prev_index: number;
+}
+
+export interface CardanoCVoteRegistrationDelegation {
+  votePublicKey: string;
+  weight: number;
+}
+
+export interface CardanoCatalystRegistrationParameters {
+  votingPublicKey: string;
+  stakingPath: string | number[];
+  rewardAddressParameters: CardanoAddressParameters;
+  nonce: string;
+}
+
+export interface CardanoCVoteRegistrationParameters {
+  votePublicKey?: string;
+  stakingPath: string | number[];
+  paymentAddressParameters: CardanoAddressParameters;
+  nonce: string;
+  format?: PROTO.CardanoCVoteRegistrationFormat;
+  delegations?: CardanoCVoteRegistrationDelegation[];
+  votingPurpose?: number;
+  paymentAddress?: string;
+}
+
+export interface CardanoAuxiliaryData {
+  hash?: string;
+  cVoteRegistrationParameters?: CardanoCVoteRegistrationParameters;
+}
+
+export interface CardanoSignTransaction {
+  inputs: CardanoInput[];
+  outputs: CardanoOutput[];
+  fee: string;
+  ttl?: string;
+  certificates?: CardanoCertificate[];
+  withdrawals?: CardanoWithdrawal[];
+  validityIntervalStart?: string;
+  auxiliaryData?: CardanoAuxiliaryData;
+  mint?: CardanoMint;
+  scriptDataHash?: string;
+  collateralInputs?: CardanoCollateralInput[];
+  requiredSigners?: CardanoRequiredSigner[];
+  collateralReturn?: CardanoOutput;
+  totalCollateral?: string;
+  referenceInputs?: CardanoReferenceInput[];
+  additionalWitnessRequests?: (string | number[])[];
+  protocolMagic: number;
+  networkId: number;
+  signingMode: PROTO.CardanoTxSigningMode;
+  derivationType?: PROTO.CardanoDerivationType;
+  includeNetworkId?: boolean;
+  chunkify?: boolean;
+  tagCborSets?: boolean;
+}
+
+export interface CardanoSignedTxWitness {
+  type: PROTO.CardanoTxWitnessType;
+  pubKey: string;
+  signature: string;
+  chainCode?: string;
+}
+
+export interface CardanoAuxiliaryDataSupplement {
+  type: PROTO.CardanoTxAuxiliaryDataSupplementType;
+  auxiliaryDataHash: string;
+  cVoteRegistrationSignature?: string;
+}
+
+export interface CardanoSignedTxData {
+  hash: string;
+  witnesses: CardanoSignedTxWitness[];
+  auxiliaryDataSupplement?: CardanoAuxiliaryDataSupplement;
+}

package/src/types/api/cardanoGetAddress.ts

@@ -0,0 +1,49 @@
+import type { CardanoAddressParametersType } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+import type { CardanoAddressParameters } from './cardano';
+
+export type CardanoGetAddressMethodParams = {
+  addressParameters: CardanoAddressParameters;
+  networkId: number;
+  /**
+   * Testnet	cip34:0-1097911063
+   * Mainnet	cip34:1-764824073
+   */
+  protocolMagic: number;
+  derivationType: number;
+  address?: string;
+  isCheck?: boolean;
+  showOnOneKey: boolean;
+};
+
+export type CardanoGetAddressParams = {
+  address_parameters: CardanoAddressParametersType;
+  network_id: number;
+  protocol_magic: number;
+  derivation_type: number;
+  address: string;
+  show_display: boolean;
+};
+
+export type CardanoAddress = {
+  addressParameters: CardanoAddressParameters;
+  protocolMagic: number;
+  networkId: number;
+  serializedPath: string;
+  serializedStakingPath: string;
+  address: string;
+  xpub?: string;
+  stakeAddress?: string;
+};
+
+export declare function cardanoGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & CardanoGetAddressMethodParams
+): Response<CardanoAddress>;
+
+export declare function cardanoGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: CardanoGetAddressMethodParams[] }
+): Response<CardanoAddress[]>;

package/src/types/api/cardanoGetPublicKey.ts

@@ -0,0 +1,33 @@
+import type { CommonParams, Response } from '../params';
+import { PROTO } from '../../constants';
+
+export type CardanoPublicKey = {
+  path: number[];
+  serializedPath: string;
+  xpub: string;
+  node: PROTO.HDNodeType;
+};
+
+export type CardanoPublicKeyParams = {
+  address_n: number[];
+  derivation_type: number;
+  show_display: boolean;
+};
+
+export type CardanoPublicKeyMethodParams = {
+  path: string | number[];
+  derivationType?: number;
+  showOnOneKey?: boolean;
+};
+
+export declare function cardanoGetPublicKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & CardanoPublicKeyMethodParams
+): Response<CardanoPublicKey>;
+
+export declare function cardanoGetPublicKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: CardanoPublicKeyMethodParams[] }
+): Response<CardanoPublicKey[]>;

package/src/types/api/cardanoSignMessage.ts

@@ -0,0 +1,25 @@
+import type { CardanoMessageSignature } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+import { PROTO } from '../../constants';
+
+export type CardanoSignMessageParams = {
+  address_n: number[];
+  message: string;
+  derivation_type: number;
+  network_id: number;
+  address_type: number;
+};
+
+export type CardanoSignMessageMethodParams = {
+  path: string;
+  message: string;
+  derivationType: number;
+  networkId: number;
+  addressType?: PROTO.CardanoAddressType;
+};
+
+export declare function cardanoSignMessage(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & CardanoSignMessageMethodParams
+): Response<CardanoMessageSignature>;

package/src/types/api/cardanoSignTransaction.ts

@@ -0,0 +1,8 @@
+import type { CommonParams, Response } from '../params';
+import type { CardanoSignTransaction, CardanoSignedTxData } from './cardano';
+
+export declare function cardanoSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & CardanoSignTransaction
+): Response<CardanoSignedTxData>;

package/src/types/api/checkAllFirmwareRelease.ts

@@ -0,0 +1,30 @@
+import type { CommonParams, Response } from '../params';
+import type { IDeviceBLEFirmwareStatus, IDeviceFirmwareStatus } from '../device';
+import { IBLEFirmwareReleaseInfo } from '../settings';
+
+export type FirmwareRelease = {
+  shouldUpdate?: boolean;
+  status: IDeviceFirmwareStatus;
+  changelog?: {
+    'zh-CN': string;
+    'en-US': string;
+  }[];
+  release: IDeviceBLEFirmwareStatus | IBLEFirmwareReleaseInfo;
+  bootloaderMode?: boolean;
+};
+
+export type AllFirmwareRelease = {
+  firmware: FirmwareRelease;
+  ble: FirmwareRelease;
+  bootloader?: FirmwareRelease;
+  bridge?: FirmwareRelease;
+};
+
+export type CheckAllFirmwareReleaseParams = {
+  checkBridgeRelease?: boolean;
+};
+
+export declare function checkAllFirmwareRelease(
+  connectId?: string,
+  params?: CommonParams & CheckAllFirmwareReleaseParams
+): Response<AllFirmwareRelease>;

package/src/types/api/checkBLEFirmwareRelease.ts

@@ -0,0 +1,15 @@
+import type { Response } from '../params';
+import type { IDeviceBLEFirmwareStatus } from '../device';
+import { IBLEFirmwareReleaseInfo } from '../settings';
+
+type BleFirmwareRelease = {
+  status: IDeviceBLEFirmwareStatus;
+  changelog: {
+    'zh-CN': string;
+    'en-US': string;
+  }[];
+  release: IBLEFirmwareReleaseInfo;
+  bootloaderMode: boolean;
+};
+
+export declare function checkBLEFirmwareRelease(connectId?: string): Response<BleFirmwareRelease>;

package/src/types/api/checkBootloaderRelease.ts

@@ -0,0 +1,15 @@
+import type { CommonParams, Response } from '../params';
+
+export type CheckBootloaderReleaseResponse = {
+  shouldUpdate: boolean;
+  status: 'outdated' | 'valid';
+  release: string | undefined;
+  bootloaderMode: boolean;
+} | null;
+
+export declare function checkBootloaderRelease(
+  connectId?: string,
+  params?: CommonParams & {
+    willUpdateFirmwareVersion?: string;
+  }
+): Response<CheckBootloaderReleaseResponse>;

package/src/types/api/checkBridgeRelease.ts

@@ -0,0 +1,14 @@
+import type { CommonParams, Response } from '../params';
+
+export type CheckBridgeReleaseResponse = {
+  shouldUpdate: boolean;
+  status: 'outdated' | 'valid';
+  releaseVersion: string;
+} | null;
+
+export declare function checkBridgeRelease(
+  connectId?: string,
+  params?: CommonParams & {
+    willUpdateFirmwareVersion?: string;
+  }
+): Response<CheckBridgeReleaseResponse>;

package/src/types/api/checkBridgeStatus.ts

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

package/src/types/api/checkFirmwareRelease.ts

@@ -0,0 +1,15 @@
+import type { Response } from '../params';
+import type { IDeviceFirmwareStatus } from '../device';
+import { IFirmwareReleaseInfo } from '../settings';
+
+type FirmwareRelease = {
+  status: IDeviceFirmwareStatus;
+  changelog: {
+    'en-US': string;
+    'zh-CN': string;
+  }[];
+  release: IFirmwareReleaseInfo;
+  bootloaderMode: boolean;
+};
+
+export declare function checkFirmwareRelease(connectId?: string): Response<FirmwareRelease>;

package/src/types/api/cipherKeyValue.ts

@@ -0,0 +1,28 @@
+import { CipheredKeyValue as HardwareCipheredKeyValue } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type CipheredKeyValue = {
+  path: string;
+} & HardwareCipheredKeyValue;
+
+export type CipheredKeyValueParams = {
+  path: string | number[];
+  key: string;
+  value: string;
+  encrypt?: boolean;
+  askOnEncrypt?: boolean;
+  askOnDecrypt?: boolean;
+  iv?: string;
+};
+
+export declare function cipherKeyValue(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & CipheredKeyValueParams
+): Response<CipheredKeyValue>;
+
+export declare function cipherKeyValue(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: CipheredKeyValueParams[] }
+): Response<Array<CipheredKeyValue>>;

package/src/types/api/confluxGetAddress.ts

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

package/src/types/api/confluxSignMessage.ts

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

package/src/types/api/confluxSignMessageCIP23.ts

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

package/src/types/api/confluxSignTransaction.ts

@@ -0,0 +1,32 @@
+import type { CommonParams, Response } from '../params';
+
+export type ConfluxSignedTx = {
+  v: string;
+  r: string;
+  s: string;
+};
+
+export type ConfluxTransaction = {
+  to: string;
+  value: string;
+  gasLimit: string;
+  gasPrice: string;
+  nonce: string;
+  epochHeight: string;
+  storageLimit: string;
+  chainId?: number;
+  data?: string;
+  data_initial_chunk?: string;
+  data_length?: string;
+};
+
+export type ConfluxSignTransactionParams = {
+  path: string | number[];
+  transaction: ConfluxTransaction;
+};
+
+export declare function confluxSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & ConfluxSignTransactionParams
+): Response<ConfluxSignedTx>;

package/src/types/api/cosmosGetAddress.ts

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

package/src/types/api/cosmosGetPublicKey.ts

@@ -0,0 +1,28 @@
+import type { CommonParams, Response } from '../params';
+
+export type CosmosPublicKey = {
+  path: string;
+  pub: string;
+  /**
+   * @deprecated Use `pub` instead.
+   */
+  publicKey?: string;
+};
+
+export type CosmosGetPublicKeyParams = {
+  path: string | number[];
+  curve?: string;
+  showOnOneKey?: boolean;
+};
+
+export declare function cosmosGetPublicKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & CosmosGetPublicKeyParams
+): Response<CosmosPublicKey>;
+
+export declare function cosmosGetPublicKey(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: CosmosGetPublicKeyParams[] }
+): Response<Array<CosmosPublicKey>>;

package/src/types/api/cosmosSignTransaction.ts

@@ -0,0 +1,17 @@
+import { CosmosSignedTx as HardwareCosmosSignedTx } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type CosmosSignedTx = {
+  path: string;
+} & HardwareCosmosSignedTx;
+
+export type CosmosSignTransactionParams = {
+  path: string | number[];
+  rawTx?: string;
+};
+
+export declare function cosmosSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & CosmosSignTransactionParams
+): Response<CosmosSignedTx>;

package/src/types/api/deviceBackup.ts

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

package/src/types/api/deviceCancel.ts

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

package/src/types/api/deviceChangePin.ts

@@ -0,0 +1,11 @@
+import { Success } from '@ukeyfe/hardware-transport';
+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 '@ukeyfe/hardware-transport';
+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/deviceFullyUploadResource.ts

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

package/src/types/api/deviceLock.ts

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

package/src/types/api/deviceRebootToBoardloader.ts

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