refactor: reduce bundle size

commitlint.config.js

@@ -21,6 +21,7 @@ const scopeEnumValues = [
   "utils",
   "runner",
   "e2e-test",
+  "crypto",
 ];
 const Configuration = {
   extends: ["@commitlint/config-conventional"],

devtools/.gitignore

@@ -0,0 +1,2 @@
+lib
+stats.json

devtools/bundler/README.md

@@ -0,0 +1,10 @@
+# Bundler
+
+A Lumos bundler playground to test, check and analyze the bundled code.
+
+## Usage
+
+```bash
+npm run bundle-stats
+npm run bundle-analyze
+```

devtools/bundler/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@ckb-lumos/bundler",
+  "version": "0.20.0",
+  "homepage": "https://github.com/ckb-js/lumos#readme",
+  "bugs": {
+    "url": "https://github.com/ckb-js/lumos/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ckb-js/lumos.git"
+  },
+  "license": "MIT",
+  "author": "",
+  "scripts": {
+    "bundle-stats": "webpack --profile --json > stats.json",
+    "bundle-analyze": "webpack-bundle-analyzer stats.json"
+  },
+  "dependencies": {
+    "@ckb-lumos/lumos": "0.20.0",
+    "@types/webpack-bundle-analyzer": "^4.6.0",
+    "buffer": "^5.6.0",
+    "fork-ts-checker-webpack-plugin": "^6.4.0",
+    "ts-loader": "^9.4.3",
+    "unminified-webpack-plugin": "^3.0.0",
+    "webpack": "^5.64.1",
+    "webpack-bundle-analyzer": "^4.9.0",
+    "webpack-cli": "^4.9.1"
+  }
+}

devtools/bundler/src/index.ts

@@ -0,0 +1 @@
+export * from "@ckb-lumos/lumos";

devtools/bundler/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "lib",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

devtools/bundler/webpack.config.js

@@ -0,0 +1,39 @@
+const path = require("path");
+const webpack = require("webpack");
+const ForkTsCheckerWebpackPlugin = require("fork-ts-checker-webpack-plugin");
+
+module.exports = {
+  mode: "production",
+  devtool: "source-map",
+  entry: { output: "./src/index.ts" },
+  output: {
+    path: path.join(__dirname, "lib"),
+    filename: "lumos.min.js",
+    library: "lumos",
+    libraryTarget: "umd",
+    globalObject: "this",
+  },
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        loader: "ts-loader",
+        options: {},
+      },
+    ],
+  },
+  resolve: {
+    extensions: [".ts", ".js", ".json"],
+    fallback: {
+      // https://www.npmjs.com/package/buffer#usage
+      buffer: require.resolve("buffer/"),
+      path: false,
+      fs: false,
+      stream: false,
+    },
+  },
+  plugins: [
+    new ForkTsCheckerWebpackPlugin({ async: false }),
+    new webpack.ProvidePlugin({ Buffer: ["buffer", "Buffer"] }),
+  ],
+};

packages/base/package.json

@@ -48,10 +48,8 @@
     "@ckb-lumos/codec": "0.20.0",
     "@ckb-lumos/toolkit": "0.20.0",
     "@types/blake2b": "^2.1.0",
-    "@types/lodash.isequal": "^4.5.5",
     "blake2b": "^2.1.3",
-    "js-xxhash": "^1.0.4",
-    "lodash.isequal": "^4.5.0"
+    "js-xxhash": "^1.0.4"
   },
   "devDependencies": {
     "jsbi": "^4.1.0"

packages/base/src/utils.ts

@@ -1,5 +1,4 @@
 import blake2b, { Blake2b } from "blake2b";
-import isEqual from "lodash.isequal";
 import { xxHash32 } from "js-xxhash";
 import { bytes, number, BytesLike } from "@ckb-lumos/codec";
 import { BI, BIish } from "@ckb-lumos/bi";
@@ -170,10 +169,6 @@ function assertHexadecimal(debugPath: string, str: string): void {
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-function isDeepEqual(a: any, b: any): boolean {
-  return isEqual(a, b);
-}
 // Buffer.from('TYPE_ID')
 const TYPE_ID_CODE_HASH =
   "0x00000000000000000000000000000000000000000000000000545950455f4944";
@@ -287,6 +282,5 @@ export {
   hashCode,
   assertHexString,
   assertHexadecimal,
-  isDeepEqual,
   generateTypeIdScript,
 };

packages/base/tests/since.test.js

@@ -1,7 +1,7 @@
 const test = require("ava");
 const { BI } = require("@ckb-lumos/bi");
 
-const { since, utils } = require("../src");
+const { since } = require("../src");
 
 const {
   parseSinceCompatible,
@@ -91,7 +91,11 @@ test.before(() => {
 test("parsedSince", (t) => {
   fixtrues.forEach((v) => {
     const parsed = parseSinceCompatible(v.since);
-    t.true(utils.isDeepEqual(parsed, v.parsed));
+    t.is(parsed.type, v.parsed.type);
+    t.is(parsed.relative, v.parsed.relative);
+    BI.isBI(parsed.value)
+      ? t.true(parsed.value.eq(v.parsed.value))
+      : t.deepEqual(parsed.value, v.parsed.value);
   });
 });
 

packages/crypto/.gitignore

@@ -0,0 +1 @@
+lib

packages/crypto/README.md

@@ -0,0 +1,20 @@
+# @ckb-lumos/crypto
+
+Low-level cryptographic primitives for Lumos, works in both Node.js and browsers. The API is compatible with `node:crypto`
+
+## Usage
+
+The `package.json` defined the entry point for both Node.js and browsers. You can just import
+
+```ts
+import { createHash } from "@ckb-lumos/crypto";
+```
+
+### Manually
+
+```typescript
+// In Node.js
+import { createHash } from "@ckb-lumos/crypto";
+// In browsers
+import { createHash } from "@ckb-lumos/crypto/lib/crypto-browser";
+```

packages/crypto/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@ckb-lumos/crypto",
+  "version": "0.20.0",
+  "description": "Crypto library for Lumos",
+  "author": "",
+  "homepage": "https://github.com/ckb-js/lumos#readme",
+  "license": "MIT",
+  "browser": "./lib/crypto-browser.js",
+  "types": "lib/crypto.d.ts",
+  "main": "./lib/crypto.js",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "directories": {
+    "lib": "lib",
+    "test": "tests"
+  },
+  "files": [
+    "lib",
+    "src"
+  ],
+  "dependencies": {
+    "@noble/hashes": "1.3.1",
+    "@noble/secp256k1": "2.0.0",
+    "@types/aes-js": "^3.1.1",
+    "browserify-aes": "^1.2.0",
+    "scrypt-js": "^3.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ckb-js/lumos.git"
+  },
+  "scripts": {
+    "fmt": "prettier --write \"{src,tests,examples}/**/*.ts\" package.json",
+    "lint": "eslint -c ../../.eslintrc.js \"{src,tests,examples}/**/*.ts\"",
+    "build": "npm run build:types && npm run build:js",
+    "build:types": "tsc --declaration --emitDeclarationOnly",
+    "build:js": "babel --root-mode upward src --out-dir lib --extensions .ts -s",
+    "clean": "rm -rf lib",
+    "prepublishOnly": "npm run clean && npm run build",
+    "release": "npm publish"
+  },
+  "bugs": {
+    "url": "https://github.com/ckb-js/lumos/issues"
+  },
+  "ava": {
+    "extensions": [
+      "ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

packages/crypto/src/crypto-browser.ts

@@ -0,0 +1,67 @@
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./third.d.ts" />
+import { hmac } from "@noble/hashes/hmac";
+import { sha512 } from "@noble/hashes/sha512";
+import { sha256 } from "@noble/hashes/sha256";
+import { ripemd160 } from "@noble/hashes/ripemd160";
+// the noble/hashes is not compatible with the https://ethereum.org/en/developers/docs/data-structures-and-encoding/web3-secret-storage/#scrypt
+// import { scrypt } from "@noble/hashes/scrypt";
+import { randomBytes as _randomBytes } from "@noble/hashes/utils";
+import { pbkdf2 as _pbkdf2 } from "@noble/hashes/pbkdf2";
+import type { Hash, HashAlgo } from "./types";
+// TODO may replace with the crypto.subtle API
+import {
+  createCipheriv as _createCipheriv,
+  createDecipheriv as _createDecipheriv,
+} from "browserify-aes";
+import { Cipher } from "./types";
+
+function _createHash(algorithm: HashAlgo) {
+  if (algorithm === "sha512") return sha512;
+  if (algorithm === "sha256") return sha256;
+  if (algorithm === "ripemd160") return ripemd160;
+  throw new Error(`Unknown hash algorithm ${algorithm}`);
+}
+
+export function createHash(algorithm: HashAlgo): Hash {
+  return _createHash(algorithm).create();
+}
+
+export function createHmac(algorithm: HashAlgo, key: Uint8Array): Hash {
+  return hmac.create(_createHash(algorithm), key);
+}
+
+export function randomBytes(bytesLen: number): Uint8Array {
+  return _randomBytes(bytesLen);
+}
+
+export function createCipheriv(
+  algorithm: string,
+  key: Uint8Array,
+  iv: Uint8Array
+): Cipher {
+  return _createCipheriv(algorithm, key, iv);
+}
+
+export function createDecipheriv(
+  algorithm: string,
+  key: Uint8Array,
+  iv: Uint8Array
+): Cipher {
+  return _createDecipheriv(algorithm, key, iv);
+}
+
+export function pbkdf2Sync(
+  password: Uint8Array,
+  salt: Uint8Array,
+  iterations: number,
+  keyLen: number,
+  digest: HashAlgo
+): Uint8Array {
+  return _pbkdf2(_createHash(digest), password, salt, {
+    dkLen: keyLen,
+    c: iterations,
+  });
+}
+
+export { scryptSync, scrypt } from "./scrypt";

packages/crypto/src/crypto.ts

@@ -0,0 +1,50 @@
+import {
+  createHmac as _createHmac,
+  createHash as _createHash,
+  scryptSync as _scryptSync,
+  randomBytes as _randomBytes,
+  createCipheriv as _createCipheriv,
+  createDecipheriv as _createDecipheriv,
+  pbkdf2Sync as _pbkdf2Sync,
+} from "node:crypto";
+import type { Cipher, Hash, HashAlgo } from "./types";
+
+export function createHash(algorithm: HashAlgo): Hash {
+  return _createHash(algorithm);
+}
+
+export function createHmac(algorithm: HashAlgo, key: Uint8Array): Hash {
+  return _createHmac(algorithm, key);
+}
+
+export function randomBytes(bytesLen: number): Uint8Array {
+  return _randomBytes(bytesLen);
+}
+
+export function createCipheriv(
+  algorithm: string,
+  key: Uint8Array,
+  iv: Uint8Array
+): Cipher {
+  return _createCipheriv(algorithm, key, iv);
+}
+
+export function createDecipheriv(
+  algorithm: string,
+  key: Uint8Array,
+  iv: Uint8Array
+): Cipher {
+  return _createDecipheriv(algorithm, key, iv);
+}
+
+export function pbkdf2Sync(
+  password: Uint8Array,
+  salt: Uint8Array,
+  iterations: number,
+  keyLen: number,
+  digest: HashAlgo
+): Uint8Array {
+  return _pbkdf2Sync(password, salt, iterations, keyLen, digest);
+}
+
+export { scryptSync, scrypt } from "./scrypt";

packages/crypto/src/scrypt.ts

@@ -0,0 +1,32 @@
+import { syncScrypt as _scryptSync, scrypt as _scrypt } from "scrypt-js";
+import { ScryptOptions } from "./types";
+
+function assertOptions(
+  options: ScryptOptions
+): asserts options is Required<ScryptOptions> {
+  if (!options.r || !options.p || !options.N) {
+    throw new Error(
+      `Invalid scrypt options ${JSON.stringify(options)}, r, p, N are required`
+    );
+  }
+}
+
+export function scryptSync(
+  password: Uint8Array,
+  salt: Uint8Array,
+  dkLen: number,
+  options: ScryptOptions
+): Uint8Array {
+  assertOptions(options);
+  return _scryptSync(password, salt, options.N, options.r, options.p, dkLen);
+}
+
+export function scrypt(
+  password: Uint8Array,
+  salt: Uint8Array,
+  dkLen: number,
+  options: ScryptOptions
+): Promise<Uint8Array> {
+  assertOptions(options);
+  return _scrypt(password, salt, options.N, options.r, options.p, dkLen);
+}