@onekeyfe/hd-core 0.2.7 → 0.2.9

package/src/api/sui/SuiGetPublicKey.ts

@@ -0,0 +1,63 @@
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { SuiGetAddressParams } from '../../types';
+
+export default class SuiGetPublicKey extends BaseMethod<any> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: SuiGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.9.0',
+      },
+      model_touch: {
+        min: '3.5.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('BatchGetPublickeys', 'EcdsaPublicKeys', {
+      paths: this.params,
+      ecdsa_curve_name: 'ed25519',
+    });
+
+    const responses = res.message.public_keys.map((publicKey: string, index: number) => ({
+      path: serializedPath((this.params as unknown as any[])[index].address_n),
+      publicKey,
+    }));
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/sui/SuiSignTransaction.ts

@@ -0,0 +1,48 @@
+import { SuiSignTx as HardwareSuiSignTx } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { formatAnyHex } from '../helpers/hexUtils';
+
+export default class SuiSignTransaction extends BaseMethod<HardwareSuiSignTx> {
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    // check payload
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'rawTx', type: 'hexString', required: true },
+    ]);
+
+    const { path, rawTx } = this.payload;
+
+    const addressN = validatePath(path, 3);
+
+    // init params
+    this.params = {
+      address_n: addressN,
+      raw_tx: formatAnyHex(rawTx),
+    };
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.9.0',
+      },
+      model_touch: {
+        min: '3.5.0',
+      },
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('SuiSignTx', 'SuiSignedTx', {
+      ...this.params,
+    });
+
+    return Promise.resolve(res.message);
+  }
+}

package/src/core/index.ts

@@ -45,6 +45,7 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   initSession: method?.payload.initSession,
   passphraseState: method?.payload.passphraseState,
   deviceId: method?.payload.deviceId,
+  deriveCardano: method?.name.startsWith('cardano'),
 });
 
 let _core: Core;

package/src/data/messages/messages.json

@@ -1892,74 +1892,113 @@
     },
     "CardanoSignTxInit": {
       "fields": {
-        "signing_mode": {
-          "rule": "required",
-          "type": "CardanoTxSigningMode",
-          "id": 1
-        },
-        "protocol_magic": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 2
-        },
-        "network_id": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 3
-        },
-        "inputs_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 4
-        },
-        "outputs_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 5
-        },
-        "fee": {
-          "rule": "required",
-          "type": "uint64",
-          "id": 6
-        },
-        "ttl": {
-          "type": "uint64",
-          "id": 7
-        },
-        "certificates_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 8
-        },
-        "withdrawals_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 9
-        },
-        "has_auxiliary_data": {
-          "rule": "required",
-          "type": "bool",
-          "id": 10
-        },
-        "validity_interval_start": {
-          "type": "uint64",
-          "id": 11
-        },
-        "witness_requests_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 12
-        },
-        "minting_asset_groups_count": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 13
-        },
-        "derivation_type": {
-          "rule": "required",
-          "type": "CardanoDerivationType",
-          "id": 14
-        }
+          "signing_mode": {
+              "rule": "required",
+              "type": "CardanoTxSigningMode",
+              "id": 1
+          },
+          "protocol_magic": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 2
+          },
+          "network_id": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 3
+          },
+          "inputs_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 4
+          },
+          "outputs_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 5
+          },
+          "fee": {
+              "rule": "required",
+              "type": "uint64",
+              "id": 6
+          },
+          "ttl": {
+              "type": "uint64",
+              "id": 7
+          },
+          "certificates_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 8
+          },
+          "withdrawals_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 9
+          },
+          "has_auxiliary_data": {
+              "rule": "required",
+              "type": "bool",
+              "id": 10
+          },
+          "validity_interval_start": {
+              "type": "uint64",
+              "id": 11
+          },
+          "witness_requests_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 12
+          },
+          "minting_asset_groups_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 13
+          },
+          "derivation_type": {
+              "rule": "required",
+              "type": "CardanoDerivationType",
+              "id": 14
+          },
+          "include_network_id": {
+              "type": "bool",
+              "id": 15,
+              "options": {
+                  "default": false
+              }
+          },
+          "script_data_hash": {
+              "type": "bytes",
+              "id": 16
+          },
+          "collateral_inputs_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 17
+          },
+          "required_signers_count": {
+              "rule": "required",
+              "type": "uint32",
+              "id": 18
+          },
+          "has_collateral_return": {
+              "type": "bool",
+              "id": 19,
+              "options": {
+                  "default": false
+              }
+          },
+          "total_collateral": {
+              "type": "uint64",
+              "id": 20
+          },
+          "reference_inputs_count": {
+              "type": "uint32",
+              "id": 21,
+              "options": {
+                  "default": 0
+              }
+          }
       }
     },
     "CardanoTxInput": {
@@ -5591,6 +5630,52 @@
     "RebootToBootloader": {
       "fields": {}
     },
+    "RebootToBoardloader": {
+      "fields": {}
+    },
+    "ListResDir": {
+      "fields": {
+        "path": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
+    "FileInfoList": {
+      "fields": {
+        "files": {
+          "rule": "repeated",
+          "type": "FileInfo",
+          "id": 1
+        }
+      },
+      "nested": {
+        "FileInfo": {
+          "fields": {
+            "name": {
+              "rule": "required",
+              "type": "string",
+              "id": 1
+            },
+            "size": {
+              "rule": "required",
+              "type": "uint64",
+              "id": 2
+            }
+          }
+        }
+      }
+    },
+    "DeviceEraseSector": {
+      "fields": {
+        "sector": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        }
+      }
+    },
     "MoneroTransactionSourceEntry": {
       "fields": {
         "outputs": {
@@ -7724,6 +7809,61 @@
         }
       }
     },
+    "SuiGetAddress": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "show_display": {
+          "type": "bool",
+          "id": 2
+        }
+      }
+    },
+    "SuiAddress": {
+      "fields": {
+        "address": {
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
+    "SuiSignTx": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "raw_tx": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "SuiSignedTx": {
+      "fields": {
+        "public_key": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        },
+        "signature": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
     "TezosGetAddress": {
       "fields": {
         "address_n": {
@@ -8721,6 +8861,10 @@
         "MessageType_AlgorandAddress": 10901,
         "MessageType_AlgorandSignTx": 10902,
         "MessageType_AlgorandSignedTx": 10903,
+        "MessageType_SuiGetAddress": 11100,
+        "MessageType_SuiAddress": 11101,
+        "MessageType_SuiSignTx": 11102,
+        "MessageType_SuiSignedTx": 11103,
         "MessageType_DeviceBackToBoot": 903,
         "MessageType_DeviceInfoSettings": 10001,
         "MessageType_GetDeviceInfo": 10002,
@@ -8741,7 +8885,11 @@
         "MessageType_ZoomRequest": 10019,
         "MessageType_ResourceRequest": 10020,
         "MessageType_ResourceAck": 10021,
-        "MessageType_ResourceUpdate": 10022
+        "MessageType_ResourceUpdate": 10022,
+        "MessageType_ListResDir": 10023,
+        "MessageType_FileInfoList": 10024,
+        "MessageType_RebootToBoardloader": 10025,
+        "MessageType_DeviceEraseSector": 10026
       }
     },
     "google": {

package/src/device/Device.ts

@@ -32,6 +32,7 @@ export type InitOptions = {
   initSession?: boolean;
   deviceId?: string;
   passphraseState?: string;
+  deriveCardano?: boolean;
 };
 
 export type RunOptions = {
@@ -343,6 +344,10 @@ export class Device extends EventEmitter {
       payload.session_id = internalState;
     }
 
+    if (options?.deriveCardano) {
+      payload.derive_cardano = true;
+    }
+
     Log.debug('initialize payload:', payload);
 
     const { message } = await this.commands.typedCall('Initialize', 'Features', payload);

package/src/inject.ts

@@ -198,6 +198,20 @@ export const inject = ({
       call({ ...params, connectId, deviceId, method: 'xrpGetAddress' }),
     xrpSignTransaction: (connectId, deviceId, params) =>
       call({ ...params, connectId, deviceId, method: 'xrpSignTransaction' }),
+
+    suiGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'suiGetAddress' }),
+    suiGetPublicKey: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'suiGetPublicKey' }),
+    suiSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'suiSignTransaction' }),
+
+    cardanoGetAddress: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'cardanoGetAddress' }),
+    cardanoGetPublicKey: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'cardanoGetPublicKey' }),
+    cardanoSignTransaction: (connectId, deviceId, params) =>
+      call({ ...params, connectId, deviceId, method: 'cardanoSignTransaction' }),
   };
   return api;
 };

package/src/types/api/cardano.ts

@@ -0,0 +1,186 @@
+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 CardanoCertificate {
+  type: PROTO.CardanoCertificateType;
+  path?: string | number[];
+  pool?: string;
+  poolParameters?: CardanoPoolParameters;
+  scriptHash?: string;
+  keyHash?: string;
+}
+
+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;
+  // @ts-expect-error
+  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 CardanoCatalystRegistrationParameters {
+  votingPublicKey: string;
+  stakingPath: string | number[];
+  rewardAddressParameters: CardanoAddressParameters;
+  nonce: string;
+}
+
+export interface CardanoAuxiliaryData {
+  hash?: string;
+  catalystRegistrationParameters?: CardanoCatalystRegistrationParameters;
+}
+
+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;
+}
+
+export interface CardanoSignedTxWitness {
+  type: PROTO.CardanoTxWitnessType;
+  pubKey: string;
+  signature: string;
+  chainCode?: string;
+}
+
+export interface CardanoAuxiliaryDataSupplement {
+  type: PROTO.CardanoTxAuxiliaryDataSupplementType;
+  auxiliaryDataHash: string;
+  catalystSignature?: string;
+}
+
+export interface CardanoSignedTxData {
+  hash: string;
+  witnesses: CardanoSignedTxWitness[];
+  auxiliaryDataSupplement?: CardanoAuxiliaryDataSupplement;
+}