@pezkuwi/util-crypto 14.0.2 → 14.0.4

package/cjs/bridge.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bridge = void 0;
+const util_1 = require("@pezkuwi/util");
+const wbg_js_1 = require("./wbg.js");
+/**
+ * @name Bridge
+ * @description
+ * Creates a bridge between the JS and WASM environments.
+ *
+ * For any bridge it is passed an function which is then called internally at the
+ * time of initialization. This affectively implements the layer between WASM and
+ * the native environment, providing all the plumbing needed for the Wbg classes.
+ */
+class Bridge {
+    #createWasm;
+    #heap;
+    #wbg;
+    #cachegetInt32;
+    #cachegetUint8;
+    #heapNext;
+    #wasm;
+    #wasmError;
+    #wasmPromise;
+    #type;
+    constructor(createWasm) {
+        this.#createWasm = createWasm;
+        this.#cachegetInt32 = null;
+        this.#cachegetUint8 = null;
+        this.#heap = new Array(32)
+            .fill(undefined)
+            .concat(undefined, null, true, false);
+        this.#heapNext = this.#heap.length;
+        this.#type = 'none';
+        this.#wasm = null;
+        this.#wasmError = null;
+        this.#wasmPromise = null;
+        this.#wbg = { ...new wbg_js_1.Wbg(this) };
+    }
+    /** @description Returns the init error */
+    get error() {
+        return this.#wasmError;
+    }
+    /** @description Returns the init type */
+    get type() {
+        return this.#type;
+    }
+    /** @description Returns the created wasm interface */
+    get wasm() {
+        return this.#wasm;
+    }
+    /** @description Performs the wasm initialization */
+    async init(createWasm) {
+        if (!this.#wasmPromise || createWasm) {
+            this.#wasmPromise = (createWasm || this.#createWasm)(this.#wbg);
+        }
+        const { error, type, wasm } = await this.#wasmPromise;
+        this.#type = type;
+        this.#wasm = wasm;
+        this.#wasmError = error;
+        return this.#wasm;
+    }
+    /**
+     * @internal
+     * @description Gets an object from the heap
+     */
+    getObject(idx) {
+        return this.#heap[idx];
+    }
+    /**
+     * @internal
+     * @description Removes an object from the heap
+     */
+    dropObject(idx) {
+        if (idx < 36) {
+            return;
+        }
+        this.#heap[idx] = this.#heapNext;
+        this.#heapNext = idx;
+    }
+    /**
+     * @internal
+     * @description Retrieves and removes an object to the heap
+     */
+    takeObject(idx) {
+        const ret = this.getObject(idx);
+        this.dropObject(idx);
+        return ret;
+    }
+    /**
+     * @internal
+     * @description Adds an object to the heap
+     */
+    addObject(obj) {
+        if (this.#heapNext === this.#heap.length) {
+            this.#heap.push(this.#heap.length + 1);
+        }
+        const idx = this.#heapNext;
+        this.#heapNext = this.#heap[idx];
+        this.#heap[idx] = obj;
+        return idx;
+    }
+    /**
+     * @internal
+     * @description Retrieve an Int32 in the WASM interface
+     */
+    getInt32() {
+        if (this.#cachegetInt32 === null || this.#cachegetInt32.buffer !== this.#wasm.memory.buffer) {
+            this.#cachegetInt32 = new Int32Array(this.#wasm.memory.buffer);
+        }
+        return this.#cachegetInt32;
+    }
+    /**
+     * @internal
+     * @description Retrieve an Uint8Array in the WASM interface
+     */
+    getUint8() {
+        if (this.#cachegetUint8 === null || this.#cachegetUint8.buffer !== this.#wasm.memory.buffer) {
+            this.#cachegetUint8 = new Uint8Array(this.#wasm.memory.buffer);
+        }
+        return this.#cachegetUint8;
+    }
+    /**
+     * @internal
+     * @description Retrieves an Uint8Array in the WASM interface
+     */
+    getU8a(ptr, len) {
+        return this.getUint8().subarray(ptr / 1, ptr / 1 + len);
+    }
+    /**
+     * @internal
+     * @description Retrieves a string in the WASM interface
+     */
+    getString(ptr, len) {
+        return (0, util_1.u8aToString)(this.getU8a(ptr, len));
+    }
+    /**
+     * @internal
+     * @description Allocates an Uint8Array in the WASM interface
+     */
+    allocU8a(arg) {
+        const ptr = this.#wasm.__wbindgen_malloc(arg.length * 1);
+        this.getUint8().set(arg, ptr / 1);
+        return [ptr, arg.length];
+    }
+    /**
+     * @internal
+     * @description Allocates a string in the WASM interface
+     */
+    allocString(arg) {
+        return this.allocU8a((0, util_1.stringToU8a)(arg));
+    }
+    /**
+     * @internal
+     * @description Retrieves an Uint8Array from the WASM interface
+     */
+    resultU8a() {
+        const r0 = this.getInt32()[8 / 4 + 0];
+        const r1 = this.getInt32()[8 / 4 + 1];
+        const ret = this.getU8a(r0, r1).slice();
+        this.#wasm.__wbindgen_free(r0, r1 * 1);
+        return ret;
+    }
+    /**
+     * @internal
+     * @description Retrieve a string from the WASM interface
+     */
+    resultString() {
+        return (0, util_1.u8aToString)(this.resultU8a());
+    }
+}
+exports.Bridge = Bridge;

package/cjs/bundle.d.ts

@@ -0,0 +1,26 @@
+import './bundleInit.js';
+export { packageInfo } from './packageInfo.js';
+export * from './address/index.js';
+export * from './base32/index.js';
+export * from './base58/index.js';
+export * from './base64/index.js';
+export * from './blake2/index.js';
+export * from './crypto.js';
+export * from './ed25519/index.js';
+export * from './ethereum/index.js';
+export * from './hd/index.js';
+export * from './hmac/index.js';
+export * from './json/index.js';
+export * from './keccak/index.js';
+export * from './key/index.js';
+export * from './mnemonic/index.js';
+export * from './nacl/index.js';
+export * from './networks.js';
+export * from './pbkdf2/index.js';
+export * from './random/index.js';
+export * from './scrypt/index.js';
+export * from './secp256k1/index.js';
+export * from './sha/index.js';
+export * from './signature/index.js';
+export * from './sr25519/index.js';
+export * from './xxhash/index.js';

package/cjs/bundle.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+const tslib_1 = require("tslib");
+require("./bundleInit.js");
+var packageInfo_js_1 = require("./packageInfo.js");
+Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+tslib_1.__exportStar(require("./address/index.js"), exports);
+tslib_1.__exportStar(require("./base32/index.js"), exports);
+tslib_1.__exportStar(require("./base58/index.js"), exports);
+tslib_1.__exportStar(require("./base64/index.js"), exports);
+tslib_1.__exportStar(require("./blake2/index.js"), exports);
+tslib_1.__exportStar(require("./crypto.js"), exports);
+tslib_1.__exportStar(require("./ed25519/index.js"), exports);
+tslib_1.__exportStar(require("./ethereum/index.js"), exports);
+tslib_1.__exportStar(require("./hd/index.js"), exports);
+tslib_1.__exportStar(require("./hmac/index.js"), exports);
+tslib_1.__exportStar(require("./json/index.js"), exports);
+tslib_1.__exportStar(require("./keccak/index.js"), exports);
+tslib_1.__exportStar(require("./key/index.js"), exports);
+tslib_1.__exportStar(require("./mnemonic/index.js"), exports);
+tslib_1.__exportStar(require("./nacl/index.js"), exports);
+tslib_1.__exportStar(require("./networks.js"), exports);
+tslib_1.__exportStar(require("./pbkdf2/index.js"), exports);
+tslib_1.__exportStar(require("./random/index.js"), exports);
+tslib_1.__exportStar(require("./scrypt/index.js"), exports);
+tslib_1.__exportStar(require("./secp256k1/index.js"), exports);
+tslib_1.__exportStar(require("./sha/index.js"), exports);
+tslib_1.__exportStar(require("./signature/index.js"), exports);
+tslib_1.__exportStar(require("./sr25519/index.js"), exports);
+tslib_1.__exportStar(require("./xxhash/index.js"), exports);

package/cjs/bundleInit.d.ts

@@ -0,0 +1 @@
+import '@polkadot/x-bigint/shim';

package/cjs/bundleInit.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@pezkuwi/x-bigint/shim");
+const crypto_js_1 = require("./crypto.js");
+(0, crypto_js_1.cryptoWaitReady)().catch(() => {
+    // shouldn't happen, logged and caught inside cryptoWaitReady
+});

package/cjs/crypto.d.ts

@@ -0,0 +1,3 @@
+import { isReady } from '@polkadot/wasm-crypto';
+export declare const cryptoIsReady: typeof isReady;
+export declare function cryptoWaitReady(): Promise<boolean>;

package/cjs/crypto.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cryptoIsReady = void 0;
+exports.cryptoWaitReady = cryptoWaitReady;
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+exports.cryptoIsReady = wasm_crypto_1.isReady;
+function cryptoWaitReady() {
+    return (0, wasm_crypto_1.waitReady)()
+        .then(() => {
+        if (!(0, wasm_crypto_1.isReady)()) {
+            throw new Error('Unable to initialize @pezkuwi/util-crypto');
+        }
+        return true;
+    })
+        .catch(() => false);
+}

package/cjs/ed25519/deriveHard.d.ts

@@ -0,0 +1 @@
+export declare function ed25519DeriveHard(seed: Uint8Array, chainCode: Uint8Array): Uint8Array;

package/cjs/ed25519/deriveHard.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519DeriveHard = ed25519DeriveHard;
+const util_1 = require("@pezkuwi/util");
+const asU8a_js_1 = require("../blake2/asU8a.js");
+const HDKD = (0, util_1.compactAddLength)((0, util_1.stringToU8a)('Ed25519HDKD'));
+function ed25519DeriveHard(seed, chainCode) {
+    if (!(0, util_1.isU8a)(chainCode) || chainCode.length !== 32) {
+        throw new Error('Invalid chainCode passed to derive');
+    }
+    return (0, asU8a_js_1.blake2AsU8a)((0, util_1.u8aConcat)(HDKD, seed, chainCode));
+}

package/{src/ed25519/index.ts → cjs/ed25519/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Implements ed25519 operations
  */

package/cjs/ed25519/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519Verify = exports.ed25519Sign = exports.ed25519PairFromString = exports.ed25519PairFromSeed = exports.ed25519PairFromSecret = exports.ed25519PairFromRandom = exports.ed25519DeriveHard = void 0;
+/**
+ * @summary Implements ed25519 operations
+ */
+var deriveHard_js_1 = require("./deriveHard.js");
+Object.defineProperty(exports, "ed25519DeriveHard", { enumerable: true, get: function () { return deriveHard_js_1.ed25519DeriveHard; } });
+var fromRandom_js_1 = require("./pair/fromRandom.js");
+Object.defineProperty(exports, "ed25519PairFromRandom", { enumerable: true, get: function () { return fromRandom_js_1.ed25519PairFromRandom; } });
+var fromSecret_js_1 = require("./pair/fromSecret.js");
+Object.defineProperty(exports, "ed25519PairFromSecret", { enumerable: true, get: function () { return fromSecret_js_1.ed25519PairFromSecret; } });
+var fromSeed_js_1 = require("./pair/fromSeed.js");
+Object.defineProperty(exports, "ed25519PairFromSeed", { enumerable: true, get: function () { return fromSeed_js_1.ed25519PairFromSeed; } });
+var fromString_js_1 = require("./pair/fromString.js");
+Object.defineProperty(exports, "ed25519PairFromString", { enumerable: true, get: function () { return fromString_js_1.ed25519PairFromString; } });
+var sign_js_1 = require("./sign.js");
+Object.defineProperty(exports, "ed25519Sign", { enumerable: true, get: function () { return sign_js_1.ed25519Sign; } });
+var verify_js_1 = require("./verify.js");
+Object.defineProperty(exports, "ed25519Verify", { enumerable: true, get: function () { return verify_js_1.ed25519Verify; } });

package/cjs/ed25519/pair/fromRandom.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name ed25519PairFromRandom
+ * @summary Creates a new public/secret keypair.
+ * @description
+ * Returns a new generate object containing a `publicKey` & `secretKey`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromRandom } from '@polkadot/util-crypto';
+ *
+ * ed25519PairFromRandom(); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export declare function ed25519PairFromRandom(): Keypair;

package/cjs/ed25519/pair/fromRandom.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519PairFromRandom = ed25519PairFromRandom;
+const index_js_1 = require("../../random/index.js");
+const fromSeed_js_1 = require("./fromSeed.js");
+/**
+ * @name ed25519PairFromRandom
+ * @summary Creates a new public/secret keypair.
+ * @description
+ * Returns a new generate object containing a `publicKey` & `secretKey`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromRandom } from '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromRandom(); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+function ed25519PairFromRandom() {
+    return (0, fromSeed_js_1.ed25519PairFromSeed)((0, index_js_1.randomAsU8a)());
+}

package/cjs/ed25519/pair/fromSecret.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name ed25519PairFromSecret
+ * @summary Creates a new public/secret keypair from a secret.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied secret.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromSecret } from '@polkadot/util-crypto';
+ *
+ * ed25519PairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export declare function ed25519PairFromSecret(secretKey: Uint8Array): Keypair;

package/{src/ed25519/pair/fromSecret.ts → cjs/ed25519/pair/fromSecret.js}

@@ -1,8 +1,6 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../../types.js';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519PairFromSecret = ed25519PairFromSecret;
 /**
  * @name ed25519PairFromSecret
  * @summary Creates a new public/secret keypair from a secret.
@@ -17,13 +15,12 @@ import type { Keypair } from '../../types.js';
  * ed25519PairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
  * ```
  */
-export function ed25519PairFromSecret (secretKey: Uint8Array): Keypair {
-  if (secretKey.length !== 64) {
-    throw new Error('Invalid secretKey provided');
-  }
-
-  return {
-    publicKey: secretKey.slice(32),
-    secretKey
-  };
+function ed25519PairFromSecret(secretKey) {
+    if (secretKey.length !== 64) {
+        throw new Error('Invalid secretKey provided');
+    }
+    return {
+        publicKey: secretKey.slice(32),
+        secretKey
+    };
 }

package/cjs/ed25519/pair/fromSeed.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name ed25519PairFromSeed
+ * @summary Creates a new public/secret keypair from a seed.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromSeed } from '@polkadot/util-crypto';
+ *
+ * ed25519PairFromSeed(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export declare function ed25519PairFromSeed(seed: Uint8Array, onlyJs?: boolean): Keypair;

package/cjs/ed25519/pair/fromSeed.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519PairFromSeed = ed25519PairFromSeed;
+const ed25519_1 = require("@noble/curves/ed25519");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+/**
+ * @name ed25519PairFromSeed
+ * @summary Creates a new public/secret keypair from a seed.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromSeed } from '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromSeed(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+function ed25519PairFromSeed(seed, onlyJs) {
+    if (!util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())) {
+        const full = (0, wasm_crypto_1.ed25519KeypairFromSeed)(seed);
+        return {
+            publicKey: full.slice(32),
+            secretKey: full.slice(0, 64)
+        };
+    }
+    const publicKey = ed25519_1.ed25519.getPublicKey(seed);
+    return {
+        publicKey,
+        secretKey: (0, util_1.u8aConcatStrict)([seed, publicKey])
+    };
+}

package/cjs/ed25519/pair/fromString.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name ed25519PairFromString
+ * @summary Creates a new public/secret keypair from a string.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied string. The string is hashed and the value used as the input seed.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromString } from '@polkadot/util-crypto';
+ *
+ * ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export declare function ed25519PairFromString(value: string): Keypair;

package/cjs/ed25519/pair/fromString.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519PairFromString = ed25519PairFromString;
+const util_1 = require("@pezkuwi/util");
+const asU8a_js_1 = require("../../blake2/asU8a.js");
+const fromSeed_js_1 = require("./fromSeed.js");
+/**
+ * @name ed25519PairFromString
+ * @summary Creates a new public/secret keypair from a string.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied string. The string is hashed and the value used as the input seed.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromString } from '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+function ed25519PairFromString(value) {
+    return (0, fromSeed_js_1.ed25519PairFromSeed)((0, asU8a_js_1.blake2AsU8a)((0, util_1.stringToU8a)(value)));
+}

package/cjs/ed25519/sign.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../types.js';
+/**
+ * @name ed25519Sign
+ * @summary Signs a message using the supplied secretKey
+ * @description
+ * Returns message signature of `message`, using the `secretKey`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519Sign } from '@polkadot/util-crypto';
+ *
+ * ed25519Sign([...], [...]); // => [...]
+ * ```
+ */
+export declare function ed25519Sign(message: string | Uint8Array, { publicKey, secretKey }: Partial<Keypair>, onlyJs?: boolean): Uint8Array;

package/cjs/ed25519/sign.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519Sign = ed25519Sign;
+const ed25519_1 = require("@noble/curves/ed25519");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+/**
+ * @name ed25519Sign
+ * @summary Signs a message using the supplied secretKey
+ * @description
+ * Returns message signature of `message`, using the `secretKey`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519Sign } from '@pezkuwi/util-crypto';
+ *
+ * ed25519Sign([...], [...]); // => [...]
+ * ```
+ */
+function ed25519Sign(message, { publicKey, secretKey }, onlyJs) {
+    if (!secretKey) {
+        throw new Error('Expected a valid secretKey');
+    }
+    else if (!publicKey) {
+        throw new Error('Expected a valid publicKey');
+    }
+    const messageU8a = (0, util_1.u8aToU8a)(message);
+    const privateU8a = secretKey.subarray(0, 32);
+    return !util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())
+        ? (0, wasm_crypto_1.ed25519Sign)(publicKey, privateU8a, messageU8a)
+        : ed25519_1.ed25519.sign(messageU8a, privateU8a);
+}

package/cjs/ed25519/verify.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name ed25519Sign
+ * @summary Verifies the signature on the supplied message.
+ * @description
+ * Verifies the `signature` on `message` with the supplied `publicKey`. Returns `true` on sucess, `false` otherwise.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519Verify } from '@polkadot/util-crypto';
+ *
+ * ed25519Verify([...], [...], [...]); // => true/false
+ * ```
+ */
+export declare function ed25519Verify(message: string | Uint8Array, signature: string | Uint8Array, publicKey: string | Uint8Array, onlyJs?: boolean): boolean;

package/cjs/ed25519/verify.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519Verify = ed25519Verify;
+const ed25519_1 = require("@noble/curves/ed25519");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+/**
+ * @name ed25519Sign
+ * @summary Verifies the signature on the supplied message.
+ * @description
+ * Verifies the `signature` on `message` with the supplied `publicKey`. Returns `true` on sucess, `false` otherwise.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519Verify } from '@pezkuwi/util-crypto';
+ *
+ * ed25519Verify([...], [...], [...]); // => true/false
+ * ```
+ */
+function ed25519Verify(message, signature, publicKey, onlyJs) {
+    const messageU8a = (0, util_1.u8aToU8a)(message);
+    const publicKeyU8a = (0, util_1.u8aToU8a)(publicKey);
+    const signatureU8a = (0, util_1.u8aToU8a)(signature);
+    if (publicKeyU8a.length !== 32) {
+        throw new Error(`Invalid publicKey, received ${publicKeyU8a.length}, expected 32`);
+    }
+    else if (signatureU8a.length !== 64) {
+        throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+    }
+    try {
+        return !util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())
+            ? (0, wasm_crypto_1.ed25519Verify)(signatureU8a, messageU8a, publicKeyU8a)
+            : ed25519_1.ed25519.verify(signatureU8a, messageU8a, publicKeyU8a);
+    }
+    catch {
+        return false;
+    }
+}

package/cjs/ethereum/encode.d.ts

@@ -0,0 +1,2 @@
+import type { HexString } from '@polkadot/util/types';
+export declare function ethereumEncode(addressOrPublic?: string | Uint8Array): HexString;

package/cjs/ethereum/encode.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ethereumEncode = ethereumEncode;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../keccak/index.js");
+const index_js_2 = require("../secp256k1/index.js");
+function getH160(u8a) {
+    if ([33, 65].includes(u8a.length)) {
+        u8a = (0, index_js_1.keccakAsU8a)((0, index_js_2.secp256k1Expand)(u8a));
+    }
+    return u8a.slice(-20);
+}
+function ethereumEncode(addressOrPublic) {
+    if (!addressOrPublic) {
+        return '0x';
+    }
+    const u8aAddress = (0, util_1.u8aToU8a)(addressOrPublic);
+    if (![20, 32, 33, 65].includes(u8aAddress.length)) {
+        throw new Error(`Invalid address or publicKey provided, received ${u8aAddress.length} bytes input`);
+    }
+    const address = (0, util_1.u8aToHex)(getH160(u8aAddress), -1, false);
+    const hash = (0, util_1.u8aToHex)((0, index_js_1.keccakAsU8a)(address), -1, false);
+    let result = '';
+    for (let i = 0; i < 40; i++) {
+        result = `${result}${parseInt(hash[i], 16) > 7 ? address[i].toUpperCase() : address[i]}`;
+    }
+    return `0x${result}`;
+}

package/{src/ethereum/index.ts → cjs/ethereum/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export { ethereumEncode } from './encode.js';
 export { isEthereumAddress } from './isAddress.js';
 export { isEthereumChecksum } from './isChecksum.js';

package/cjs/ethereum/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEthereumChecksum = exports.isEthereumAddress = exports.ethereumEncode = void 0;
+var encode_js_1 = require("./encode.js");
+Object.defineProperty(exports, "ethereumEncode", { enumerable: true, get: function () { return encode_js_1.ethereumEncode; } });
+var isAddress_js_1 = require("./isAddress.js");
+Object.defineProperty(exports, "isEthereumAddress", { enumerable: true, get: function () { return isAddress_js_1.isEthereumAddress; } });
+var isChecksum_js_1 = require("./isChecksum.js");
+Object.defineProperty(exports, "isEthereumChecksum", { enumerable: true, get: function () { return isChecksum_js_1.isEthereumChecksum; } });

package/cjs/ethereum/isAddress.d.ts

@@ -0,0 +1 @@
+export declare function isEthereumAddress(address?: string): boolean;