eth-crypto-ts 0.0.3 → 0.0.6

package/dist/lib/create-identity.d.ts

@@ -1,16 +1,17 @@
+export declare const DEFAULT_ENTROPY_BYTES = 32;
+export declare const MINIMUM_SHANNON_ENTROPY = 4;
 /**
- * create a privateKey from the given entropy or a new one
- * @param  {Buffer} entropy
- * @return {string}
+ * creates a new private key
+ * @param { Uint8Array } entropy - optional entropy to create the private key
+ * @returns a new private key
  */
-export declare function createPrivateKey(entropy?: Buffer): string;
+export declare const createPrivateKey: (entropy?: Uint8Array) => string;
 /**
- * creates a new object with
- * private-, public-Key and address
- * @param {Buffer?} entropy if provided, will use that as single random-source
+ * creates a new identity
+ * @param { Uint8Array } entropy - optional entropy to create the private key
+ * @returns a new pair of private and public key
  */
-export declare function createIdentity(entropy?: Buffer): {
+export declare const createIdentity: (entropy?: Uint8Array) => {
     privateKey: string;
     publicKey: string;
-    address: string;
 };

package/dist/lib/decrypt-with-private-key.d.ts

@@ -1,2 +1,2 @@
-import { Encrypted } from '../types';
-export declare function decryptWithPrivateKey(privateKey: string, encrypted: Encrypted | any): Promise<string>;
+import { Encrypted } from './types';
+export declare const decryptWithPrivateKey: (privateKey: string, encrypted: Encrypted) => string;

package/dist/lib/encrypt-with-public-key.d.ts

@@ -0,0 +1,2 @@
+import { EncryptionOptions } from './types';
+export declare const encryptWithPublicKey: (publicKey: string, message: string, options?: EncryptionOptions) => import("./types").Encrypted;

package/dist/lib/encryption-utils.d.ts

@@ -0,0 +1,18 @@
+import { Encrypted, EncryptionOptions } from './types';
+/**
+ *  See https://github.com/bitchan/eccrypto for the original implementation that eth-crypto used, it's ancient and not maintained.
+ */
+/**
+ * Encrypts a message using the recipient's public key.
+ * @param {string} publicKeyTo - The recipient's public key.
+ * @param {string} msg - The message to encrypt.
+ * @returns {Encrypted} The encrypted message.
+ */
+export declare const encrypt: (publicKeyTo: string, msg: string, options?: EncryptionOptions) => Encrypted;
+/**
+ * Decrypts an encrypted message using the recipient's private key.
+ * @param {string} privateKey - The recipient's private key.
+ * @param {Encrypted} opts - The encrypted message.
+ * @returns {string} The decrypted message.
+ */
+export declare const decrypt: (privateKey: string, opts: Encrypted) => string;

package/dist/lib/hash.d.ts

@@ -0,0 +1 @@
+export declare const keccak256: (params: string) => string;

package/dist/lib/index.d.ts

@@ -0,0 +1,27 @@
+import { createIdentity } from './create-identity';
+import { sign } from './sign';
+import { encryptWithPublicKey } from './encrypt-with-public-key';
+import { decryptWithPrivateKey } from './decrypt-with-private-key';
+import { keccak256 } from './hash';
+import { publicKeyByPrivateKey } from './public-key-by-private-key';
+import { recoverPublicKey } from './recoverPublicKey';
+declare const hash: {
+    keccak256: (params: string) => string;
+};
+export { createIdentity, decryptWithPrivateKey, encryptWithPublicKey, hash, keccak256, publicKeyByPrivateKey, recoverPublicKey, sign, };
+declare const _default: {
+    createIdentity: (entropy?: Uint8Array) => {
+        privateKey: string;
+        publicKey: string;
+    };
+    decryptWithPrivateKey: (privateKey: string, encrypted: import("./types").Encrypted) => string;
+    encryptWithPublicKey: (publicKey: string, message: string, options?: import("./types").EncryptionOptions) => import("./types").Encrypted;
+    hash: {
+        keccak256: (params: string) => string;
+    };
+    keccak256: (params: string) => string;
+    publicKeyByPrivateKey: (privateKey: string) => string;
+    recoverPublicKey: (signature: string, hash: string) => string;
+    sign: (privateKey: string, hash: string) => string;
+};
+export default _default;

package/dist/lib/public-key-by-private-key.d.ts

@@ -2,7 +2,6 @@
  * Generate publicKey from the privateKey.
  * This creates the uncompressed publicKey,
  * where 04 has stripped from left
- * @param {string} privateKey
  * @returns {string}
  */
-export declare function publicKeyByPrivateKey(privateKey: string): string;
+export declare const publicKeyByPrivateKey: (privateKey: string) => string;

package/dist/lib/{recover-public-key.d.ts → recoverPublicKey.d.ts}

@@ -4,4 +4,4 @@
  * @param  {string} hash
  * @return {string} publicKey
  */
-export declare function recoverPublicKey(signature: string, hash: string): string;
+export declare const recoverPublicKey: (signature: string, hash: string) => string;

package/dist/lib/sign.d.ts

@@ -1,8 +1,8 @@
 /**
  * signs the given message
- * we do not use sign from eth-lib because the pure secp256k1-version is 90% faster
  * @param  {string} privateKey
  * @param  {string} hash
  * @return {string} hexString
  */
-export declare function sign(privateKey: string, hash: string): string;
+export declare const sign: (privateKey: string, hash: string) => string;
+export declare const hmacSha256Sign: (key: Uint8Array, msg: Uint8Array) => Uint8Array;

package/dist/{types → lib/types}/index.d.ts

@@ -4,7 +4,6 @@ export type Encrypted = {
     ciphertext: string;
     mac: string;
 };
-export type EncryptOptions = {
-    iv?: Buffer;
-    ephemPrivateKey?: Buffer;
+export type EncryptionOptions = {
+    ephemPrivateKey?: string;
 };

package/dist/lib/utils.d.ts

@@ -1,4 +1,37 @@
-export declare function removeLeading0x(str: string): string;
-export declare function addLeading0x(str: string): string;
-export declare function uint8ArrayToHex(arr: any[] | Uint8Array): string;
-export declare function hexToUnit8Array(str: string): Uint8Array;
+/**
+ * Returns a `Boolean` on whether or not the a `String` starts with '0x'
+ * @param str the string input value
+ * @return a boolean if it is or is not hex prefixed
+ * @throws if the str input is not a string
+ */
+export declare const isHexPrefixed: (str: string) => boolean;
+/**
+ * Removes '0x' from a given `String` if present
+ * @param str the string value
+ * @returns the string without 0x prefix
+ */
+export declare const stripHexPrefix: (str: string) => string;
+/**
+ * Is the string a hex string.
+ *
+ * @param  value
+ * @param  length
+ * @returns  output the string is a hex string
+ */
+export declare const isHexString: (value: string, length?: number) => boolean;
+/**
+ * Adds '0x' to a given `String` if not present
+ * @param str the string input value
+ * @return the string with a 0x prefix
+ */
+export declare const addLeading0x: (str: string) => string;
+export declare const decompress: (startsWith02Or03: string) => string;
+/** Helper function to concat UInt8Arrays mimicking the behaviour of the
+ *  Buffer.concat function in Node.js
+ */
+export declare const concatUint8Arrays: (uint8arrays: Uint8Array[]) => Uint8Array;
+/**
+ * Converts a UTF-8 string to a Uint8Array without using TextEncoder, which is not available in mobile
+ * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+ */
+export declare const utf8ToBytes: (str: string) => Uint8Array;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eth-crypto-ts",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "eth-crypto library with typescript",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.esm.js",
@@ -22,18 +22,22 @@
     "build": "rollup --config --sourcemap --validate --bundleConfigAsCjs",
     "build:prod": "npm run build --compact --environment production",
     "build:dev": "rollup --config --bundleConfigAsCjs --watch",
-    "test": "NODE_ENV=test jest",
+    "test": "NODE_ENV=test jest --runInBand --detectOpenHandles --coverage",
     "test:watch": "NODE_ENV=test jest --watch",
     "lint": "eslint",
+    "lint:fix": "eslint --fix",
     "audit-ci": "audit-ci --config audit-ci.jsonc",
     "release": "npm publish --access-public"
   },
-  "author": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tarekbeb/eth-crypto-ts"
+  },
+  "author": "tarekbeb",
   "license": "ISC",
   "dependencies": {
-    "eccrypto": "^1.1.6",
-    "ethereumjs-util": "^7.1.5",
-    "ethers": "^6.13.1",
+    "@noble/hashes": "^1.8.0",
+    "ethereum-cryptography": "^3.2.0",
     "secp256k1": "^5.0.0"
   },
   "devDependencies": {
@@ -43,18 +47,28 @@
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^11.1.6",
     "@types/eccrypto": "^1.1.6",
-    "@types/secp256k1": "^4.0.6",
     "@types/jest": "^29.5.0",
+    "@types/secp256k1": "^4.0.6",
+    "@typescript-eslint/eslint-plugin": "^8.58.1",
+    "@typescript-eslint/parser": "^8.58.1",
     "audit-ci": "^7.0.1",
-    "ts-jest": "^29.1.0",
-    "jest-environment-jsdom": "^29.5.0",
     "eslint": "^9.5.0",
+    "eslint-plugin-prettier": "^5.5.5",
     "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.5.0",
+    "prettier": "^3.8.2",
     "rimraf": "^5.0.7",
     "rollup": "^4.18.0",
     "rollup-plugin-node-builtins": "^2.0.0",
     "rollup-plugin-node-globals": "^1.4.0",
     "rollup-plugin-polyfill-node": "^0.13.0",
+    "ts-jest": "^29.1.0",
     "typescript": "^5.5.2"
+  },
+  "overrides": {
+    "serialize-javascript": "^7.0.3",
+    "@tootallnate/once": "^3.0.1",
+    "semver": "^5.7.2",
+    "bl": "^0.9.5"
   }
 }

package/dist/lib/cipher/index.d.ts

@@ -1,11 +0,0 @@
-import { Encrypted } from '../../types';
-interface CipherInterface {
-    stringify(encrypted: Encrypted): string;
-    parse(string: string): Encrypted;
-}
-export declare class Cipher implements CipherInterface {
-    constructor();
-    stringify(encrypted: Encrypted): string;
-    parse(str: string): Encrypted;
-}
-export {};

package/dist/lib/compress-public-key.d.ts

@@ -1 +0,0 @@
-export declare function compress(startsWith04: any): string;

package/dist/lib/decompress-public-key.d.ts

@@ -1 +0,0 @@
-export declare function decompress(startsWith02Or03: any): string;

package/dist/lib/encrypt-with-private-key.d.ts

@@ -1,2 +0,0 @@
-import { Encrypted, EncryptOptions } from '../types';
-export declare function encryptWithPublicKey(publicKey: string, message: string, options?: EncryptOptions): Promise<Encrypted>;

package/dist/lib/hash/index.d.ts

@@ -1,4 +0,0 @@
-export declare class Hash {
-    constructor();
-    keccak256(params: any | any[]): string;
-}