@onekeyfe/hd-core 0.0.6 → 0.0.9

package/src/types/api/nemSignTransaction.ts

@@ -0,0 +1,117 @@
+import { NEMSignedTx } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+type MosaicID = {
+  namespaceId: string;
+  name: string;
+};
+
+type MosaicDefinition = {
+  levy?: {
+    type?: number;
+    fee?: number;
+    recipient?: string;
+    mosaicId?: MosaicID;
+  };
+  id: MosaicID;
+  description: string;
+  properties?: Array<{
+    name: 'divisibility' | 'initialSupply' | 'supplyMutable' | 'transferable';
+    value: string;
+  }>;
+};
+
+export type NEMMosaic = {
+  mosaicId: MosaicID;
+  quantity: number;
+};
+
+type Modification = {
+  modificationType: number;
+  cosignatoryAccount: string;
+};
+
+type Message = {
+  payload?: string;
+  type?: number;
+  publicKey?: string;
+};
+
+type TransactionCommon = {
+  version: number;
+  timeStamp: number;
+  fee: number;
+  deadline?: number;
+  signer?: string;
+};
+
+export type NEMTransferTransaction = TransactionCommon & {
+  type: 0x0101;
+  recipient: string;
+  amount: number | string;
+  mosaics?: NEMMosaic[];
+  message?: Message;
+};
+
+export type NEMImportanceTransaction = TransactionCommon & {
+  type: 0x0801;
+  importanceTransfer: {
+    mode: number;
+    publicKey: string;
+  };
+};
+
+export type NEMAggregateModificationTransaction = TransactionCommon & {
+  type: 0x1001;
+  modifications?: Modification[];
+  minCosignatories: {
+    relativeChange: number;
+  };
+};
+
+export type NEMProvisionNamespaceTransaction = TransactionCommon & {
+  type: 0x2001;
+  newPart?: string;
+  parent?: string;
+  rentalFeeSink?: string;
+  rentalFee?: number;
+};
+
+export type NEMMosaicCreationTransaction = TransactionCommon & {
+  type: 0x4001;
+  mosaicDefinition: MosaicDefinition;
+  creationFeeSink?: string;
+  creationFee?: number;
+};
+
+export type NEMSupplyChangeTransaction = TransactionCommon & {
+  type: 0x4002;
+  mosaicId: MosaicID;
+  supplyType: number;
+  delta?: number;
+};
+
+type Transaction =
+  | NEMTransferTransaction
+  | NEMImportanceTransaction
+  | NEMAggregateModificationTransaction
+  | NEMProvisionNamespaceTransaction
+  | NEMMosaicCreationTransaction
+  | NEMSupplyChangeTransaction;
+
+export type NEMMultisigTransaction = TransactionCommon & {
+  type: 0x0102 | 0x1002 | 0x1004;
+  otherTrans: Transaction;
+};
+
+export type NEMTransaction = Transaction | NEMMultisigTransaction;
+
+export type NEMSignTransactionParams = {
+  path: string | number[];
+  transaction: NEMTransaction;
+};
+
+export declare function nemSignTransaction(
+  connectId: string,
+  params: CommonParams & NEMSignTransactionParams
+): Response<NEMSignedTx>;

package/src/types/api/solGetAddress.ts

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

package/src/types/api/solSignTransaction.ts

@@ -0,0 +1,21 @@
+import { SolanaSignedTx as HardwareSolanaSignedTx } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type SolanaSignedTx = {
+  path: string;
+} & HardwareSolanaSignedTx;
+
+export type SolanaSignTransactionParams = {
+  path: string | number[];
+  rawTx?: string;
+};
+
+export declare function solSignTransaction(
+  connectId: string,
+  params: CommonParams & SolanaSignTransactionParams
+): Response<SolanaSignedTx>;
+
+export declare function solSignTransaction(
+  connectId: string,
+  params: CommonParams & { bundle?: SolanaSignTransactionParams[] }
+): Response<Array<SolanaSignedTx>>;

package/src/types/api/stellarGetAddress.ts

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

package/src/types/api/stellarSignTransaction.ts

@@ -0,0 +1,153 @@
+import { StellarSignedTx } from '@onekeyfe/hd-transport/src/types/messages';
+import { CommonParams, Response } from '../params';
+
+export type StellarAsset = {
+  type: 0 | 1 | 2; // 0: native, 1: credit_alphanum4, 2: credit_alphanum12
+  code: string;
+  issuer?: string;
+};
+
+type StellarCreateAccountOperation = {
+  type: 'createAccount';
+  source?: string;
+  destination: string;
+  startingBalance: string;
+};
+
+type StellarPaymentOperation = {
+  type: 'payment';
+  source?: string;
+  destination: string;
+  asset?: StellarAsset | typeof undefined;
+  amount: string;
+};
+
+type StellarPathPaymentOperation = {
+  type: 'pathPayment';
+  source?: string;
+  sendAsset: StellarAsset;
+  sendMax: string;
+  destination: string;
+  destAsset: StellarAsset;
+  destAmount: string;
+  path?: StellarAsset[];
+};
+
+type StellarPassiveOfferOperation = {
+  type: 'createPassiveOffer';
+  source?: string;
+  buying: StellarAsset;
+  selling: StellarAsset;
+  amount: string;
+  price: { n: number; d: number };
+};
+
+type StellarManageOfferOperation = {
+  type: 'manageOffer';
+  source?: string;
+  buying: StellarAsset;
+  selling: StellarAsset;
+  amount: string;
+  offerId?: string;
+  price: { n: number; d: number };
+};
+
+type StellarSetOptionsOperation = {
+  type: 'setOptions';
+  source?: string;
+  signer?: {
+    type: 0 | 1 | 2;
+    key: string | Buffer;
+    weight?: number;
+  };
+  inflationDest?: string;
+  clearFlags?: number;
+  setFlags?: number;
+  masterWeight?: number | string;
+  lowThreshold?: number | string;
+  medThreshold?: number | string;
+  highThreshold?: number | string;
+  homeDomain?: string;
+};
+
+type StellarChangeTrustOperation = {
+  type: 'changeTrust';
+  source?: string;
+  line: StellarAsset;
+  limit?: string;
+};
+
+type StellarAllowTrustOperation = {
+  type: 'allowTrust';
+  source?: string;
+  trustor: string;
+  assetCode: string;
+  assetType: number;
+  authorize?: boolean | typeof undefined;
+};
+
+type StellarAccountMergeOperation = {
+  type: 'accountMerge';
+  source?: string;
+  destination: string;
+};
+
+type StellarManageDataOperation = {
+  type: 'manageData';
+  source?: string;
+  name: string;
+  value?: Buffer | string;
+};
+
+type StellarBumpSequenceOperation = {
+  type: 'bumpSequence';
+  source?: string;
+  bumpTo: string;
+};
+
+type StellarInflationOperation = {
+  type: 'inflation';
+  source?: string;
+};
+
+export type StellarOperation =
+  | StellarCreateAccountOperation
+  | StellarPaymentOperation
+  | StellarPathPaymentOperation
+  | StellarPassiveOfferOperation
+  | StellarManageOfferOperation
+  | StellarSetOptionsOperation
+  | StellarChangeTrustOperation
+  | StellarAllowTrustOperation
+  | StellarAccountMergeOperation
+  | StellarInflationOperation
+  | StellarManageDataOperation
+  | StellarBumpSequenceOperation;
+
+export type StellarTransaction = {
+  source: string;
+  fee: number;
+  sequence: string | number;
+  timebounds?: {
+    minTime: number;
+    maxTime: number;
+  };
+  memo?: {
+    type: 0 | 1 | 2 | 3 | 4;
+    id?: string;
+    text?: string;
+    hash?: string | Buffer;
+  };
+  operations: StellarOperation[];
+};
+
+export type StellarSignTransactionParams = {
+  path: string | number[];
+  networkPassphrase: string;
+  transaction: StellarTransaction;
+};
+
+export declare function stellarSignTransaction(
+  connectId: string,
+  params: CommonParams & StellarSignTransactionParams
+): Response<StellarSignedTx>;

package/src/types/device.ts

@@ -73,8 +73,16 @@ export type Features = PROTO.Features;
 
 export type IDeviceType = 'classic' | 'mini' | 'touch' | 'pro';
 
+// model_mini: 'classic' | 'mini'
+// model_touch: 'touch' | 'pro'
+export type IDeviceModel = 'model_mini' | 'model_touch';
+
 export type IDeviceFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'none';
 
 export type IDeviceBLEFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'none';
 
 export type ITransportStatus = 'valid' | 'outdated';
+
+export type DeviceFirmwareRange = {
+  [deviceType in IDeviceType | IDeviceModel]?: { min: string; max?: string };
+};

package/src/utils/deviceFeaturesUtils.ts

@@ -1,4 +1,16 @@
-import type { Features, IVersionArray, IDeviceType } from '../types';
+import type { Features, IVersionArray, IDeviceType, IDeviceModel } from '../types';
+
+export const getDeviceModel = (features?: Features): IDeviceModel => {
+  if (!features || typeof features !== 'object') {
+    return 'model_mini';
+  }
+
+  if (features.model === '1') {
+    return 'model_mini';
+  }
+  // model === 'T'
+  return 'model_touch';
+};
 
 export const getDeviceType = (features?: Features): IDeviceType => {
   if (!features || typeof features !== 'object' || !features.serial_no) {
@@ -8,6 +20,24 @@ export const getDeviceType = (features?: Features): IDeviceType => {
   const serialNo = features.serial_no;
   const miniFlag = serialNo.slice(0, 2);
   if (miniFlag.toLowerCase() === 'mi') return 'mini';
+  if (miniFlag.toLowerCase() === 'tc') return 'touch';
+  return 'classic';
+};
+
+export const getDeviceTypeByBleName = (name?: string): IDeviceType | null => {
+  if (!name) return 'classic';
+  if (name.startsWith('MI')) return 'mini';
+  if (name.startsWith('T')) return 'touch';
+  return 'classic';
+};
+
+export const getDeviceTypeByDeviceId = (deviceId?: string): IDeviceType => {
+  if (!deviceId) {
+    return 'classic';
+  }
+
+  const miniFlag = deviceId.slice(0, 2);
+  if (miniFlag.toLowerCase() === 'mi') return 'mini';
   return 'classic';
 };
 
@@ -31,7 +61,9 @@ export const getDeviceLabel = (features: Features) => {
 /**
  * Get Connected Device version by features
  */
-export const getDeviceFirmwareVersion = (features: Features): IVersionArray => {
+export const getDeviceFirmwareVersion = (features: Features | undefined): IVersionArray => {
+  if (!features) return [0, 0, 0];
+
   if (features.onekey_version) {
     return features.onekey_version.split('.') as unknown as IVersionArray;
   }

package/src/utils/index.ts

@@ -3,7 +3,13 @@ import { initLog, enableLog } from './logger';
 export * from './assets';
 export * from './versionUtils';
 export * from './deferred';
-export { getDeviceType, getDeviceUUID, getDeviceLabel } from './deviceFeaturesUtils';
+export {
+  getDeviceType,
+  getDeviceTypeByBleName,
+  getDeviceTypeByDeviceId,
+  getDeviceUUID,
+  getDeviceLabel,
+} from './deviceFeaturesUtils';
 export { getHDPath, getScriptType } from '../api/helpers/pathUtils';
 
 export { initLog, enableLog };