@ocap/wallet 1.18.166 → 1.19.0

package/.eslintrc.js

@@ -0,0 +1,12 @@
+const path = require('path');
+
+module.exports = {
+  root: true,
+  extends: ['@arcblock/eslint-config-ts/base'],
+  parserOptions: {
+    project: path.resolve(__dirname, 'tsconfig.eslint.json'),
+  },
+  rules: {
+    '@typescript-eslint/comma-dangle': 'off',
+  },
+};

package/docs/README.md

@@ -0,0 +1,186 @@
+## Modules
+
+<dl>
+<dt><a href="#module_@ocap/wallet">@ocap/wallet</a></dt>
+<dd><p>This module wraps common utility functions to help developers manipulate crypto wallets</p>
+</dd>
+</dl>
+
+## Typedefs
+
+<dl>
+<dt><a href="#WalletObject">WalletObject</a></dt>
+<dd></dd>
+</dl>
+
+## @ocap/wallet
+
+This module wraps common utility functions to help developers manipulate crypto wallets
+
+**Requires**: `module:@ocap/mcrypto`, `module:@arcblock/did`\
+**Example**
+
+```js
+yarn add @ocap/wallet
+```
+
+*   [Wallet(keyPair, \[type\])](#Wallet) ⇒ [`WalletObject`](#WalletObject)
+*   [fromSecretKey(sk, \[type\])](#fromSecretKey) ⇒ [`WalletObject`](#WalletObject)
+*   [fromPublicKey(pk, \[type\])](#fromPublicKey) ⇒ [`WalletObject`](#WalletObject)
+*   [fromAddress(address)](#fromAddress) ⇒ [`WalletObject`](#WalletObject)
+*   [fromRandom(\[type\])](#fromRandom) ⇒ [`WalletObject`](#WalletObject)
+*   [fromJSON(json)](#fromJSON) ⇒ [`WalletObject`](#WalletObject)
+*   [isValid(wallet, canSign)](#isValid)
+
+### Wallet(keyPair, \[type]) ⇒ [`WalletObject`](#WalletObject)
+
+Generate an wallet instance that can be used to sign a message or verify a signature
+
+**Kind**: static method\
+**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
+**Access**: public
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| keyPair | `object` |  | the key pair |
+| keyPair.sk | `string` |  | the secretKey |
+| keyPair.pk | `string` |  | the wallet publicKey |
+| \[type] | `DidType` | `&#x27;default&#x27;` | wallet type |
+
+### fromSecretKey(sk, \[type]) ⇒ [`WalletObject`](#WalletObject)
+
+Generate a wallet from secretKey
+
+**Kind**: static method\
+**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
+**Access**: public
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| sk | `string` |  | the secret key, `hex encoded string` |
+| \[type] | `DidType` | `&#x27;default&#x27;` | wallet type |
+
+**Example**
+
+```js
+const assert = require('assert');
+const { fromSecretKey } = require('@ocap/wallet');
+
+const sk =
+  '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
+const sig =
+  '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
+
+const wallet = fromSecretKey(sk, type);
+const message = 'data to sign';
+const signature = wallet.sign(message);
+assert.equal(signature, sig, "signature should match");
+assert.ok(wallet.verify(message, signature), "signature should be verified");
+```
+
+### fromPublicKey(pk, \[type]) ⇒ [`WalletObject`](#WalletObject)
+
+Generate a wallet from publicKey
+
+**Kind**: static method\
+**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
+**Access**: public
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| pk | `string` |  | the public key, `hex encoded string` |
+| \[type] | `DidType` | `&#x27;default&#x27;` | wallet type |
+
+### fromAddress(address) ⇒ [`WalletObject`](#WalletObject)
+
+Generate a wallet from address (did)
+
+Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
+
+**Kind**: static method\
+**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
+**Access**: public
+
+| Param | Type | Description |
+| --- | --- | --- |
+| address | `string` | the wallet address |
+
+**Example**
+
+```js
+const assert = require('assert');
+const { fromAddress } = require('@ocap/wallet');
+
+const address = 'zNKtCNqYWLYWYW3gWRA1vnRykfCBZYHZvzKr';
+const wallet = fromAddress(address);
+console.log(wallet.toJSON());
+```
+
+### fromRandom(\[type]) ⇒ [`WalletObject`](#WalletObject)
+
+Generate a wallet by generating a random secretKey
+
+**Kind**: static method\
+**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
+**Access**: public
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| \[type] | `DidType` | `&#x27;default&#x27;` | wallet type |
+
+**Example**
+
+```js
+const { fromRandom } = require('@ocap/wallet');
+const wallet = fromRandom();
+// Do something with wallet
+```
+
+### fromJSON(json) ⇒ [`WalletObject`](#WalletObject)
+
+Generating a wallet from a serialized json presentation of another wallet
+
+**Kind**: static method\
+**Returns**: [`WalletObject`](#WalletObject) - wallet object that can be used to sign/verify/getAddress\
+**Access**: public
+
+| Param | Type | Description |
+| --- | --- | --- |
+| json | `object` | json presentation of a wallet |
+
+**Example**
+
+```js
+const { fromJSON, fromRandom } = require('@ocap/wallet');
+const wallet = fromRandom();
+const wallet2 = fromJSON(wallet.toJSON());
+// wallet2 is identical to wallet
+```
+
+### isValid(wallet, canSign)
+
+Check if an object is valid wallet object
+
+**Kind**: static method\
+**Access**: public
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| wallet | `object` |  |  |
+| canSign | `boolean` | `true` | should the wallet support sign |
+
+## WalletObject
+
+**Kind**: global typedef\
+**Access**: public\
+**Properties**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| type | `DidType` | Indicates the wallet type |
+| secretKey | `secretKey` | Wallet secretKey |
+| publicKey | `publicKey` | Wallet publicKey |
+| sign | `function` | Sign `data`, data is hashed using the `HashType` defined in type before signing |
+| verify | `function` | Verify `signature`, data is hashed using the `HashType` defined in type before verifying |
+| toAddress | `function` | Get wallet address without `did:abt:` prefix |
+| toJSON | `function` | Serialize wallet to json object, checkout [fromJSON](fromJSON) for deserialisation |

package/jest.config.js

@@ -0,0 +1,7 @@
+const base = require('../../jest.config.base');
+
+module.exports = {
+  ...base,
+  preset: 'ts-jest',
+  collectCoverageFrom: ['<rootDir>/core/wallet/src/*.ts', '<rootDir>/core/wallet/src/**/*.ts'],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocap/wallet",
-  "version": "1.18.166",
+  "version": "1.19.0",
   "description": "Utility function to create and use an forge compatible crypto wallet",
   "keywords": [
     "crypto",
@@ -20,19 +20,24 @@
   ],
   "homepage": "https://github.com/ArcBlock/blockchain/tree/master/core/forge-wallet",
   "license": "Apache-2.0",
-  "main": "lib/index.js",
-  "typings": "lib/index.d.ts",
-  "files": [
-    "lib"
-  ],
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./lib/index.js",
+      "default": "./esm/index.js"
+    }
+  },
   "devDependencies": {
-    "@arcblock/eslint-config-ts": "0.2.3",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^17.0.45",
-    "eslint": "^8.25.0",
+    "@arcblock/eslint-config-ts": "0.3.3",
+    "@types/jest": "^29.5.13",
+    "@types/node": "^22.7.5",
+    "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
-    "typescript": "^4.8.4"
+    "typescript": "^5.6.2"
   },
   "repository": {
     "type": "git",
@@ -43,18 +48,20 @@
     "lint:fix": "eslint --fix tests src",
     "test": "jest --forceExit --detectOpenHandles",
     "coverage": "npm run test -- --coverage",
-    "clean": "rm -fr lib",
+    "clean": "rm -fr lib esm",
     "prebuild": "npm run clean",
-    "build": "tsc",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build": "npm run build:cjs && npm run build:esm",
     "build:watch": "npm run build -- -w"
   },
   "bugs": {
     "url": "https://github.com/ArcBlock/blockchain/issues"
   },
   "dependencies": {
-    "@arcblock/did": "1.18.166",
-    "@ocap/mcrypto": "1.18.166",
-    "@ocap/util": "1.18.166"
+    "@arcblock/did": "1.19.0",
+    "@ocap/mcrypto": "1.19.0",
+    "@ocap/util": "1.19.0"
   },
-  "gitHead": "58c8356b3b8c238728560e4c3fef6ed1704d3ac4"
+  "gitHead": "1b6fac03988fb18507c8ef4c21de282762005f87"
 }

package/src/index.ts

@@ -0,0 +1,235 @@
+import { toHex, EncodingType, BytesType } from '@ocap/util';
+import { getSigner, getHasher } from '@ocap/mcrypto';
+import {
+  toAddress,
+  fromPublicKey as DIDFromPublicKey,
+  toTypeInfo,
+  DidType,
+  DIDType,
+  DIDTypeStr,
+  DIDTypeArg,
+} from '@arcblock/did';
+
+type KeyPairType<T extends BytesType = string> = {
+  sk?: T;
+  pk?: T;
+  address?: string;
+};
+
+export type SerializedWallet = {
+  type: DIDTypeStr;
+  pk: string;
+  sk: string;
+  address: string;
+};
+
+export interface WalletObject<T extends BytesType = string> {
+  type: DIDType;
+  secretKey: T;
+  publicKey: T;
+  address: string;
+
+  hash(data: BytesType, round?: number, encoding?: 'hex'): string;
+  hash(data: BytesType, round?: number, encoding?: 'base16'): string;
+  hash(data: BytesType, round?: number, encoding?: 'base58'): string;
+  hash(data: BytesType, round?: number, encoding?: 'base64'): string;
+  hash(data: BytesType, round?: number, encoding?: 'buffer'): Buffer;
+  hash(data: BytesType, round?: number, encoding?: 'Uint8Array'): Uint8Array;
+  hash(data: BytesType, round?: number, encoding?: EncodingType): BytesType;
+
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'hex'): string;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base16'): string;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base58'): string;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base64'): string;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'buffer'): Buffer;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Uint8Array;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: EncodingType): BytesType;
+
+  verify(data: BytesType, signature: BytesType, hashBeforeVerify?: boolean, extra?: any): Promise<boolean>;
+
+  ethHash(data: string): string;
+  ethSign(data: string, hashBeforeSign?: boolean): string;
+  ethVerify(data: string, signature: string, hashBeforeVerify?: boolean): boolean;
+
+  toJSON(): SerializedWallet;
+
+  /**
+   * @deprecated ES6: use `wallet.address` instead
+   */
+  toAddress(): string;
+}
+
+export const WalletType = DidType;
+
+/**
+ * Generate an wallet instance that can be used to sign a message or verify a signature
+ */
+export function Wallet<T extends BytesType = string>(
+  keyPair: KeyPairType<T>,
+  t: DIDTypeArg = 'default'
+): WalletObject<T> {
+  const type = DidType(t);
+  const signer = getSigner(type.pk);
+  const hasher = getHasher(type.hash);
+  return {
+    type,
+    secretKey: keyPair.sk,
+    publicKey: keyPair.pk,
+    address: keyPair.pk ? DIDFromPublicKey(keyPair.pk, type) : keyPair.address,
+
+    // @ts-ignore
+    hash(data: BytesType, round = 1, encoding: EncodingType = 'hex'): BytesType {
+      return hasher(data, round, encoding);
+    },
+
+    // @ts-ignore
+    sign(data: BytesType, hashBeforeSign = true, encoding: EncodingType = 'hex'): BytesType {
+      if (!keyPair.sk) {
+        throw new Error('Cannot sign data without a secretKey');
+      }
+      if (hashBeforeSign) {
+        const hash = hasher(data, 1);
+        return signer.sign(hash, keyPair.sk, encoding);
+      }
+      return signer.sign(data, keyPair.sk, encoding);
+    },
+
+    // eslint-disable-next-line require-await
+    async verify(data: BytesType, signature: BytesType, hashBeforeVerify = true, extra?: any): Promise<boolean> {
+      if (!keyPair.pk) {
+        throw new Error('Cannot verify data without a publicKey');
+      }
+      const hash = hashBeforeVerify ? hasher(data, 1) : data;
+      return signer.verify(hash, signature, keyPair.pk, extra);
+    },
+
+    ethHash(data: string): string {
+      if (typeof signer.ethHash !== 'function') {
+        throw new Error('ethHash is not supported by signer');
+      }
+      return signer.ethHash(data);
+    },
+    ethSign(data: string, hashBeforeSign = true): string {
+      if (!keyPair.sk) {
+        throw new Error('Cannot sign data without a secretKey');
+      }
+      if (typeof signer.ethHash !== 'function') {
+        throw new Error('ethSign is not supported by signer');
+      }
+      if (hashBeforeSign) {
+        return signer.ethSign(signer.ethHash(data), toHex(keyPair.sk));
+      }
+      return signer.ethSign(data, toHex(keyPair.sk));
+    },
+    ethVerify(data: string, signature: string, hashBeforeVerify = true): boolean {
+      if (typeof signer.ethHash !== 'function') {
+        throw new Error('ethVerify is not supported by signer');
+      }
+      const hash = hashBeforeVerify ? signer.ethHash(data) : data;
+      return signer.ethRecover(hash, signature) === this.address;
+    },
+
+    // deprecated
+    toAddress(): string {
+      return keyPair.pk ? DIDFromPublicKey(keyPair.pk, type) : keyPair.address;
+    },
+
+    toJSON(): SerializedWallet {
+      return {
+        type: DidType.toJSON(type),
+        sk: toHex(keyPair.sk),
+        pk: toHex(keyPair.pk),
+        address: this.address,
+      };
+    },
+  };
+}
+
+/**
+ * Generate a wallet from secretKey
+ *
+ * @example
+ * const assert = require('assert');
+ * const { fromSecretKey } = require('@ocap/wallet');
+ *
+ * const sk =
+ *   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
+ * const sig =
+ *   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
+ *
+ * const wallet = fromSecretKey(sk, type);
+ * const message = 'data to sign';
+ * const signature = wallet.sign(message);
+ * assert.equal(signature, sig, "signature should match");
+ * assert.ok(wallet.verify(message, signature), "signature should be verified");
+ */
+export function fromSecretKey<T extends BytesType = string>(sk: T, _type: DIDTypeArg = 'default'): WalletObject<T> {
+  const type = DidType(_type);
+  const keyPair = { sk, pk: getSigner(type.pk).getPublicKey(sk) as T };
+  return Wallet<T>(keyPair, type);
+}
+
+/**
+ * Generate a wallet from publicKey
+ */
+export function fromPublicKey<T extends BytesType = string>(pk: T, _type: DIDTypeArg = 'default'): WalletObject<T> {
+  return Wallet<T>({ pk }, DidType(_type));
+}
+
+/**
+ * Generate a wallet from address (did)
+ *
+ * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
+ */
+export function fromAddress<T extends BytesType = string>(address: string): WalletObject<T> {
+  return Wallet<T>({ address: toAddress(address) }, toTypeInfo(address));
+}
+
+/**
+ * Generate a wallet by generating a random secretKey
+ */
+export function fromRandom<T extends BytesType = string>(_type: DIDTypeArg = 'default'): WalletObject<T> {
+  const type = DidType(_type);
+  const signer = getSigner(type.pk);
+  const keyPair = signer.genKeyPair();
+  return Wallet<T>({ sk: keyPair.secretKey as T, pk: keyPair.publicKey as T }, type);
+}
+
+/**
+ * Generating a wallet from a serialized json presentation of another wallet
+ */
+export function fromJSON<T extends BytesType = string>(json: SerializedWallet): WalletObject<T> {
+  const type = DidType.fromJSON(json.type);
+  // @ts-ignore
+  return Wallet<T>(json, type);
+}
+
+/**
+ * Check if an object is valid wallet object
+ */
+export function isValid(wallet: WalletObject, canSign = true): boolean {
+  if (!wallet || typeof wallet !== 'object') {
+    return false;
+  }
+  if (typeof wallet.verify !== 'function') {
+    return false;
+  }
+  if (typeof wallet.toAddress !== 'function') {
+    return false;
+  }
+  if (typeof wallet.toJSON !== 'function') {
+    return false;
+  }
+  if (!wallet.type || !wallet.publicKey) {
+    return false;
+  }
+  if (canSign) {
+    if (!wallet.secretKey) {
+      return false;
+    }
+    if (typeof wallet.sign !== 'function') {
+      return false;
+    }
+  }
+  return true;
+}

package/tests/index.spec.ts

@@ -0,0 +1,116 @@
+import { types } from '@ocap/mcrypto';
+import { fromBase64 } from '@ocap/util';
+import { fromRandom, fromPublicKey, fromSecretKey, fromJSON, fromAddress, isValid } from '../src/index';
+
+const sk =
+  '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
+const pk = '0xE4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
+const appId = 'zNKtCNqYWLYWYW3gWRA1vnRykfCBZYHZvzKr';
+const sig =
+  '0x8122c608f61b04f6b574f005dc8e0463d393a7fb50e0426bca587b20778a8a9f6376bab87bc3983b0a5f1c9581f6d94162317c715a3c1c0f086be1e514399109';
+const type = {
+  role: types.RoleType.ROLE_APPLICATION,
+  pk: types.KeyType.ED25519,
+  hash: types.HashType.SHA3,
+  address: types.EncodingType.BASE58,
+};
+describe('#Wallet', () => {
+  test('should have basic functions', () => {
+    expect(typeof fromPublicKey).toEqual('function');
+    expect(typeof fromSecretKey).toEqual('function');
+    expect(typeof fromJSON).toEqual('function');
+  });
+
+  test('should serialize to json as expected', () => {
+    const wallet = fromPublicKey(pk, type);
+    const json = wallet.toJSON();
+    expect(json.address).toEqual(appId);
+    const wallet2 = fromJSON(json);
+    expect(wallet2.address).toEqual(appId);
+    expect(wallet2.address).toEqual(appId);
+  });
+
+  test('should throw error when sign without sk', () => {
+    const wallet = fromPublicKey(pk, type);
+    const hash = wallet.hash('abc');
+    expect(hash).toEqual('0x3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532');
+    try {
+      wallet.sign('data to sign');
+    } catch (err) {
+      expect(err).toBeTruthy();
+    }
+  });
+
+  test('should sign when sk is provided', async () => {
+    const wallet = fromSecretKey(sk, type);
+    const hash = wallet.hash('abc');
+    expect(hash).toEqual('0x3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532');
+    const message = 'data to sign';
+    const signature = wallet.sign(message);
+    expect(signature).toEqual(sig);
+    expect(await wallet.verify(message, signature)).toEqual(true);
+    expect(() => fromSecretKey('abc')).toThrow();
+  });
+
+  test('should gen type from address', () => {
+    const wallet = fromAddress(appId);
+    expect(wallet.type.pk).toEqual(type.pk);
+    expect(wallet.type.hash).toEqual(type.hash);
+    expect(wallet.type.role).toEqual(type.role);
+  });
+
+  test('should detect invalid wallets', () => {
+    const wallet = fromRandom();
+    expect(isValid(wallet)).toEqual(true);
+    const wallet2 = fromPublicKey(pk, type);
+    expect(isValid(wallet2, false)).toEqual(true);
+  });
+
+  test('should generate base58 address', () => {
+    const wallet = fromRandom();
+    expect(wallet.toAddress().startsWith('z')).toBeTruthy();
+    expect(wallet.address.startsWith('z')).toBeTruthy();
+    expect(() => wallet.ethHash('abc')).toThrow();
+    expect(() => wallet.ethSign('abc')).toThrow();
+  });
+
+  test('should generate base16 address', () => {
+    const wallet = fromRandom('eth');
+    expect(wallet.address.startsWith('0x')).toBeTruthy();
+  });
+
+  test('should work with ethereum', async () => {
+    // eslint-disable-next-line
+    const sk = '0xfe51dc1dfe30e2f4b06f7941bdfe0341704c10e28d28e4ecd7871f8f0204fa33';
+    const address = '0x5547a73ed3c2Ad599114866fA1d5E8a02147D1C9';
+    const data = '0xef56b956483ebe2fa8ed6c35c8b884d940d57fdf535a70a2df245661c9cf42e4';
+    // eslint-disable-next-line
+    const sig = '0x242ad32e16c38307e2909600cb641da17734121d9d50df93b6240db40ad3fc2d562f3e41cc6409730cbb81c5bc90a914f24baf0d3537a7db8334dc67ed2000fe1c'; // prettier-ignore
+    const wallet = fromSecretKey(sk, 'eth');
+    expect(wallet.address).toEqual(address);
+    expect(wallet.ethSign(data)).toEqual(sig);
+    expect(wallet.ethHash(data)).toEqual('0x9f5dc66bef3e8053b02c4cb6a8504cb4d7e48862245a4d34fc69bc615080d276');
+    expect(await wallet.ethVerify(data, sig)).toEqual(true);
+    expect(() => fromSecretKey('abc', 'eth')).toThrow();
+  });
+
+  test('should work with passkey', async () => {
+    const publicKey = fromBase64(
+      'pQECAyYgASFYIA3GyM4rSxM_HyV52QTRwGJOdkXurky3cwTLvb_gKSF-Ilggpd0fhMlPdxHBl45_eJxqywCRl-a4IDpeFa4pcfmrxuM'
+    );
+
+    const wallet = fromPublicKey(publicKey, 'passkey');
+    expect(wallet.address).toEqual('z3i165rPumFgyQZpZ1W3VLEYBPuV2xSCAjoqo');
+
+    const challenge = '0x7E093B990CB41A97990657D6AD688BD4E28267C9FCC0A36BC15D241D5D302CEF';
+    const response = {
+      authenticatorData: 'u_rJjitfFaLnT_p0uECHZ0CSuRQE7psYSUxv2p-nql0dAAAAAA',
+      clientDataJSON:
+        'eyJ0eXBlIjoid2ViYXV0aG4uZ2V0IiwiY2hhbGxlbmdlIjoiZmdrN21ReTBHcGVaQmxmV3JXaUwxT0tDWjhuOHdLTnJ3VjBrSFYwd0xPOCIsIm9yaWdpbiI6Imh0dHBzOi8vYmJxYXhlN2lhZGZpbWRkY2c0cmZycHRmdXp4bW12NWI2dnBudXB1bmk0NC5kaWQuYWJ0bmV0LmlvIiwiY3Jvc3NPcmlnaW4iOmZhbHNlfQ',
+      signature: 'MEUCIQCo51Gg_3UrSotxrguG92iXcuSbW5fNZqcSsHS8zlZbdAIgEmaBD0cQeiML3Mr60HSPP176EyqNvqfTdEV1oGWhQ-o',
+    };
+
+    const verified = await wallet.verify(challenge, response.signature, false, JSON.stringify(response));
+    expect(verified).toEqual(true);
+  });
+});

package/tsconfig.cjs.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src"],
+  "exclude": ["node_modules", "tests"],
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "lib"
+  }
+}

package/tsconfig.eslint.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src", "tests", ".eslintrc.js", "jest.config.js"]
+}

package/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src"],
+  "exclude": ["node_modules", "tests"],
+  "compilerOptions": {
+    "module": "esnext",
+    "outDir": "esm"
+  }
+}

package/lib/index.d.ts

@@ -1,90 +0,0 @@
-/// <reference types="node" />
-import { EncodingType, BytesType } from '@ocap/util';
-import { DidType, DIDType, DIDTypeStr, DIDTypeArg } from '@arcblock/did';
-declare type KeyPairType<T extends BytesType = string> = {
-    sk?: T;
-    pk?: T;
-    address?: string;
-};
-export declare type SerializedWallet = {
-    type: DIDTypeStr;
-    pk: string;
-    sk: string;
-    address: string;
-};
-export interface WalletObject<T extends BytesType = string> {
-    type: DIDType;
-    secretKey: T;
-    publicKey: T;
-    address: string;
-    hash(data: BytesType, round?: number, encoding?: 'hex'): string;
-    hash(data: BytesType, round?: number, encoding?: 'base16'): string;
-    hash(data: BytesType, round?: number, encoding?: 'base58'): string;
-    hash(data: BytesType, round?: number, encoding?: 'base64'): string;
-    hash(data: BytesType, round?: number, encoding?: 'buffer'): Buffer;
-    hash(data: BytesType, round?: number, encoding?: 'Uint8Array'): Uint8Array;
-    hash(data: BytesType, round?: number, encoding?: EncodingType): BytesType;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'hex'): string;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base16'): string;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base58'): string;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base64'): string;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'buffer'): Buffer;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Uint8Array;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: EncodingType): BytesType;
-    verify(data: BytesType, signature: BytesType, hashBeforeVerify?: boolean): boolean;
-    ethHash(data: string): string;
-    ethSign(data: string, hashBeforeSign?: boolean): string;
-    ethVerify(data: string, signature: string, hashBeforeVerify?: boolean): boolean;
-    toJSON(): SerializedWallet;
-    /**
-     * @deprecated ES6: use `wallet.address` instead
-     */
-    toAddress(): string;
-}
-export declare const WalletType: typeof DidType;
-/**
- * Generate an wallet instance that can be used to sign a message or verify a signature
- */
-export declare function Wallet<T extends BytesType = string>(keyPair: KeyPairType<T>, t?: DIDTypeArg): WalletObject<T>;
-/**
- * Generate a wallet from secretKey
- *
- * @example
- * const assert = require('assert');
- * const { fromSecretKey } = require('@ocap/wallet');
- *
- * const sk =
- *   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
- * const sig =
- *   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
- *
- * const wallet = fromSecretKey(sk, type);
- * const message = 'data to sign';
- * const signature = wallet.sign(message);
- * assert.equal(signature, sig, "signature should match");
- * assert.ok(wallet.verify(message, signature), "signature should be verified");
- */
-export declare function fromSecretKey<T extends BytesType = string>(sk: T, _type?: DIDTypeArg): WalletObject<T>;
-/**
- * Generate a wallet from publicKey
- */
-export declare function fromPublicKey<T extends BytesType = string>(pk: T, _type?: DIDTypeArg): WalletObject<T>;
-/**
- * Generate a wallet from address (did)
- *
- * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
- */
-export declare function fromAddress<T extends BytesType = string>(address: string): WalletObject<T>;
-/**
- * Generate a wallet by generating a random secretKey
- */
-export declare function fromRandom<T extends BytesType = string>(_type?: DIDTypeArg): WalletObject<T>;
-/**
- * Generating a wallet from a serialized json presentation of another wallet
- */
-export declare function fromJSON<T extends BytesType = string>(json: SerializedWallet): WalletObject<T>;
-/**
- * Check if an object is valid wallet object
- */
-export declare function isValid(wallet: WalletObject, canSign?: boolean): boolean;
-export {};

package/lib/index.js

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValid = exports.fromJSON = exports.fromRandom = exports.fromAddress = exports.fromPublicKey = exports.fromSecretKey = exports.Wallet = exports.WalletType = void 0;
-const util_1 = require("@ocap/util");
-const mcrypto_1 = require("@ocap/mcrypto");
-const did_1 = require("@arcblock/did");
-exports.WalletType = did_1.DidType;
-/**
- * Generate an wallet instance that can be used to sign a message or verify a signature
- */
-function Wallet(keyPair, t = 'default') {
-    const type = (0, did_1.DidType)(t);
-    const signer = (0, mcrypto_1.getSigner)(type.pk);
-    const hasher = (0, mcrypto_1.getHasher)(type.hash);
-    return {
-        type,
-        secretKey: keyPair.sk,
-        publicKey: keyPair.pk,
-        address: keyPair.pk ? (0, did_1.fromPublicKey)(keyPair.pk, type) : keyPair.address,
-        // @ts-ignore
-        hash(data, round = 1, encoding = 'hex') {
-            return hasher(data, round, encoding);
-        },
-        // @ts-ignore
-        sign(data, hashBeforeSign = true, encoding = 'hex') {
-            if (!keyPair.sk) {
-                throw new Error('Cannot sign data without a secretKey');
-            }
-            if (hashBeforeSign) {
-                const hash = hasher(data, 1);
-                return signer.sign(hash, keyPair.sk, encoding);
-            }
-            return signer.sign(data, keyPair.sk, encoding);
-        },
-        verify(data, signature, hashBeforeVerify = true) {
-            if (!keyPair.pk) {
-                throw new Error('Cannot verify data without a publicKey');
-            }
-            const hash = hashBeforeVerify ? hasher(data, 1) : data;
-            return signer.verify(hash, signature, keyPair.pk);
-        },
-        ethHash(data) {
-            if (typeof signer.ethHash !== 'function') {
-                throw new Error('ethHash is not supported by signer');
-            }
-            return signer.ethHash(data);
-        },
-        ethSign(data, hashBeforeSign = true) {
-            if (!keyPair.sk) {
-                throw new Error('Cannot sign data without a secretKey');
-            }
-            if (typeof signer.ethHash !== 'function') {
-                throw new Error('ethSign is not supported by signer');
-            }
-            if (hashBeforeSign) {
-                return signer.ethSign(signer.ethHash(data), (0, util_1.toHex)(keyPair.sk));
-            }
-            return signer.ethSign(data, (0, util_1.toHex)(keyPair.sk));
-        },
-        ethVerify(data, signature, hashBeforeVerify = true) {
-            if (typeof signer.ethHash !== 'function') {
-                throw new Error('ethVerify is not supported by signer');
-            }
-            const hash = hashBeforeVerify ? signer.ethHash(data) : data;
-            return signer.ethRecover(hash, signature) === this.address;
-        },
-        // deprecated
-        toAddress() {
-            return keyPair.pk ? (0, did_1.fromPublicKey)(keyPair.pk, type) : keyPair.address;
-        },
-        toJSON() {
-            return {
-                type: did_1.DidType.toJSON(type),
-                sk: (0, util_1.toHex)(keyPair.sk),
-                pk: (0, util_1.toHex)(keyPair.pk),
-                address: this.address,
-            };
-        },
-    };
-}
-exports.Wallet = Wallet;
-/**
- * Generate a wallet from secretKey
- *
- * @example
- * const assert = require('assert');
- * const { fromSecretKey } = require('@ocap/wallet');
- *
- * const sk =
- *   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
- * const sig =
- *   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
- *
- * const wallet = fromSecretKey(sk, type);
- * const message = 'data to sign';
- * const signature = wallet.sign(message);
- * assert.equal(signature, sig, "signature should match");
- * assert.ok(wallet.verify(message, signature), "signature should be verified");
- */
-function fromSecretKey(sk, _type = 'default') {
-    const type = (0, did_1.DidType)(_type);
-    const keyPair = { sk, pk: (0, mcrypto_1.getSigner)(type.pk).getPublicKey(sk) };
-    return Wallet(keyPair, type);
-}
-exports.fromSecretKey = fromSecretKey;
-/**
- * Generate a wallet from publicKey
- */
-function fromPublicKey(pk, _type = 'default') {
-    return Wallet({ pk }, (0, did_1.DidType)(_type));
-}
-exports.fromPublicKey = fromPublicKey;
-/**
- * Generate a wallet from address (did)
- *
- * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
- */
-function fromAddress(address) {
-    return Wallet({ address: (0, did_1.toAddress)(address) }, (0, did_1.toTypeInfo)(address));
-}
-exports.fromAddress = fromAddress;
-/**
- * Generate a wallet by generating a random secretKey
- */
-function fromRandom(_type = 'default') {
-    const type = (0, did_1.DidType)(_type);
-    const signer = (0, mcrypto_1.getSigner)(type.pk);
-    const keyPair = signer.genKeyPair();
-    return Wallet({ sk: keyPair.secretKey, pk: keyPair.publicKey }, type);
-}
-exports.fromRandom = fromRandom;
-/**
- * Generating a wallet from a serialized json presentation of another wallet
- */
-function fromJSON(json) {
-    const type = did_1.DidType.fromJSON(json.type);
-    // @ts-ignore
-    return Wallet(json, type);
-}
-exports.fromJSON = fromJSON;
-/**
- * Check if an object is valid wallet object
- */
-function isValid(wallet, canSign = true) {
-    if (!wallet || typeof wallet !== 'object') {
-        return false;
-    }
-    if (typeof wallet.verify !== 'function') {
-        return false;
-    }
-    if (typeof wallet.toAddress !== 'function') {
-        return false;
-    }
-    if (typeof wallet.toJSON !== 'function') {
-        return false;
-    }
-    if (!wallet.type || !wallet.publicKey) {
-        return false;
-    }
-    if (canSign) {
-        if (!wallet.secretKey) {
-            return false;
-        }
-        if (typeof wallet.sign !== 'function') {
-            return false;
-        }
-    }
-    return true;
-}
-exports.isValid = isValid;