@ocap/mcrypto 1.16.15 → 1.17.0

package/lib/signer/ed25519.d.ts

@@ -0,0 +1,53 @@
+import { BytesType, EncodingType, KeyPairType } from '@ocap/util';
+import Signer from '../protocols/signer';
+/**
+ * Signer implementation for ed25519, based on `tweetnacl`
+ *
+ * @class Ed25519Signer
+ */
+declare class Ed25519Signer extends Signer {
+    constructor();
+    /**
+     * @public
+     * @typedefKeyPairType
+     * @prop {string} publicKey - publicKey in hex format
+     * @prop {string} secretKey - secretKey in hex format
+     * @memberof Ed25519Signer
+     */
+    /**
+     * Generate random secret/public key pair
+     *
+     * @param {Buffer|Uint8Array} [userSeed=undefined]
+     * @param {string} [encoding='hex']
+     * @returns {KeyPairType}
+     * @memberof Ed25519Signer
+     */
+    genKeyPair(encoding?: EncodingType, userSeed?: BytesType): KeyPairType;
+    /**
+     * Get publicKey from secretKey
+     *
+     * @param {hex|buffer|base58|Uint8Array} sk - can be either a hex encoded string or a buffer
+     * @returns {string} hex encoded publicKey
+     */
+    getPublicKey(sk: BytesType, encoding?: EncodingType): BytesType;
+    /**
+     * Sign a message and get the signature hex
+     *
+     * @param {hex|base58|buffer|Uint8Array} message
+     * @param {hex|base58|buffer|Uint8Array} sk
+     * @returns {string} hex encoded signature
+     */
+    sign(message: BytesType, sk: BytesType, encoding?: EncodingType): BytesType;
+    /**
+     * Verify if a signature is valid
+     *
+     * @param {string|buffer} message
+     * @param {string|buffer} signature
+     * @param {string|buffer} pk
+     * @returns {bool}
+     */
+    verify(message: BytesType, signature: BytesType, pk: BytesType): boolean;
+}
+declare const _default: Ed25519Signer;
+export default _default;
+export { Ed25519Signer };

package/lib/signer/ed25519.js

@@ -1,93 +1,88 @@
-/* eslint-disable class-methods-use-this */
-/* eslint-disable no-useless-constructor */
-const ed25519 = require('tweetnacl').sign;
-const randomBytes = require('randombytes');
-const { toUint8Array } = require('@ocap/util');
-
-const Signer = require('../protocols/signer');
-const encode = require('../encode');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ed25519Signer = void 0;
+/* eslint-disable @typescript-eslint/no-useless-constructor */
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const randombytes_1 = __importDefault(require("randombytes"));
+const util_1 = require("@ocap/util");
+const signer_1 = __importDefault(require("../protocols/signer"));
+const encode_1 = __importDefault(require("../encode"));
+const ed25519 = tweetnacl_1.default.sign;
 /**
  * Signer implementation for ed25519, based on `tweetnacl`
  *
  * @class Ed25519Signer
  */
-class Ed25519Signer extends Signer {
-  constructor() {
-    super();
-  }
-
-  /**
-   * @public
-   * @typedef KeyPair
-   * @prop {string} publicKey - publicKey in hex format
-   * @prop {string} secretKey - secretKey in hex format
-   * @memberof Ed25519Signer
-   */
-
-  /**
-   * Generate random secret/public key pair
-   *
-   * @param {Buffer|Uint8Array} [userSeed=undefined]
-   * @param {string} [encoding='hex']
-   * @returns {KeyPair}
-   * @memberof Ed25519Signer
-   */
-  genKeyPair(userSeed, encoding = 'hex') {
-    const seed = userSeed ? toUint8Array(userSeed) : new Uint8Array(randomBytes(32));
-    if (seed.byteLength !== 32) {
-      throw new Error('Invalid seed to generate key pair');
+class Ed25519Signer extends signer_1.default {
+    constructor() {
+        super();
+    }
+    /**
+     * @public
+     * @typedefKeyPairType
+     * @prop {string} publicKey - publicKey in hex format
+     * @prop {string} secretKey - secretKey in hex format
+     * @memberof Ed25519Signer
+     */
+    /**
+     * Generate random secret/public key pair
+     *
+     * @param {Buffer|Uint8Array} [userSeed=undefined]
+     * @param {string} [encoding='hex']
+     * @returns {KeyPairType}
+     * @memberof Ed25519Signer
+     */
+    genKeyPair(encoding = 'hex', userSeed) {
+        const seed = userSeed ? (0, util_1.toUint8Array)(userSeed) : new Uint8Array((0, randombytes_1.default)(32));
+        if (seed.byteLength !== 32) {
+            throw new Error('Invalid seed to generate key pair');
+        }
+        const keyPair = ed25519.keyPair.fromSeed(seed);
+        keyPair.publicKey = (0, encode_1.default)(keyPair.publicKey, encoding);
+        keyPair.secretKey = (0, encode_1.default)(keyPair.secretKey, encoding);
+        return keyPair;
+    }
+    /**
+     * Get publicKey from secretKey
+     *
+     * @param {hex|buffer|base58|Uint8Array} sk - can be either a hex encoded string or a buffer
+     * @returns {string} hex encoded publicKey
+     */
+    getPublicKey(sk, encoding = 'hex') {
+        const skBytes = (0, util_1.toUint8Array)(sk);
+        const pk = ed25519.keyPair.fromSecretKey(skBytes).publicKey;
+        return (0, encode_1.default)(pk, encoding);
+    }
+    /**
+     * Sign a message and get the signature hex
+     *
+     * @param {hex|base58|buffer|Uint8Array} message
+     * @param {hex|base58|buffer|Uint8Array} sk
+     * @returns {string} hex encoded signature
+     */
+    sign(message, sk, encoding = 'hex') {
+        const skBytes = (0, util_1.toUint8Array)(sk);
+        const messageBytes = (0, util_1.toUint8Array)(message);
+        const signature = ed25519.detached(messageBytes, skBytes);
+        return (0, encode_1.default)(signature, encoding);
+    }
+    /**
+     * Verify if a signature is valid
+     *
+     * @param {string|buffer} message
+     * @param {string|buffer} signature
+     * @param {string|buffer} pk
+     * @returns {bool}
+     */
+    verify(message, signature, pk) {
+        const pkBytes = (0, util_1.toUint8Array)(pk);
+        const messageBytes = (0, util_1.toUint8Array)(message);
+        const signatureBytes = (0, util_1.toUint8Array)(signature);
+        return ed25519.detached.verify(messageBytes, signatureBytes, pkBytes);
     }
-
-    const keyPair = ed25519.keyPair.fromSeed(seed);
-
-    keyPair.publicKey = encode(keyPair.publicKey, encoding);
-    keyPair.secretKey = encode(keyPair.secretKey, encoding);
-
-    return keyPair;
-  }
-
-  /**
-   * Get publicKey from secretKey
-   *
-   * @param {hex|buffer|base58|Uint8Array} sk - can be either a hex encoded string or a buffer
-   * @returns {string} hex encoded publicKey
-   */
-  getPublicKey(sk, encoding = 'hex') {
-    const skBytes = toUint8Array(sk);
-    const pk = ed25519.keyPair.fromSecretKey(skBytes).publicKey;
-    return encode(pk, encoding);
-  }
-
-  /**
-   * Sign a message and get the signature hex
-   *
-   * @param {hex|base58|buffer|Uint8Array} message
-   * @param {hex|base58|buffer|Uint8Array} sk
-   * @returns {string} hex encoded signature
-   */
-  sign(message, sk, encoding = 'hex') {
-    const skBytes = toUint8Array(sk);
-    const messageBytes = toUint8Array(message);
-    const signature = ed25519.detached(messageBytes, skBytes);
-    return encode(signature, encoding);
-  }
-
-  /**
-   * Verify if a signature is valid
-   *
-   * @param {string|buffer} message
-   * @param {string|buffer} signature
-   * @param {string|buffer} pk
-   * @returns {bool}
-   */
-  verify(message, signature, pk) {
-    const pkBytes = toUint8Array(pk);
-    const messageBytes = toUint8Array(message);
-    const signatureBytes = toUint8Array(signature);
-    return ed25519.detached.verify(messageBytes, signatureBytes, pkBytes);
-  }
 }
-
-module.exports = new Ed25519Signer();
-module.exports.Ed25519Signer = Ed25519Signer;
+exports.Ed25519Signer = Ed25519Signer;
+exports.default = new Ed25519Signer();

package/lib/signer/ethereum.d.ts

@@ -0,0 +1,17 @@
+import { BytesType } from '@ocap/util';
+import { Secp256k1Signer } from './secp256k1';
+/**
+ * Signer implementation for secp256k1, based on `elliptic`, and ethereum compatible
+ *
+ * @class EthereumSigner
+ */
+declare class EthereumSigner extends Secp256k1Signer {
+    pkHasFormatPrefix: boolean;
+    constructor();
+    ethHash(data: string): string;
+    ethSign(data: BytesType, privateKey: BytesType): string;
+    ethRecover(data: BytesType, signature: BytesType): string;
+}
+declare const _default: EthereumSigner;
+export default _default;
+export { EthereumSigner };

package/lib/signer/ethereum.js

@@ -1,40 +1,41 @@
-/* eslint-disable class-methods-use-this */
-/* eslint-disable no-useless-constructor */
-const Account = require('eth-lib/lib/account');
-const Hash = require('eth-lib/lib/hash');
-const { isHexStrict, utf8ToHex, hexToBytes } = require('@ocap/util');
-
-const { Secp256k1Signer } = require('./secp256k1');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthereumSigner = void 0;
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @ts-ignore
+const account_1 = __importDefault(require("eth-lib/lib/account"));
+// @ts-ignore
+const hash_1 = __importDefault(require("eth-lib/lib/hash"));
+const util_1 = require("@ocap/util");
+const secp256k1_1 = require("./secp256k1");
 /**
  * Signer implementation for secp256k1, based on `elliptic`, and ethereum compatible
  *
  * @class EthereumSigner
  */
-class EthereumSigner extends Secp256k1Signer {
-  constructor() {
-    super();
-    this.pkHasFormatPrefix = false;
-  }
-
-  ethHash(data) {
-    const messageHex = isHexStrict(data) ? data : utf8ToHex(data);
-    const messageBytes = hexToBytes(messageHex);
-    const messageBuffer = Buffer.from(messageBytes);
-    const preamble = `\x19Ethereum Signed Message:\n${messageBytes.length}`;
-    const preambleBuffer = Buffer.from(preamble);
-    const ethMessage = Buffer.concat([preambleBuffer, messageBuffer]);
-    return Hash.keccak256s(ethMessage);
-  }
-
-  ethSign(data, privateKey) {
-    return Account.sign(data, privateKey);
-  }
-
-  ethRecover(data, signature) {
-    return Account.recover(data, signature);
-  }
+class EthereumSigner extends secp256k1_1.Secp256k1Signer {
+    constructor() {
+        super();
+        this.pkHasFormatPrefix = false;
+    }
+    ethHash(data) {
+        const messageHex = (0, util_1.isHexStrict)(data) ? data : (0, util_1.utf8ToHex)(data);
+        const messageBytes = (0, util_1.hexToBytes)(messageHex);
+        const messageBuffer = Buffer.from(messageBytes);
+        const preamble = `\x19Ethereum Signed Message:\n${messageBytes.length}`;
+        const preambleBuffer = Buffer.from(preamble);
+        const ethMessage = Buffer.concat([preambleBuffer, messageBuffer]);
+        return hash_1.default.keccak256s(ethMessage);
+    }
+    ethSign(data, privateKey) {
+        return account_1.default.sign(data, privateKey);
+    }
+    ethRecover(data, signature) {
+        return account_1.default.recover(data, signature);
+    }
 }
-
-module.exports = new EthereumSigner();
-module.exports.EthereumSigner = EthereumSigner;
+exports.EthereumSigner = EthereumSigner;
+exports.default = new EthereumSigner();

package/lib/signer/secp256k1.d.ts

@@ -0,0 +1,39 @@
+import { BytesType, KeyPairType, EncodingType } from '@ocap/util';
+import Signer from '../protocols/signer';
+/**
+ * Signer implementation for secp256k1, based on `elliptic`
+ *
+ * @class Secp256k1Signer
+ */
+declare class Secp256k1Signer extends Signer {
+    pkCompressed: boolean;
+    pkHasFormatPrefix: boolean;
+    constructor();
+    isValidSK(sk: BytesType): boolean;
+    /**
+     * @public
+     * @typedefKeyPairType
+     * @prop {string} publicKey - publicKey in hex format
+     * @prop {string} secretKey - secretKey in hex format
+     * @memberof Secp256k1Signer
+     */
+    /**
+     * Generate random secret/public key pair
+     */
+    genKeyPair(encoding?: EncodingType): KeyPairType;
+    /**
+     * Get publicKey from secretKey
+     */
+    getPublicKey(sk: BytesType, encoding?: EncodingType): BytesType;
+    /**
+     * Sign a message and get the signature hex
+     */
+    sign(message: BytesType, sk: BytesType, encoding?: EncodingType): BytesType;
+    /**
+     * Verify if a signature is valid
+     */
+    verify(message: BytesType, signature: BytesType, pk: BytesType): boolean;
+}
+declare const _default: Secp256k1Signer;
+export default _default;
+export { Secp256k1Signer };

package/lib/signer/secp256k1.js

@@ -1,120 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Secp256k1Signer = void 0;
+const elliptic_1 = __importDefault(require("elliptic"));
+const util_1 = require("@ocap/util");
+const randombytes_1 = __importDefault(require("randombytes"));
+const signer_1 = __importDefault(require("../protocols/signer"));
+const encode_1 = __importDefault(require("../encode"));
 /* eslint-disable class-methods-use-this */
 /* eslint-disable no-useless-constructor */
-const EC = require('elliptic').ec;
-const { BN } = require('@ocap/util');
-const randomBytes = require('randombytes');
-const { stripHexPrefix, toHex, toBuffer, toUint8Array } = require('@ocap/util');
-const Signer = require('../protocols/signer');
-
+const EC = elliptic_1.default.ec;
 const secp256k1 = new EC('secp256k1');
-const encode = require('../encode');
-
 /**
  * Signer implementation for secp256k1, based on `elliptic`
  *
  * @class Secp256k1Signer
  */
-class Secp256k1Signer extends Signer {
-  constructor() {
-    super();
-    this.pkHasFormatPrefix = true;
-    this.pkCompressed = false;
-  }
-
-  isValidSK(sk) {
-    const bn = new BN(sk);
-    return bn.cmp(secp256k1.curve.n) < 0 && !bn.isZero();
-  }
-
-  /**
-   * @public
-   * @typedef KeyPair
-   * @prop {string} publicKey - publicKey in hex format
-   * @prop {string} secretKey - secretKey in hex format
-   * @memberof Secp256k1Signer
-   */
-
-  /**
-   * Generate random secret/public key pair
-   *
-   * @param {string} [encoding='hex']
-   * @returns {KeyPair}
-   * @memberof Secp256k1Signer
-   */
-  genKeyPair(encoding = 'hex') {
-    let sk = null;
-    do {
-      sk = new Uint8Array(randomBytes(32));
-    } while (!this.isValidSK(sk));
-    const pk = this.getPublicKey(toHex(sk));
-    return { secretKey: encode(sk, encoding), publicKey: encode(pk, encoding) };
-  }
-
-  /**
-   * Get publicKey from secretKey
-   *
-   * @param {string} sk - must be a hex encoded string
-   * @param {string} [encoding='hex']
-   * @returns {string} hex encoded publicKey
-   * @memberof Secp256k1Signer
-   */
-  getPublicKey(sk, encoding = 'hex') {
-    let pk = secp256k1.keyFromPrivate(toBuffer(sk)).getPublic(this.pkCompressed, 'hex');
-    if (this.pkHasFormatPrefix === false) {
-      pk = pk.slice(2);
+class Secp256k1Signer extends signer_1.default {
+    constructor() {
+        super();
+        this.pkHasFormatPrefix = true;
+        this.pkCompressed = false;
     }
-
-    return encode(`0x${pk}`, encoding);
-  }
-
-  /**
-   * Sign a message and get the signature hex
-   *
-   * @param {string} message
-   * @param {string} sk
-   * @param {string} [encoding='hex']
-   * @returns {string} hex encoded signature
-   * @memberof Secp256k1Signer
-   */
-  sign(message, sk, encoding = 'hex') {
-    let msg = message;
-    try {
-      msg = toUint8Array(message);
-    } catch (err) {
-      // Do nothing;
+    isValidSK(sk) {
+        const bn = new util_1.BN(sk);
+        return bn.cmp(secp256k1.curve.n) < 0 && !bn.isZero();
     }
-
-    const signature = secp256k1
-      .keyFromPrivate(toBuffer(sk))
-      .sign(stripHexPrefix(msg), { canonical: true })
-      .toDER('hex');
-    return encode(`0x${signature}`, encoding);
-  }
-
-  /**
-   * Verify if a signature is valid
-   *
-   * @param {string} message
-   * @param {string} signature
-   * @param {string} pk
-   * @returns {bool}
-   */
-  verify(message, signature, pk) {
-    let msg = message;
-    try {
-      msg = toUint8Array(message);
-    } catch (err) {
-      // Do nothing;
+    /**
+     * @public
+     * @typedefKeyPairType
+     * @prop {string} publicKey - publicKey in hex format
+     * @prop {string} secretKey - secretKey in hex format
+     * @memberof Secp256k1Signer
+     */
+    /**
+     * Generate random secret/public key pair
+     */
+    genKeyPair(encoding = 'hex') {
+        let sk = null;
+        do {
+            sk = new Uint8Array((0, randombytes_1.default)(32));
+        } while (!this.isValidSK(sk));
+        const pk = this.getPublicKey((0, util_1.toHex)(sk));
+        return { secretKey: (0, encode_1.default)(sk, encoding), publicKey: (0, encode_1.default)(pk, encoding) };
     }
-
-    let pkBuffer = toBuffer(pk);
-    if (this.pkHasFormatPrefix === false && pkBuffer[0] !== 0x04 && pkBuffer.byteLength === 64) {
-      pkBuffer = Buffer.concat([Buffer.from([0x04]), pkBuffer]);
+    /**
+     * Get publicKey from secretKey
+     */
+    getPublicKey(sk, encoding = 'hex') {
+        let pk = secp256k1.keyFromPrivate((0, util_1.toBuffer)(sk)).getPublic(this.pkCompressed, 'hex');
+        if (this.pkHasFormatPrefix === false) {
+            pk = pk.slice(2);
+        }
+        return (0, encode_1.default)(`0x${pk}`, encoding);
+    }
+    /**
+     * Sign a message and get the signature hex
+     */
+    sign(message, sk, encoding = 'hex') {
+        let msg = message;
+        try {
+            msg = (0, util_1.toUint8Array)(message);
+        }
+        catch (err) {
+            // Do nothing;
+        }
+        const signature = secp256k1
+            .keyFromPrivate((0, util_1.toBuffer)(sk))
+            .sign((0, util_1.stripHexPrefix)(msg), { canonical: true })
+            .toDER('hex');
+        return (0, encode_1.default)(`0x${signature}`, encoding);
+    }
+    /**
+     * Verify if a signature is valid
+     */
+    verify(message, signature, pk) {
+        let msg = message;
+        try {
+            msg = (0, util_1.toUint8Array)(message);
+        }
+        catch (err) {
+            // Do nothing;
+        }
+        let pkBuffer = (0, util_1.toBuffer)(pk);
+        if (this.pkHasFormatPrefix === false && pkBuffer[0] !== 0x04 && pkBuffer.byteLength === 64) {
+            pkBuffer = Buffer.concat([Buffer.from([0x04]), pkBuffer]);
+        }
+        return secp256k1.keyFromPublic(pkBuffer).verify((0, util_1.stripHexPrefix)(msg), (0, util_1.stripHexPrefix)((0, util_1.toHex)(signature)));
     }
-
-    return secp256k1.keyFromPublic(pkBuffer).verify(stripHexPrefix(msg), stripHexPrefix(toHex(signature)));
-  }
 }
-
-module.exports = new Secp256k1Signer();
-module.exports.Secp256k1Signer = Secp256k1Signer;
+exports.Secp256k1Signer = Secp256k1Signer;
+exports.default = new Secp256k1Signer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocap/mcrypto",
-  "version": "1.16.15",
+  "version": "1.17.0",
   "description": "Crypto lib that provides signer,crypter,hasher interface",
   "keywords": [
     "crypto",
@@ -22,36 +22,43 @@
   "homepage": "https://github.com/ArcBlock/asset-chain/tree/master/core/mcrypto",
   "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/crypto-js": "^4.1.1",
+    "@types/elliptic": "^6.4.14",
+    "@types/node": "^17.0.38",
+    "@types/randombytes": "^2.0.0",
+    "eslint": "^8.17.0",
+    "jest": "^28.1.1",
+    "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-dts": "j2d lib/index.js",
+    "lint": "eslint src tests",
+    "lint:fix": "npm run lint -- --fix",
     "prepush": "CI=1 yarn test",
     "test": "jest --forceExit --detectOpenHandles",
-    "format-docs": "remark . -o",
-    "gen-docs": "jsdoc2md lib/index.js > docs/README.md",
-    "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": {
-    "@ocap/util": "1.16.15",
-    "bn.js": "5.2.0",
-    "crypto-js": "^4.0.0",
+    "@ocap/util": "1.17.0",
+    "bn.js": "5.2.1",
+    "crypto-js": "^4.1.1",
     "elliptic": "^6.5.3",
     "eth-lib": "^0.2.8",
     "hash.js": "^1.1.7",
@@ -61,8 +68,8 @@
     "tweetnacl": "^1.0.3"
   },
   "resolutions": {
-    "bn.js": "5.2.0",
+    "bn.js": "5.2.1",
     "elliptic": "6.5.3"
   },
-  "gitHead": "dac591c5ba14e0cac5cc7b2e9c015ea9fa8333d7"
+  "gitHead": "f0944b60a5fb4115e1a3727bb07f68174bc56c5c"
 }