Feature/add support for nexa (#259)

huhuanming · web-flow · commit de2aa94d2fff · 2023-07-13T23:49:09.000+08:00
diff --git a/.gitignore b/.gitignore
@@ -31,3 +31,4 @@ libDev
 dist
 coverage
 build
+.history
diff --git a/packages/core/src/api/index.ts b/packages/core/src/api/index.ts
@@ -103,3 +103,6 @@ export { default as polkadotSignTransaction } from './polkadot/PolkadotSignTrans
 
 export { default as kaspaGetAddress } from './kaspa/KaspaGetAddress';
 export { default as kaspaSignTransaction } from './kaspa/KaspaSignTransaction';
+
+export { default as nexaGetAddress } from './nexa/NexaGetAddress';
+export { default as nexaSignTransaction } from './nexa/NexaSignTransaction';
diff --git a/packages/core/src/api/nexa/NexaGetAddress.ts b/packages/core/src/api/nexa/NexaGetAddress.ts
@@ -0,0 +1,82 @@
+import { NexaGetAddress as HardwareNexaGetAddress } from '@onekeyfe/hd-transport';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { NexaGetAddressParams } from '../../types';
+
+export default class NexaGetAddress extends BaseMethod<HardwareNexaGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.notAllowDeviceMode = [...this.notAllowDeviceMode, 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: NexaGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'prefix', type: 'string' },
+        { name: 'scheme', type: 'string' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        show_display: showOnOneKey,
+        prefix: batch.prefix,
+        scheme: batch.scheme,
+      });
+    });
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.2.0',
+      },
+      model_touch: {
+        min: '4.4.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: {
+      path: string;
+      pub: string;
+      address: string;
+    }[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NexaGetAddress', 'NexaAddress', {
+        ...param,
+      });
+
+      const { address } = res.message;
+
+      const result = {
+        path: serializedPath(param.address_n),
+        pub: res.message.public_key,
+        address,
+      };
+      responses.push(result);
+      this.postPreviousAddressMessage(result);
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}
diff --git a/packages/core/src/api/nexa/NexaSignTransaction.ts b/packages/core/src/api/nexa/NexaSignTransaction.ts
@@ -0,0 +1,96 @@
+import { TypedCall } from '@onekeyfe/hd-transport';
+import { TypedResponseMessage } from '../../device/DeviceCommands';
+import { validatePath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { NexaSignTransactionParams, NexaSignature } from '../../types';
+
+export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionParams> {
+  hasBundle = false;
+
+  init() {
+    const payload = this.payload as NexaSignTransactionParams;
+
+    payload.inputs.forEach(input => {
+      validateParams(input, [
+        { name: 'path', type: 'string', required: true },
+        { name: 'message', type: 'string', required: true },
+        { name: 'prefix', type: 'string', required: true },
+      ]);
+      return input;
+    });
+    this.params = payload;
+  }
+
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '3.2.0',
+      },
+      model_touch: {
+        min: '4.4.0',
+      },
+    };
+  }
+
+  async processTxRequest(
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'NexaTxInputRequest'> | TypedResponseMessage<'NexaSignedTx'>,
+    index: number,
+    signature: NexaSignature[]
+  ): Promise<NexaSignature[]> {
+    if (res.type === 'NexaSignedTx') {
+      signature.push({
+        index,
+        signature: res.message.signature,
+      });
+
+      return signature;
+    }
+
+    if (res.type === 'NexaTxInputRequest') {
+      signature.push({
+        index,
+        signature: res.message.signature ?? '',
+      });
+
+      const nextIndex = res.message.request_index;
+      const input = this.params.inputs[nextIndex];
+      const response = await typedCall(
+        'NexaTxInputAck',
+        // @ts-expect-error
+        ['NexaTxInputRequest', 'NexaSignedTx'],
+        {
+          address_n: input.path,
+          raw_message: input.message,
+        }
+      );
+
+      return this.processTxRequest(typedCall, response, nextIndex, signature);
+    }
+
+    return signature;
+  }
+
+  async run() {
+    const { device, params } = this;
+    const input = params.inputs[0];
+
+    const response = await device.commands.typedCall(
+      'NexaSignTx',
+      ['NexaTxInputRequest', 'NexaSignedTx'],
+      {
+        address_n: validatePath(input.path, 3),
+        raw_message: input.message,
+        prefix: input.prefix,
+        input_count: params.inputs.length,
+      }
+    );
+    return this.processTxRequest(
+      device.commands.typedCall.bind(device.commands),
+      response as any,
+      0,
+      []
+    );
+  }
+}
diff --git a/packages/core/src/data/messages/messages.json b/packages/core/src/data/messages/messages.json
@@ -7369,6 +7369,113 @@
         }
       }
     },
+    "NexaGetAddress": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "show_display": {
+          "type": "bool",
+          "id": 2
+        },
+        "prefix": {
+          "type": "string",
+          "id": 3,
+          "options": {
+            "default": "nexa"
+          }
+        }
+      }
+    },
+    "NexaAddress": {
+      "fields": {
+        "address": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        },
+        "public_key": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "NexaSignTx": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "raw_message": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        },
+        "prefix": {
+          "type": "string",
+          "id": 3,
+          "options": {
+            "default": "nexa"
+          }
+        },
+        "input_count": {
+          "type": "uint32",
+          "id": 4,
+          "options": {
+            "default": 1
+          }
+        }
+      }
+    },
+    "NexaTxInputRequest": {
+      "fields": {
+        "request_index": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        },
+        "signature": {
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "NexaTxInputAck": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "raw_message": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 2
+        }
+      }
+    },
+    "NexaSignedTx": {
+      "fields": {
+        "signature": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
     "PolkadotGetAddress": {
       "fields": {
         "address_n": {
@@ -9446,6 +9553,12 @@
         "MessageType_KaspaSignedTx": 11303,
         "MessageType_KaspaTxInputRequest": 11304,
         "MessageType_KaspaTxInputAck": 11305,
+        "MessageType_NexaGetAddress": 11400,
+        "MessageType_NexaAddress": 11401,
+        "MessageType_NexaSignTx": 11402,
+        "MessageType_NexaSignedTx": 11403,
+        "MessageType_NexaTxInputRequest": 11404,
+        "MessageType_NexaTxInputAck": 11405,
         "MessageType_DeviceBackToBoot": 903,
         "MessageType_DeviceInfoSettings": 10001,
         "MessageType_GetDeviceInfo": 10002,
diff --git a/packages/core/src/inject.ts b/packages/core/src/inject.ts
@@ -261,4 +261,8 @@ export const createCoreApi = (
     call({ ...params, connectId, deviceId, method: 'kaspaGetAddress' }),
   kaspaSignTransaction: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'kaspaSignTransaction' }),
+  nexaGetAddress: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'nexaGetAddress' }),
+  nexaSignTransaction: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'nexaSignTransaction' }),
 });
diff --git a/packages/core/src/types/api/export.ts b/packages/core/src/types/api/export.ts
@@ -137,3 +137,11 @@ export type {
   KaspaSignInputParams,
   KaspaSignOutputParams,
 } from './kaspaSignTransaction';
+
+export type { NexaAddress, NexaGetAddressParams } from './nexaGetAddress';
+export type {
+  NexaSignature,
+  NexaSignTransactionParams,
+  NexaSignInputParams,
+  NexaSignOutputParams,
+} from './nexaSignTransaction';
diff --git a/packages/core/src/types/api/index.ts b/packages/core/src/types/api/index.ts
@@ -108,6 +108,9 @@ import { polkadotSignTransaction } from './polkadotSignTransaction';
 import { kaspaGetAddress } from './kaspaGetAddress';
 import { kaspaSignTransaction } from './kaspaSignTransaction';
 
+import { nexaGetAddress } from './nexaGetAddress';
+import { nexaSignTransaction } from './nexaSignTransaction';
+
 export * from './export';
 
 export type CoreApi = {
@@ -290,4 +293,10 @@ export type CoreApi = {
    */
   kaspaGetAddress: typeof kaspaGetAddress;
   kaspaSignTransaction: typeof kaspaSignTransaction;
+
+  /**
+   * nexa function
+   */
+  nexaGetAddress: typeof nexaGetAddress;
+  nexaSignTransaction: typeof nexaSignTransaction;
 };
diff --git a/packages/core/src/types/api/nexaGetAddress.ts b/packages/core/src/types/api/nexaGetAddress.ts
@@ -0,0 +1,25 @@
+import { NexaAddress as HardwareNexaAddress } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type NexaAddress = {
+  path: string;
+} & HardwareNexaAddress;
+
+export type NexaGetAddressParams = {
+  path: string | number[];
+  prefix?: string;
+  scheme?: string;
+  showOnOneKey?: boolean;
+};
+
+export declare function nexaGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & NexaGetAddressParams
+): Response<NexaAddress>;
+
+export declare function nexaGetAddress(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & { bundle?: NexaGetAddressParams[] }
+): Response<Array<NexaAddress>>;
diff --git a/packages/core/src/types/api/nexaSignTransaction.ts b/packages/core/src/types/api/nexaSignTransaction.ts
diff --git a/packages/hd-transport/src/types/messages.ts b/packages/hd-transport/src/types/messages.ts
