@ocap/mcrypto 1.29.4 → 1.29.6

package/lib/node_modules/hash.js/lib/hash/utils.cjs

@@ -0,0 +1,216 @@
+'use strict';
+
+const require_rolldown_runtime = require('../../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../minimalistic-assert/index.cjs');
+const require_inherits$1 = require('../../../inherits/inherits.cjs');
+
+//#region ../../node_modules/hash.js/lib/hash/utils.js
+var require_utils = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports) => {
+	var assert = require_index.default;
+	var inherits = require_inherits$1.default;
+	exports.inherits = inherits;
+	function isSurrogatePair(msg, i) {
+		if ((msg.charCodeAt(i) & 64512) !== 55296) return false;
+		if (i < 0 || i + 1 >= msg.length) return false;
+		return (msg.charCodeAt(i + 1) & 64512) === 56320;
+	}
+	function toArray(msg, enc) {
+		if (Array.isArray(msg)) return msg.slice();
+		if (!msg) return [];
+		var res = [];
+		if (typeof msg === "string") {
+			if (!enc) {
+				var p = 0;
+				for (var i = 0; i < msg.length; i++) {
+					var c = msg.charCodeAt(i);
+					if (c < 128) res[p++] = c;
+					else if (c < 2048) {
+						res[p++] = c >> 6 | 192;
+						res[p++] = c & 63 | 128;
+					} else if (isSurrogatePair(msg, i)) {
+						c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i) & 1023);
+						res[p++] = c >> 18 | 240;
+						res[p++] = c >> 12 & 63 | 128;
+						res[p++] = c >> 6 & 63 | 128;
+						res[p++] = c & 63 | 128;
+					} else {
+						res[p++] = c >> 12 | 224;
+						res[p++] = c >> 6 & 63 | 128;
+						res[p++] = c & 63 | 128;
+					}
+				}
+			} else if (enc === "hex") {
+				msg = msg.replace(/[^a-z0-9]+/gi, "");
+				if (msg.length % 2 !== 0) msg = "0" + msg;
+				for (i = 0; i < msg.length; i += 2) res.push(parseInt(msg[i] + msg[i + 1], 16));
+			}
+		} else for (i = 0; i < msg.length; i++) res[i] = msg[i] | 0;
+		return res;
+	}
+	exports.toArray = toArray;
+	function toHex(msg) {
+		var res = "";
+		for (var i = 0; i < msg.length; i++) res += zero2(msg[i].toString(16));
+		return res;
+	}
+	exports.toHex = toHex;
+	function htonl(w) {
+		return (w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24) >>> 0;
+	}
+	exports.htonl = htonl;
+	function toHex32(msg, endian) {
+		var res = "";
+		for (var i = 0; i < msg.length; i++) {
+			var w = msg[i];
+			if (endian === "little") w = htonl(w);
+			res += zero8(w.toString(16));
+		}
+		return res;
+	}
+	exports.toHex32 = toHex32;
+	function zero2(word) {
+		if (word.length === 1) return "0" + word;
+		else return word;
+	}
+	exports.zero2 = zero2;
+	function zero8(word) {
+		if (word.length === 7) return "0" + word;
+		else if (word.length === 6) return "00" + word;
+		else if (word.length === 5) return "000" + word;
+		else if (word.length === 4) return "0000" + word;
+		else if (word.length === 3) return "00000" + word;
+		else if (word.length === 2) return "000000" + word;
+		else if (word.length === 1) return "0000000" + word;
+		else return word;
+	}
+	exports.zero8 = zero8;
+	function join32(msg, start, end, endian) {
+		var len = end - start;
+		assert(len % 4 === 0);
+		var res = new Array(len / 4);
+		for (var i = 0, k = start; i < res.length; i++, k += 4) {
+			var w;
+			if (endian === "big") w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3];
+			else w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k];
+			res[i] = w >>> 0;
+		}
+		return res;
+	}
+	exports.join32 = join32;
+	function split32(msg, endian) {
+		var res = new Array(msg.length * 4);
+		for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
+			var m = msg[i];
+			if (endian === "big") {
+				res[k] = m >>> 24;
+				res[k + 1] = m >>> 16 & 255;
+				res[k + 2] = m >>> 8 & 255;
+				res[k + 3] = m & 255;
+			} else {
+				res[k + 3] = m >>> 24;
+				res[k + 2] = m >>> 16 & 255;
+				res[k + 1] = m >>> 8 & 255;
+				res[k] = m & 255;
+			}
+		}
+		return res;
+	}
+	exports.split32 = split32;
+	function rotr32(w, b) {
+		return w >>> b | w << 32 - b;
+	}
+	exports.rotr32 = rotr32;
+	function rotl32(w, b) {
+		return w << b | w >>> 32 - b;
+	}
+	exports.rotl32 = rotl32;
+	function sum32(a, b) {
+		return a + b >>> 0;
+	}
+	exports.sum32 = sum32;
+	function sum32_3(a, b, c) {
+		return a + b + c >>> 0;
+	}
+	exports.sum32_3 = sum32_3;
+	function sum32_4(a, b, c, d) {
+		return a + b + c + d >>> 0;
+	}
+	exports.sum32_4 = sum32_4;
+	function sum32_5(a, b, c, d, e) {
+		return a + b + c + d + e >>> 0;
+	}
+	exports.sum32_5 = sum32_5;
+	function sum64(buf, pos, ah, al) {
+		var bh = buf[pos];
+		var lo = al + buf[pos + 1] >>> 0;
+		buf[pos] = (lo < al ? 1 : 0) + ah + bh >>> 0;
+		buf[pos + 1] = lo;
+	}
+	exports.sum64 = sum64;
+	function sum64_hi(ah, al, bh, bl) {
+		return (al + bl >>> 0 < al ? 1 : 0) + ah + bh >>> 0;
+	}
+	exports.sum64_hi = sum64_hi;
+	function sum64_lo(ah, al, bh, bl) {
+		return al + bl >>> 0;
+	}
+	exports.sum64_lo = sum64_lo;
+	function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
+		var carry = 0;
+		var lo = al;
+		lo = lo + bl >>> 0;
+		carry += lo < al ? 1 : 0;
+		lo = lo + cl >>> 0;
+		carry += lo < cl ? 1 : 0;
+		lo = lo + dl >>> 0;
+		carry += lo < dl ? 1 : 0;
+		return ah + bh + ch + dh + carry >>> 0;
+	}
+	exports.sum64_4_hi = sum64_4_hi;
+	function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
+		return al + bl + cl + dl >>> 0;
+	}
+	exports.sum64_4_lo = sum64_4_lo;
+	function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+		var carry = 0;
+		var lo = al;
+		lo = lo + bl >>> 0;
+		carry += lo < al ? 1 : 0;
+		lo = lo + cl >>> 0;
+		carry += lo < cl ? 1 : 0;
+		lo = lo + dl >>> 0;
+		carry += lo < dl ? 1 : 0;
+		lo = lo + el >>> 0;
+		carry += lo < el ? 1 : 0;
+		return ah + bh + ch + dh + eh + carry >>> 0;
+	}
+	exports.sum64_5_hi = sum64_5_hi;
+	function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+		return al + bl + cl + dl + el >>> 0;
+	}
+	exports.sum64_5_lo = sum64_5_lo;
+	function rotr64_hi(ah, al, num) {
+		return (al << 32 - num | ah >>> num) >>> 0;
+	}
+	exports.rotr64_hi = rotr64_hi;
+	function rotr64_lo(ah, al, num) {
+		return (ah << 32 - num | al >>> num) >>> 0;
+	}
+	exports.rotr64_lo = rotr64_lo;
+	function shr64_hi(ah, al, num) {
+		return ah >>> num;
+	}
+	exports.shr64_hi = shr64_hi;
+	function shr64_lo(ah, al, num) {
+		return (ah << 32 - num | al >>> num) >>> 0;
+	}
+	exports.shr64_lo = shr64_lo;
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_utils();
+  }
+});

package/lib/node_modules/hash.js/lib/hash.cjs

@@ -0,0 +1,30 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_utils$1 = require('./hash/utils.cjs');
+const require_common$1 = require('./hash/common.cjs');
+const require_sha$1 = require('./hash/sha.cjs');
+const require_ripemd$1 = require('./hash/ripemd.cjs');
+const require_hmac$1 = require('./hash/hmac.cjs');
+
+//#region ../../node_modules/hash.js/lib/hash.js
+var require_hash = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports) => {
+	var hash = exports;
+	hash.utils = require_utils$1.default;
+	hash.common = require_common$1.default;
+	hash.sha = require_sha$1.default;
+	hash.ripemd = require_ripemd$1.default;
+	hash.hmac = require_hmac$1.default;
+	hash.sha1 = hash.sha.sha1;
+	hash.sha256 = hash.sha.sha256;
+	hash.sha224 = hash.sha.sha224;
+	hash.sha384 = hash.sha.sha384;
+	hash.sha512 = hash.sha.sha512;
+	hash.ripemd160 = hash.ripemd.ripemd160;
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_hash();
+  }
+});

package/lib/node_modules/inherits/inherits.cjs

@@ -0,0 +1,23 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_inherits_browser$1 = require('./inherits_browser.cjs');
+
+//#region ../../node_modules/inherits/inherits.js
+var require_inherits = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	try {
+		var util = require("util");
+		/* istanbul ignore next */
+		if (typeof util.inherits !== "function") throw "";
+		module.exports = util.inherits;
+	} catch (e) {
+		/* istanbul ignore next */
+		module.exports = require_inherits_browser$1.default;
+	}
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_inherits();
+  }
+});

package/lib/node_modules/inherits/inherits_browser.cjs

@@ -0,0 +1,33 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+
+//#region ../../node_modules/inherits/inherits_browser.js
+var require_inherits_browser = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	if (typeof Object.create === "function") module.exports = function inherits(ctor, superCtor) {
+		if (superCtor) {
+			ctor.super_ = superCtor;
+			ctor.prototype = Object.create(superCtor.prototype, { constructor: {
+				value: ctor,
+				enumerable: false,
+				writable: true,
+				configurable: true
+			} });
+		}
+	};
+	else module.exports = function inherits(ctor, superCtor) {
+		if (superCtor) {
+			ctor.super_ = superCtor;
+			var TempCtor = function() {};
+			TempCtor.prototype = superCtor.prototype;
+			ctor.prototype = new TempCtor();
+			ctor.prototype.constructor = ctor;
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_inherits_browser();
+  }
+});

package/lib/node_modules/minimalistic-assert/index.cjs

@@ -0,0 +1,20 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+
+//#region ../../node_modules/minimalistic-assert/index.js
+var require_minimalistic_assert = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	module.exports = assert;
+	function assert(val, msg) {
+		if (!val) throw new Error(msg || "Assertion failed");
+	}
+	assert.equal = function assertEqual(l, r, msg) {
+		if (l != r) throw new Error(msg || "Assertion failed: " + l + " != " + r);
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_minimalistic_assert();
+  }
+});

package/lib/signer/ed25519.cjs

@@ -1,17 +1,19 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_encode = require('../encode.cjs');
+const require_hash$1 = require('../node_modules/hash.js/lib/hash.cjs');
 const require_protocols_signer = require('../protocols/signer.cjs');
 let _ocap_util = require("@ocap/util");
 let randombytes = require("randombytes");
 randombytes = require_rolldown_runtime.__toESM(randombytes);
-let tweetnacl = require("tweetnacl");
-tweetnacl = require_rolldown_runtime.__toESM(tweetnacl);
+let _noble_ed25519 = require("@noble/ed25519");
+_noble_ed25519 = require_rolldown_runtime.__toESM(_noble_ed25519);
 
 //#region src/signer/ed25519.ts
-const ed25519 = tweetnacl.default.sign;
+var import_hash = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_hash$1.default, 1);
+_noble_ed25519.hashes.sha512 = (msg) => new Uint8Array(import_hash.default.sha512().update(msg).digest());
 /**
-* Signer implementation for ed25519, based on `tweetnacl`
+* Signer implementation for ed25519, based on `@noble/ed25519`
 *
 * @class Ed25519Signer
 */
@@ -34,10 +36,14 @@ var Ed25519Signer = class extends require_protocols_signer.default {
 	genKeyPair(encoding = "hex", userSeed) {
 		const seed = userSeed ? (0, _ocap_util.toUint8Array)(userSeed) : new Uint8Array((0, randombytes.default)(32));
 		if (seed.byteLength !== 32) throw new Error("Invalid seed to generate key pair");
-		const keyPair = ed25519.keyPair.fromSeed(seed);
-		keyPair.publicKey = require_encode.encode(keyPair.publicKey, encoding);
-		keyPair.secretKey = require_encode.encode(keyPair.secretKey, encoding);
-		return keyPair;
+		const publicKey = _noble_ed25519.getPublicKey(seed);
+		const secretKey = new Uint8Array(64);
+		secretKey.set(seed);
+		secretKey.set(publicKey, 32);
+		return {
+			publicKey: require_encode.encode(publicKey, encoding),
+			secretKey: require_encode.encode(secretKey, encoding)
+		};
 	}
 	/**
 	* Get publicKey from secretKey
@@ -47,8 +53,8 @@ var Ed25519Signer = class extends require_protocols_signer.default {
 	*/
 	getPublicKey(sk, encoding = "hex") {
 		const skBytes = (0, _ocap_util.toUint8Array)(sk);
-		const pk = ed25519.keyPair.fromSecretKey(skBytes).publicKey;
-		return require_encode.encode(pk, encoding);
+		if (skBytes.byteLength === 64) return require_encode.encode(skBytes.slice(32, 64), encoding);
+		return require_encode.encode(_noble_ed25519.getPublicKey(skBytes), encoding);
 	}
 	/**
 	* Sign a message and get the signature hex
@@ -58,9 +64,9 @@ var Ed25519Signer = class extends require_protocols_signer.default {
 	* @returns {string} hex encoded signature
 	*/
 	sign(message, sk, encoding = "hex") {
-		const skBytes = (0, _ocap_util.toUint8Array)(sk);
+		const seed = (0, _ocap_util.toUint8Array)(sk).slice(0, 32);
 		const messageBytes = (0, _ocap_util.toUint8Array)(message);
-		return require_encode.encode(ed25519.detached(messageBytes, skBytes), encoding);
+		return require_encode.encode(_noble_ed25519.sign(messageBytes, seed), encoding);
 	}
 	/**
 	* Verify if a signature is valid
@@ -74,7 +80,7 @@ var Ed25519Signer = class extends require_protocols_signer.default {
 		const pkBytes = (0, _ocap_util.toUint8Array)(pk);
 		const messageBytes = (0, _ocap_util.toUint8Array)(message);
 		const signatureBytes = (0, _ocap_util.toUint8Array)(signature);
-		return ed25519.detached.verify(messageBytes, signatureBytes, pkBytes);
+		return _noble_ed25519.verify(signatureBytes, messageBytes, pkBytes);
 	}
 };
 var ed25519_default = new Ed25519Signer();

package/lib/signer/ed25519.d.cts

@@ -4,7 +4,7 @@ import { BytesType, EncodingType, KeyPairType } from "@ocap/util";
 //#region src/signer/ed25519.d.ts
 
 /**
- * Signer implementation for ed25519, based on `tweetnacl`
+ * Signer implementation for ed25519, based on `@noble/ed25519`
  *
  * @class Ed25519Signer
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocap/mcrypto",
-  "version": "1.29.4",
+  "version": "1.29.6",
   "type": "module",
   "description": "Crypto lib that provides signer,crypter,hasher interface",
   "keywords": [
@@ -48,7 +48,7 @@
     "esm"
   ],
   "devDependencies": {
-    "@ocap/e2e-test": "1.29.4",
+    "@ocap/e2e-test": "1.29.6",
     "@types/crypto-js": "^4.2.2",
     "@types/elliptic": "^6.4.18",
     "@types/node": "^22.7.5",
@@ -67,23 +67,23 @@
     "test": "bun test",
     "coverage": "npm run test -- --coverage",
     "build": "tsdown",
-    "build:watch": "tsdown -w"
+    "build:watch": "tsdown -w",
+    "clean": "rm -rf lib esm"
   },
   "bugs": {
     "url": "https://github.com/ArcBlock/blockchain/issues"
   },
   "dependencies": {
-    "@ocap/util": "1.29.4",
+    "@noble/ed25519": "^3.0.0",
+    "@noble/hashes": "^2.0.1",
+    "@ocap/util": "1.29.6",
     "@simplewebauthn/server": "^13.0.0",
     "bn.js": "5.2.2",
     "crypto-js": "^4.2.0",
     "elliptic": "^6.6.1",
     "eth-lib": "^0.2.8",
-    "hash.js": "^1.1.7",
     "interface": "^1.2.1",
-    "js-sha3": "^0.8.0",
-    "randombytes": "^2.1.0",
-    "tweetnacl": "^1.0.3"
+    "randombytes": "^2.1.0"
   },
   "resolutions": {
     "bn.js": "5.2.2",