@ocap/wallet 1.16.16 → 1.17.1

package/lib/index.d.ts

@@ -1,43 +1,50 @@
-// Generate by [js2dts@0.3.3](https://github.com/whxaxes/js2dts#readme)
-
-/**
- * The structure of a forge wallet type
- *
- * @public
- * @static
- * @global
- * @typedef {Object} DidType
- * @prop {number} role - Enum field to identify wallet role type
- * @prop {number} pk - Crypto algorithm to derive publicKey from the secretKey
- * @prop {number} hash - Hash algorithm used to hash data before sign them
- */
-
+import { BytesType } from '@ocap/util';
+import { DidType, DIDType, DIDTypeStr, DIDTypeArg } from '@arcblock/did';
+declare type KeyPairType = {
+    sk?: BytesType;
+    pk?: BytesType;
+    address?: string;
+};
+export declare type SerializedWallet = {
+    type: DIDTypeStr;
+    pk: string;
+    sk: string;
+    address: string;
+};
+export declare type WalletObject = {
+    type: DIDType;
+    secretKey: BytesType;
+    publicKey: BytesType;
+    address: string;
+    hash: (data: BytesType, round?: number) => string;
+    sign: (data: BytesType, hashBeforeSign?: boolean) => BytesType;
+    verify: (data: BytesType, signature: BytesType, hashBeforeVerify?: boolean) => boolean;
+    ethHash: (data: string) => string;
+    ethSign: (data: string, hashBeforeSign?: boolean) => string;
+    ethVerify: (data: string, signature: BytesType, hashBeforeVerify?: boolean) => boolean;
+    toAddress: () => string;
+    toJSON: () => SerializedWallet;
+};
+export declare const WalletType: typeof DidType;
 /**
- * Create an wallet type object that be used as param to create a new wallet
+ * Generate an wallet instance that can be used to sign a message or verify a signature
  *
  * @public
  * @static
- * @param {DidType|string} [type='default']
- * @returns {object}
- * @example
- * const assert = require('assert');
- * const { DidType } = require('@arcblock/did');
- * const { types } = require('@ocap/mcrypto');
- *
- * const type = DidType({
- *   role: types.RoleType.ROLE_APPLICATION,
- *   pk: types.KeyType.ED25519,
- *   hash: types.HashType.SHA3,
- * });
+ * @param {object} keyPair - the key pair
+ * @param {string} keyPair.sk - the secretKey
+ * @param {string} keyPair.pk - the wallet publicKey
+ * @param {DIDTypeArg} [type='default'] - wallet type
+ * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
  */
-declare function DidType(type?: DidType | string): object;
+export declare function Wallet(keyPair: KeyPairType, t?: DIDTypeArg): WalletObject;
 /**
  * Generate a wallet from secretKey
  *
  * @public
  * @static
  * @param {string} sk - the secret key, `hex encoded string`
- * @param {DidType} [type='default'] - wallet type
+ * @param {DIDTypeArg} [type='default'] - wallet type
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
  * @example
  * const assert = require('assert');
@@ -54,30 +61,17 @@ declare function DidType(type?: DidType | string): object;
  * assert.equal(signature, sig, "signature should match");
  * assert.ok(wallet.verify(message, signature), "signature should be verified");
  */
-declare function fromSecretKey(sk: string, _type?: string): WalletObject;
+export declare function fromSecretKey(sk: BytesType, _type?: DIDTypeArg): WalletObject;
 /**
  * Generate a wallet from publicKey
  *
  * @public
  * @static
  * @param {string} pk - the public key, `hex encoded string`
- * @param {DidType} [type='default'] - wallet type
- * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- */
-declare function fromPublicKey(pk: string, _type?: string): WalletObject;
-/**
- * Generate a wallet by generating a random secretKey
- *
- * @public
- * @static
- * @param {DidType} [type='default'] - wallet type
+ * @param {DIDTypeArg} [type='default'] - wallet type
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- * @example
- * const { fromRandom } = require('@ocap/wallet');
- * const wallet = fromRandom();
- * // Do something with wallet
  */
-declare function fromRandom(_type?: string): WalletObject;
+export declare function fromPublicKey(pk: BytesType, _type?: DIDTypeArg): WalletObject;
 /**
  * Generate a wallet from address (did)
  *
@@ -87,29 +81,21 @@ declare function fromRandom(_type?: string): WalletObject;
  * @static
  * @param {string} address - the wallet address
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- * @example
- * const assert = require('assert');
- * const { fromAddress } = require('@ocap/wallet');
- *
- * const address = 'zNKtCNqYWLYWYW3gWRA1vnRykfCBZYHZvzKr';
- * const wallet = fromAddress(address);
- * console.log(wallet.toJSON());
  */
-declare function fromAddress(address: string): WalletObject;
+export declare function fromAddress(address: string): WalletObject;
 /**
- * Generating a wallet from a serialized json presentation of another wallet
+ * Generate a wallet by generating a random secretKey
  *
  * @public
  * @static
- * @param {object} json - json presentation of a wallet
+ * @param {DIDTypeArg} [type='default'] - wallet type
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- * @example
- * const { fromJSON, fromRandom } = require('@ocap/wallet');
- * const wallet = fromRandom();
- * const wallet2 = fromJSON(wallet.toJSON());
- * // wallet2 is identical to wallet
  */
-declare function fromJSON(json: any): WalletObject;
+export declare function fromRandom(_type?: DIDTypeArg): WalletObject;
+/**
+ * Generating a wallet from a serialized json presentation of another wallet
+ */
+export declare function fromJSON(json: SerializedWallet): WalletObject;
 /**
  * Check if an object is valid wallet object
  *
@@ -118,60 +104,5 @@ declare function fromJSON(json: any): WalletObject;
  * @param {object} wallet
  * @param {boolean} canSign - should the wallet support sign
  */
-declare function isValid(wallet: any, canSign?: boolean): boolean;
-/**
- * @public
- * @static
- * @global
- * @name WalletObject
- * @typedef WalletObject
- * @prop {DidType} type - Indicates the wallet type
- * @prop {secretKey} secretKey - Wallet secretKey
- * @prop {publicKey} publicKey - Wallet publicKey
- * @prop {function} sign - Sign `data`, data is hashed using the `HashType` defined in type before signing
- * @prop {function} verify - Verify `signature`, data is hashed using the `HashType` defined in type before verifying
- * @prop {function} toAddress - Get wallet address without `did:abt:` prefix
- * @prop {function} toJSON - Serialize wallet to json object, checkout {@link fromJSON} for deserialisation
- */
-
-/**
- * Generate an wallet instance that can be used to sign a message or verify a signature
- *
- * @public
- * @static
- * @param {object} keyPair - the key pair
- * @param {string} keyPair.sk - the secretKey
- * @param {string} keyPair.pk - the wallet publicKey
- * @param {DidType} [type='default'] - wallet type
- * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- */
-declare function Wallet(keyPair: _Lib.T100, type?: typeof DidType): WalletObject;
-declare const _Lib: _Lib.T101;
-declare namespace _Lib {
-  export interface WalletObject {
-    type: typeof DidType;
-    secretKey: any;
-    publicKey: any;
-    sign: (...args: any[]) => any;
-    verify: (...args: any[]) => any;
-    toAddress: (...args: any[]) => any;
-    toJSON: (...args: any[]) => any;
-  }
-  export interface T100 {
-    sk: string;
-    pk: string;
-  }
-  export interface T101 {
-    fromSecretKey: typeof fromSecretKey;
-    fromPublicKey: typeof fromPublicKey;
-    fromRandom: typeof fromRandom;
-    fromAddress: typeof fromAddress;
-    fromDID: typeof fromAddress;
-    fromJSON: typeof fromJSON;
-    isValid: typeof isValid;
-    Wallet: typeof Wallet;
-    WalletType: typeof DidType;
-    DidType: typeof DidType;
-  }
-}
-export = _Lib;
+export declare function isValid(wallet: WalletObject, canSign?: boolean): boolean;
+export {};

package/lib/index.js

@@ -1,29 +1,10 @@
-/**
- * @fileOverview This module wraps common utility functions to help developers manipulate crypto wallets
- * @module @ocap/wallet
- * @requires @ocap/mcrypto
- * @requires @arcblock/did
- * @example
- * yarn add @ocap/wallet
- */
-const { getSigner, getHasher } = require('@ocap/mcrypto');
-const { toAddress, fromPublicKey: DIDFromPublicKey, toTypeInfo, DidType } = require('@arcblock/did');
-
-/**
- * @public
- * @static
- * @global
- * @name WalletObject
- * @typedef WalletObject
- * @prop {DidType} type - Indicates the wallet type
- * @prop {secretKey} secretKey - Wallet secretKey
- * @prop {publicKey} publicKey - Wallet publicKey
- * @prop {function} sign - Sign `data`, data is hashed using the `HashType` defined in type before signing
- * @prop {function} verify - Verify `signature`, data is hashed using the `HashType` defined in type before verifying
- * @prop {function} toAddress - Get wallet address without `did:abt:` prefix
- * @prop {function} toJSON - Serialize wallet to json object, checkout {@link fromJSON} for deserialisation
- */
-
+"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
  *
@@ -32,98 +13,85 @@ const { toAddress, fromPublicKey: DIDFromPublicKey, toTypeInfo, DidType } = requ
  * @param {object} keyPair - the key pair
  * @param {string} keyPair.sk - the secretKey
  * @param {string} keyPair.pk - the wallet publicKey
- * @param {DidType} [type='default'] - wallet type
+ * @param {DIDTypeArg} [type='default'] - wallet type
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
  */
-function Wallet(keyPair, type = 'default') {
-  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,
-
-    hash(data, round = 1) {
-      return hasher(data, round);
-    },
-
-    sign(data, hashBeforeSign = true) {
-      if (!keyPair.sk) {
-        throw new Error('Cannot sign data without a secretKey');
-      }
-
-      if (hashBeforeSign) {
-        const hash = hasher(data, 1);
-        // console.log('sign.hash', hash.replace(/^0x/i, '').toUpperCase());
-        return signer.sign(hash, keyPair.sk);
-      }
-
-      return signer.sign(data, keyPair.sk);
-    },
-
-    verify(data, signature, hashBeforeVerify = true) {
-      if (!keyPair.pk) {
-        throw new Error('Cannot verify data without a publicKey');
-      }
-      const hash = hashBeforeVerify ? hasher(data, 1) : data;
-      // console.log('verify.hash', hash.replace(/^0x/i, '').toUpperCase());
-      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), keyPair.sk);
-      }
-
-      return signer.ethSign(data, 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;
-    },
-
-    toAddress() {
-      return keyPair.pk ? DIDFromPublicKey(keyPair.pk, type) : keyPair.address;
-    },
-
-    toJSON() {
-      return {
-        type: DidType.toJSON(type),
-        sk: keyPair.sk,
-        pk: keyPair.pk,
-        address: this.address,
-      };
-    },
-  };
+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,
+        hash(data, round = 1) {
+            return hasher(data, round);
+        },
+        sign(data, hashBeforeSign = true) {
+            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);
+            }
+            return signer.sign(data, keyPair.sk);
+        },
+        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), keyPair.sk);
+            }
+            return signer.ethSign(data, 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
  *
  * @public
  * @static
  * @param {string} sk - the secret key, `hex encoded string`
- * @param {DidType} [type='default'] - wallet type
+ * @param {DIDTypeArg} [type='default'] - wallet type
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
  * @example
  * const assert = require('assert');
@@ -141,24 +109,24 @@ function Wallet(keyPair, type = 'default') {
  * assert.ok(wallet.verify(message, signature), "signature should be verified");
  */
 function fromSecretKey(sk, _type = 'default') {
-  const type = DidType(_type);
-  const keyPair = { sk, pk: getSigner(type.pk).getPublicKey(sk) };
-  return Wallet(keyPair, type);
+    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
  *
  * @public
  * @static
  * @param {string} pk - the public key, `hex encoded string`
- * @param {DidType} [type='default'] - wallet type
+ * @param {DIDTypeArg} [type='default'] - wallet type
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
  */
 function fromPublicKey(pk, _type = 'default') {
-  return Wallet({ pk }, DidType(_type));
+    return Wallet({ pk }, (0, did_1.DidType)(_type));
 }
-
+exports.fromPublicKey = fromPublicKey;
 /**
  * Generate a wallet from address (did)
  *
@@ -168,55 +136,34 @@ function fromPublicKey(pk, _type = 'default') {
  * @static
  * @param {string} address - the wallet address
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- * @example
- * const assert = require('assert');
- * const { fromAddress } = require('@ocap/wallet');
- *
- * const address = 'zNKtCNqYWLYWYW3gWRA1vnRykfCBZYHZvzKr';
- * const wallet = fromAddress(address);
- * console.log(wallet.toJSON());
  */
 function fromAddress(address) {
-  return Wallet({ address: toAddress(address) }, DidType(toTypeInfo(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
  *
  * @public
  * @static
- * @param {DidType} [type='default'] - wallet type
+ * @param {DIDTypeArg} [type='default'] - wallet type
  * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- * @example
- * const { fromRandom } = require('@ocap/wallet');
- * const wallet = fromRandom();
- * // Do something with wallet
  */
 function fromRandom(_type = 'default') {
-  const type = DidType(_type);
-  const signer = getSigner(type.pk);
-  const keyPair = signer.genKeyPair();
-  return Wallet({ sk: keyPair.secretKey, pk: keyPair.publicKey }, type);
+    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
- *
- * @public
- * @static
- * @param {object} json - json presentation of a wallet
- * @returns {WalletObject} wallet object that can be used to sign/verify/getAddress
- * @example
- * const { fromJSON, fromRandom } = require('@ocap/wallet');
- * const wallet = fromRandom();
- * const wallet2 = fromJSON(wallet.toJSON());
- * // wallet2 is identical to wallet
  */
 function fromJSON(json) {
-  const type = DidType.fromJSON(json.type);
-  return Wallet(json, type);
+    const type = did_1.DidType.fromJSON(json.type);
+    return Wallet(json, type);
 }
-
+exports.fromJSON = fromJSON;
 /**
  * Check if an object is valid wallet object
  *
@@ -226,47 +173,29 @@ function fromJSON(json) {
  * @param {boolean} canSign - should the wallet support sign
  */
 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 (!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 (typeof wallet.sign !== 'function') {
-      return false;
+    if (canSign) {
+        if (!wallet.secretKey) {
+            return false;
+        }
+        if (typeof wallet.sign !== 'function') {
+            return false;
+        }
     }
-  }
-
-  return true;
+    return true;
 }
-
-module.exports = {
-  fromSecretKey,
-  fromPublicKey,
-  fromRandom,
-  fromAddress,
-  fromDID: fromAddress,
-  fromJSON,
-  isValid,
-  Wallet,
-  WalletType: DidType,
-  DidType,
-};
+exports.isValid = isValid;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocap/wallet",
-  "version": "1.16.16",
+  "version": "1.17.1",
   "description": "Utility function to create and use an forge compatible crypto wallet",
   "keywords": [
     "crypto",
@@ -21,34 +21,40 @@
   "homepage": "https://github.com/ArcBlock/asset-chain/tree/master/core/forge-wallet",
   "license": "Apache-2.0",
   "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
   "files": [
     "lib"
   ],
   "devDependencies": {
-    "jest": "^27.3.1",
-    "jsdoc-to-markdown": "^7.1.1"
+    "@arcblock/eslint-config-ts": "0.2.2",
+    "@types/jest": "^28.1.0",
+    "@types/node": "^17.0.38",
+    "eslint": "^8.17.0",
+    "jest": "^28.1.0",
+    "ts-jest": "^28.0.3",
+    "typescript": "^4.7.3"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ArcBlock/asset-chain.git"
   },
   "scripts": {
-    "lint": "eslint tests lib",
-    "lint:fix": "eslint --fix tests lib",
-    "docs": "yarn gen-dts && yarn gen-docs && yarn cleanup-docs && yarn format-docs",
-    "cleanup-docs": "node ../../scripts/cleanup-docs.js docs/README.md $npm_package_name",
-    "gen-docs": "jsdoc2md lib/index.js > docs/README.md",
-    "gen-dts": "j2d lib/index.js",
-    "format-docs": "remark . -o",
+    "lint": "eslint tests src",
+    "lint:fix": "eslint --fix tests src",
     "test": "jest --forceExit --detectOpenHandles",
-    "coverage": "yarn test -- --coverage"
+    "coverage": "yarn test -- --coverage",
+    "clean": "rm -fr lib",
+    "prebuild": "npm run clean",
+    "build": "tsc",
+    "build:watch": "npm run build -- -w"
   },
   "bugs": {
     "url": "https://github.com/ArcBlock/asset-chain/issues"
   },
   "dependencies": {
-    "@arcblock/did": "1.16.16",
-    "@ocap/mcrypto": "1.16.16"
+    "@arcblock/did": "1.17.1",
+    "@ocap/mcrypto": "1.17.1",
+    "@ocap/util": "1.17.1"
   },
-  "gitHead": "051f9620995cf24407374cc4811b0fa6ed6dc7ca"
+  "gitHead": "ca2ac264d9d6358680d5be99fcdd4685d0c999fc"
 }