@ukeyfe/hardware-core 1.1.13

package/src/types/api/starcoinGetAddress.ts

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

package/src/types/api/starcoinGetPublicKey.ts

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

package/src/types/api/starcoinSignMessage.ts

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

package/src/types/api/starcoinSignTransaction.ts

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

package/src/types/api/starcoinVerifyMessage.ts

@@ -0,0 +1,14 @@
+import { Success } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type StarcoinVerifyMessageParams = {
+  publicKey: string;
+  messageHex: string;
+  signature: string;
+};
+
+export declare function starcoinVerifyMessage(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & StarcoinVerifyMessageParams
+): Response<Success>;

package/src/types/api/stellarGetAddress.ts

@@ -0,0 +1,23 @@
+import { StellarAddress as HardwareStellarAddress } from '@ukeyfe/hardware-transport';
+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,
+  deviceId: string,
+  params: CommonParams & StellarGetAddressParams
+): Response<StellarAddress>;
+
+export declare function stellarGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: StellarGetAddressParams[] }
+): Response<Array<StellarAddress>>;

package/src/types/api/stellarSignTransaction.ts

@@ -0,0 +1,154 @@
+import { StellarSignedTx } from '@ukeyfe/hardware-transport';
+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,
+  deviceId: string,
+  params: CommonParams & StellarSignTransactionParams
+): Response<StellarSignedTx>;

package/src/types/api/suiGetAddress.ts

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

package/src/types/api/suiGetPublicKey.ts

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

package/src/types/api/suiSignMessage.ts

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

package/src/types/api/suiSignTransaction.ts

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

package/src/types/api/testInitializeDeviceDuration.ts

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

package/src/types/api/tonGetAddress.ts

@@ -0,0 +1,34 @@
+import { TonWalletVersion, TonWorkChain } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type TonAddress = {
+  path: string;
+  pub: string;
+  /**
+   * @deprecated Use `pub` instead.
+   */
+  publicKey?: string;
+  address: string;
+};
+
+export type TonGetAddressParams = {
+  path: string | number[];
+  showOnOneKey?: boolean;
+  walletVersion?: TonWalletVersion;
+  isBounceable?: boolean;
+  isTestnetOnly?: boolean;
+  workchain?: TonWorkChain;
+  walletId?: number;
+};
+
+export declare function tonGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & TonGetAddressParams
+): Response<TonAddress>;
+
+export declare function tonGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: TonGetAddressParams[] }
+): Response<Array<TonAddress>>;

package/src/types/api/tonSignMessage.ts

@@ -0,0 +1,42 @@
+import type {
+  TonSignedMessage,
+  TonWalletVersion,
+  TonWorkChain,
+  UintType,
+} from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type TonSignMessageParams = {
+  path: string | number[];
+  destination: string;
+  jettonMasterAddress?: string;
+  jettonWalletAddress?: string;
+  tonAmount: UintType;
+  jettonAmount?: UintType;
+  fwdFee?: UintType;
+  comment?: string;
+  isRawData?: boolean;
+  mode?: number;
+  seqno: number;
+  expireAt: UintType;
+  walletVersion?: TonWalletVersion;
+  walletId?: number;
+  workchain?: TonWorkChain;
+  isBounceable?: boolean;
+  isTestnetOnly?: boolean;
+  extDestination?: string[];
+  extTonAmount?: UintType[];
+  extPayload?: string[];
+  initState?: string;
+  signingMessageRepr?: string;
+};
+
+export type TonSignedMessageResponse = {
+  skip_validate: boolean;
+} & TonSignedMessage;
+
+export declare function tonSignMessage(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & TonSignMessageParams
+): Response<TonSignedMessageResponse>;

package/src/types/api/tonSignProof.ts

@@ -0,0 +1,25 @@
+import type {
+  TonSignedProof,
+  TonWalletVersion,
+  TonWorkChain,
+  UintType,
+} from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type TonSignProofParams = {
+  path: string | number[];
+  appdomain: string;
+  comment?: string;
+  expireAt: UintType;
+  walletVersion?: TonWalletVersion;
+  walletId?: number;
+  workchain?: TonWorkChain;
+  isBounceable?: boolean;
+  isTestnetOnly?: boolean;
+};
+
+export declare function tonSignProof(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & TonSignProofParams
+): Response<TonSignedProof>;

package/src/types/api/tronGetAddress.ts

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

package/src/types/api/tronSignMessage.ts

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

package/src/types/api/tronSignTransaction.ts

@@ -0,0 +1,89 @@
+import { UintType, TronSignedTx, TronResourceCode } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type TronTransferContract = {
+  toAddress?: string;
+  amount?: UintType;
+};
+
+export type TronTriggerSmartContract = {
+  contractAddress?: string;
+  callValue?: number;
+  data?: string;
+  callTokenValue?: number;
+  assetId?: number;
+};
+
+export type TronFreezeBalanceV2Contract = {
+  frozenBalance?: number;
+  resource?: TronResourceCode;
+};
+
+export type TronUnfreezeBalanceV2Contract = {
+  resource?: TronResourceCode;
+  unfreezeBalance?: number;
+};
+
+export type TronDelegateResourceContract = {
+  resource?: TronResourceCode;
+  balance?: number;
+  receiverAddress?: string;
+  lock?: boolean;
+  lockPeriod?: number;
+};
+
+export type TronUnDelegateResourceContract = {
+  resource?: TronResourceCode;
+  balance?: number;
+  receiverAddress?: string;
+};
+
+export type TronWithdrawBalanceContract = {
+  ownerAddress?: string;
+};
+
+export type TronWithdrawExpireUnfreezeContract = undefined;
+
+export type TronVoteWitnessContract = {
+  votes?: {
+    voteAddress?: string;
+    voteCount?: number;
+  }[];
+  support?: boolean;
+};
+
+export type TronCancelAllUnfreezeV2Contract = undefined;
+
+export type TronTransactionContract = {
+  transferContract?: TronTransferContract;
+  triggerSmartContract?: TronTriggerSmartContract;
+  freezeBalanceV2Contract?: TronFreezeBalanceV2Contract;
+  unfreezeBalanceV2Contract?: TronUnfreezeBalanceV2Contract;
+  cancelAllUnfreezeV2Contract?: TronCancelAllUnfreezeV2Contract;
+  delegateResourceContract?: TronDelegateResourceContract;
+  unDelegateResourceContract?: TronUnDelegateResourceContract;
+  withdrawBalanceContract?: TronWithdrawBalanceContract;
+  withdrawExpireUnfreezeContract?: TronWithdrawExpireUnfreezeContract;
+  voteWitnessContract?: TronVoteWitnessContract;
+};
+
+export type TronTransaction = {
+  refBlockBytes: string;
+  refBlockHash: string;
+  expiration: number;
+  data?: string;
+  contract: TronTransactionContract;
+  timestamp: number;
+  feeLimit?: number;
+};
+
+export type TronSignTransactionParams = {
+  path: string | number[];
+  transaction: TronTransaction;
+};
+
+export declare function tronSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & TronSignTransactionParams
+): Response<TronSignedTx>;

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/api/xrpGetAddress.ts

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

package/src/types/api/xrpSignTransaction.ts

@@ -0,0 +1,29 @@
+import type { Messages } from '@ukeyfe/hardware-transport';
+import type { CommonParams, Response } from '../params';
+
+export type XrpSignTransactionParams = Messages.RippleSignTx;
+
+export type XrpSignTransactionResponse = {
+  serializedTx: string;
+  signature: string;
+};
+
+type XrpPayment = {
+  amount: string;
+  destination: string;
+  destinationTag?: number;
+};
+
+type XrpTransaction = {
+  fee: string;
+  flags?: number;
+  sequence: number;
+  maxLedgerVersion?: number; // Proto: "last_ledger_sequence"
+  payment: XrpPayment;
+};
+
+export declare function xrpSignTransaction(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & XrpTransaction
+): Response<XrpSignTransactionResponse>;