@pezkuwi/util-crypto 14.0.10 → 14.0.11

package/cjs/scrypt/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scryptToU8a = exports.scryptFromU8a = exports.scryptEncode = void 0;
+var encode_js_1 = require("./encode.js");
+Object.defineProperty(exports, "scryptEncode", { enumerable: true, get: function () { return encode_js_1.scryptEncode; } });
+var fromU8a_js_1 = require("./fromU8a.js");
+Object.defineProperty(exports, "scryptFromU8a", { enumerable: true, get: function () { return fromU8a_js_1.scryptFromU8a; } });
+var toU8a_js_1 = require("./toU8a.js");
+Object.defineProperty(exports, "scryptToU8a", { enumerable: true, get: function () { return toU8a_js_1.scryptToU8a; } });

package/cjs/scrypt/toU8a.d.ts

@@ -0,0 +1,2 @@
+import type { ScryptParams } from './types.js';
+export declare function scryptToU8a(salt: Uint8Array, { N, p, r }: ScryptParams): Uint8Array;

package/cjs/scrypt/toU8a.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scryptToU8a = scryptToU8a;
+const util_1 = require("@pezkuwi/util");
+const bn_js_1 = require("../bn.js");
+function scryptToU8a(salt, { N, p, r }) {
+    return (0, util_1.u8aConcat)(salt, (0, util_1.bnToU8a)(N, bn_js_1.BN_LE_32_OPTS), (0, util_1.bnToU8a)(p, bn_js_1.BN_LE_32_OPTS), (0, util_1.bnToU8a)(r, bn_js_1.BN_LE_32_OPTS));
+}

package/cjs/scrypt/types.d.ts

@@ -0,0 +1,6 @@
+/** The params that control scrypt generation */
+export interface ScryptParams {
+    N: number;
+    p: number;
+    r: number;
+}

package/cjs/scrypt/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/secp256k1/compress.d.ts

@@ -0,0 +1 @@
+export declare function secp256k1Compress(publicKey: Uint8Array, onlyJs?: boolean): Uint8Array;

package/cjs/secp256k1/compress.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secp256k1Compress = secp256k1Compress;
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+function secp256k1Compress(publicKey, onlyJs) {
+    if (![33, 65].includes(publicKey.length)) {
+        throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
+    }
+    if (publicKey.length === 33) {
+        return publicKey;
+    }
+    return !util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())
+        ? (0, wasm_crypto_1.secp256k1Compress)(publicKey)
+        : secp256k1_1.secp256k1.ProjectivePoint.fromHex(publicKey).toRawBytes(true);
+}

package/cjs/secp256k1/deriveHard.d.ts

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

package/cjs/secp256k1/deriveHard.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secp256k1DeriveHard = secp256k1DeriveHard;
+const util_1 = require("@pezkuwi/util");
+const asU8a_js_1 = require("../blake2/asU8a.js");
+const HDKD = (0, util_1.compactAddLength)((0, util_1.stringToU8a)('Secp256k1HDKD'));
+function secp256k1DeriveHard(seed, chainCode) {
+    if (!(0, util_1.isU8a)(chainCode) || chainCode.length !== 32) {
+        throw new Error('Invalid chainCode passed to derive');
+    }
+    // NOTE This is specific to the Substrate HDD derivation, so always use the blake2 hasher
+    return (0, asU8a_js_1.blake2AsU8a)((0, util_1.u8aConcat)(HDKD, seed, chainCode), 256);
+}

package/cjs/secp256k1/expand.d.ts

@@ -0,0 +1 @@
+export declare function secp256k1Expand(publicKey: Uint8Array, onlyJs?: boolean): Uint8Array;

package/cjs/secp256k1/expand.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secp256k1Expand = secp256k1Expand;
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const bn_js_1 = require("../bn.js");
+function secp256k1Expand(publicKey, onlyJs) {
+    if (![33, 65].includes(publicKey.length)) {
+        throw new Error(`Invalid publicKey provided, received ${publicKey.length} bytes input`);
+    }
+    if (publicKey.length === 65) {
+        return publicKey.subarray(1);
+    }
+    if (!util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())) {
+        return (0, wasm_crypto_1.secp256k1Expand)(publicKey).subarray(1);
+    }
+    const { px, py } = secp256k1_1.secp256k1.ProjectivePoint.fromHex(publicKey);
+    return (0, util_1.u8aConcat)((0, util_1.bnToU8a)(px, bn_js_1.BN_BE_256_OPTS), (0, util_1.bnToU8a)(py, bn_js_1.BN_BE_256_OPTS));
+}

package/cjs/secp256k1/hasher.d.ts

@@ -0,0 +1,2 @@
+import type { HashType } from './types.js';
+export declare function hasher(hashType: HashType, data: Uint8Array | string, onlyJs?: boolean): Uint8Array;

package/cjs/secp256k1/hasher.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasher = hasher;
+const index_js_1 = require("../blake2/index.js");
+const index_js_2 = require("../keccak/index.js");
+function hasher(hashType, data, onlyJs) {
+    return hashType === 'keccak'
+        ? (0, index_js_2.keccakAsU8a)(data, undefined, onlyJs)
+        : (0, index_js_1.blake2AsU8a)(data, undefined, undefined, onlyJs);
+}

package/cjs/secp256k1/index.d.ts

@@ -0,0 +1,7 @@
+export { secp256k1Compress } from './compress.js';
+export { secp256k1Expand } from './expand.js';
+export { secp256k1PairFromSeed } from './pair/fromSeed.js';
+export { secp256k1Recover } from './recover.js';
+export { secp256k1Sign } from './sign.js';
+export { secp256k1PrivateKeyTweakAdd } from './tweakAdd.js';
+export { secp256k1Verify } from './verify.js';

package/cjs/secp256k1/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secp256k1Verify = exports.secp256k1PrivateKeyTweakAdd = exports.secp256k1Sign = exports.secp256k1Recover = exports.secp256k1PairFromSeed = exports.secp256k1Expand = exports.secp256k1Compress = void 0;
+var compress_js_1 = require("./compress.js");
+Object.defineProperty(exports, "secp256k1Compress", { enumerable: true, get: function () { return compress_js_1.secp256k1Compress; } });
+var expand_js_1 = require("./expand.js");
+Object.defineProperty(exports, "secp256k1Expand", { enumerable: true, get: function () { return expand_js_1.secp256k1Expand; } });
+var fromSeed_js_1 = require("./pair/fromSeed.js");
+Object.defineProperty(exports, "secp256k1PairFromSeed", { enumerable: true, get: function () { return fromSeed_js_1.secp256k1PairFromSeed; } });
+var recover_js_1 = require("./recover.js");
+Object.defineProperty(exports, "secp256k1Recover", { enumerable: true, get: function () { return recover_js_1.secp256k1Recover; } });
+var sign_js_1 = require("./sign.js");
+Object.defineProperty(exports, "secp256k1Sign", { enumerable: true, get: function () { return sign_js_1.secp256k1Sign; } });
+var tweakAdd_js_1 = require("./tweakAdd.js");
+Object.defineProperty(exports, "secp256k1PrivateKeyTweakAdd", { enumerable: true, get: function () { return tweakAdd_js_1.secp256k1PrivateKeyTweakAdd; } });
+var verify_js_1 = require("./verify.js");
+Object.defineProperty(exports, "secp256k1Verify", { enumerable: true, get: function () { return verify_js_1.secp256k1Verify; } });

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

@@ -0,0 +1,6 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name secp256k1PairFromSeed
+ * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ */
+export declare function secp256k1PairFromSeed(seed: Uint8Array, onlyJs?: boolean): Keypair;

package/cjs/secp256k1/pair/fromSeed.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secp256k1PairFromSeed = secp256k1PairFromSeed;
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+/**
+ * @name secp256k1PairFromSeed
+ * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ */
+function secp256k1PairFromSeed(seed, onlyJs) {
+    if (seed.length !== 32) {
+        throw new Error('Expected valid 32-byte private key as a seed');
+    }
+    if (!util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())) {
+        const full = (0, wasm_crypto_1.secp256k1FromSeed)(seed);
+        const publicKey = full.slice(32);
+        // There is an issue with the secp256k1 when running in an ASM.js environment where
+        // it seems that the lazy static section yields invalid results on the _first_ run.
+        // If this happens, fail outright, we cannot allow invalid return values
+        // https://github.com/polkadot-js/wasm/issues/307
+        if ((0, util_1.u8aEmpty)(publicKey)) {
+            throw new Error('Invalid publicKey generated from WASM interface');
+        }
+        return {
+            publicKey,
+            secretKey: full.slice(0, 32)
+        };
+    }
+    return {
+        publicKey: secp256k1_1.secp256k1.getPublicKey(seed, true),
+        secretKey: seed
+    };
+}

package/cjs/secp256k1/recover.d.ts

@@ -0,0 +1,6 @@
+import type { HashType } from './types.js';
+/**
+ * @name secp256k1Recover
+ * @description Recovers a publicKey from the supplied signature
+ */
+export declare function secp256k1Recover(msgHash: string | Uint8Array, signature: string | Uint8Array, recovery: number, hashType?: HashType, onlyJs?: boolean): Uint8Array;

package/cjs/secp256k1/recover.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secp256k1Recover = secp256k1Recover;
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const compress_js_1 = require("./compress.js");
+const expand_js_1 = require("./expand.js");
+/**
+ * @name secp256k1Recover
+ * @description Recovers a publicKey from the supplied signature
+ */
+function secp256k1Recover(msgHash, signature, recovery, hashType = 'blake2', onlyJs) {
+    const sig = (0, util_1.u8aToU8a)(signature).subarray(0, 64);
+    const msg = (0, util_1.u8aToU8a)(msgHash);
+    const publicKey = !util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())
+        ? (0, wasm_crypto_1.secp256k1Recover)(msg, sig, recovery)
+        : secp256k1_1.secp256k1.Signature
+            .fromCompact(sig)
+            .addRecoveryBit(recovery)
+            .recoverPublicKey(msg)
+            .toRawBytes();
+    if (!publicKey) {
+        throw new Error('Unable to recover publicKey from signature');
+    }
+    return hashType === 'keccak'
+        ? (0, expand_js_1.secp256k1Expand)(publicKey, onlyJs)
+        : (0, compress_js_1.secp256k1Compress)(publicKey, onlyJs);
+}

package/cjs/secp256k1/sign.d.ts

@@ -0,0 +1,7 @@
+import type { Keypair } from '../types.js';
+import type { HashType } from './types.js';
+/**
+ * @name secp256k1Sign
+ * @description Returns message signature of `message`, using the supplied pair
+ */
+export declare function secp256k1Sign(message: Uint8Array | string, { secretKey }: Partial<Keypair>, hashType?: HashType, onlyJs?: boolean): Uint8Array;

package/cjs/secp256k1/sign.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secp256k1Sign = secp256k1Sign;
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const bn_js_1 = require("../bn.js");
+const hasher_js_1 = require("./hasher.js");
+/**
+ * @name secp256k1Sign
+ * @description Returns message signature of `message`, using the supplied pair
+ */
+function secp256k1Sign(message, { secretKey }, hashType = 'blake2', onlyJs) {
+    if (secretKey?.length !== 32) {
+        throw new Error('Expected valid secp256k1 secretKey, 32-bytes');
+    }
+    const data = (0, hasher_js_1.hasher)(hashType, message, onlyJs);
+    if (!util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())) {
+        return (0, wasm_crypto_1.secp256k1Sign)(data, secretKey);
+    }
+    const signature = secp256k1_1.secp256k1.sign(data, secretKey, { lowS: true });
+    return (0, util_1.u8aConcat)((0, util_1.bnToU8a)(signature.r, bn_js_1.BN_BE_256_OPTS), (0, util_1.bnToU8a)(signature.s, bn_js_1.BN_BE_256_OPTS), new Uint8Array([signature.recovery || 0]));
+}

package/cjs/secp256k1/tweakAdd.d.ts

@@ -0,0 +1 @@
+export declare function secp256k1PrivateKeyTweakAdd(seckey: Uint8Array, tweak: Uint8Array, onlyBn?: boolean): Uint8Array;

package/cjs/secp256k1/tweakAdd.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secp256k1PrivateKeyTweakAdd = secp256k1PrivateKeyTweakAdd;
+const util_1 = require("@pezkuwi/util");
+const x_bigint_1 = require("@pezkuwi/x-bigint");
+const bn_js_1 = require("../bn.js");
+const N = 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141'.replace(/ /g, '');
+const N_BI = (0, x_bigint_1.BigInt)(`0x${N}`);
+const N_BN = new util_1.BN(N, 'hex');
+function addBi(seckey, tweak) {
+    let res = (0, util_1.u8aToBigInt)(tweak, bn_js_1.BN_BE_OPTS);
+    if (res >= N_BI) {
+        throw new Error('Tweak parameter is out of range');
+    }
+    res += (0, util_1.u8aToBigInt)(seckey, bn_js_1.BN_BE_OPTS);
+    if (res >= N_BI) {
+        res -= N_BI;
+    }
+    if (res === util_1._0n) {
+        throw new Error('Invalid resulting private key');
+    }
+    return (0, util_1.nToU8a)(res, bn_js_1.BN_BE_256_OPTS);
+}
+function addBn(seckey, tweak) {
+    const res = new util_1.BN(tweak);
+    if (res.cmp(N_BN) >= 0) {
+        throw new Error('Tweak parameter is out of range');
+    }
+    res.iadd(new util_1.BN(seckey));
+    if (res.cmp(N_BN) >= 0) {
+        res.isub(N_BN);
+    }
+    if (res.isZero()) {
+        throw new Error('Invalid resulting private key');
+    }
+    return (0, util_1.bnToU8a)(res, bn_js_1.BN_BE_256_OPTS);
+}
+function secp256k1PrivateKeyTweakAdd(seckey, tweak, onlyBn) {
+    if (!(0, util_1.isU8a)(seckey) || seckey.length !== 32) {
+        throw new Error('Expected seckey to be an Uint8Array with length 32');
+    }
+    else if (!(0, util_1.isU8a)(tweak) || tweak.length !== 32) {
+        throw new Error('Expected tweak to be an Uint8Array with length 32');
+    }
+    return !util_1.hasBigInt || onlyBn
+        ? addBn(seckey, tweak)
+        : addBi(seckey, tweak);
+}

package/cjs/secp256k1/types.d.ts

@@ -0,0 +1 @@
+export type HashType = 'blake2' | 'keccak';

package/cjs/secp256k1/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/secp256k1/verify.d.ts

@@ -0,0 +1,6 @@
+import type { HashType } from './types.js';
+/**
+ * @name secp256k1Verify
+ * @description Verifies the signature of `message`, using the supplied pair
+ */
+export declare function secp256k1Verify(msgHash: string | Uint8Array, signature: string | Uint8Array, address: string | Uint8Array, hashType?: HashType, onlyJs?: boolean): boolean;

package/cjs/secp256k1/verify.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secp256k1Verify = secp256k1Verify;
+const util_1 = require("@pezkuwi/util");
+const hasher_js_1 = require("./hasher.js");
+const recover_js_1 = require("./recover.js");
+/**
+ * @name secp256k1Verify
+ * @description Verifies the signature of `message`, using the supplied pair
+ */
+function secp256k1Verify(msgHash, signature, address, hashType = 'blake2', onlyJs) {
+    const sig = (0, util_1.u8aToU8a)(signature);
+    if (sig.length !== 65) {
+        throw new Error(`Expected signature with 65 bytes, ${sig.length} found instead`);
+    }
+    const publicKey = (0, recover_js_1.secp256k1Recover)((0, hasher_js_1.hasher)(hashType, msgHash), sig, sig[64], hashType, onlyJs);
+    const signerAddr = (0, hasher_js_1.hasher)(hashType, publicKey, onlyJs);
+    const inputAddr = (0, util_1.u8aToU8a)(address);
+    // for Ethereum (keccak) the last 20 bytes is the address
+    return (0, util_1.u8aEq)(publicKey, inputAddr) || (hashType === 'keccak'
+        ? (0, util_1.u8aEq)(signerAddr.slice(-20), inputAddr.slice(-20))
+        : (0, util_1.u8aEq)(signerAddr, inputAddr));
+}

package/cjs/sha/asU8a.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name shaAsU8a
+ * @summary Creates a sha Uint8Array from the input.
+ */
+export declare const shaAsU8a: (value: string | Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name sha256AsU8a
+ * @summary Creates a sha256 Uint8Array from the input.
+ */
+export declare const sha256AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name sha512AsU8a
+ * @summary Creates a sha512 Uint8Array from the input.
+ */
+export declare const sha512AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;

package/cjs/sha/asU8a.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha512AsU8a = exports.sha256AsU8a = exports.shaAsU8a = void 0;
+const sha256_1 = require("@noble/hashes/sha256");
+const sha512_1 = require("@noble/hashes/sha512");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const helpers_js_1 = require("../helpers.js");
+/**
+ * @name shaAsU8a
+ * @summary Creates a sha Uint8Array from the input.
+ */
+exports.shaAsU8a = (0, helpers_js_1.createDualHasher)({ 256: wasm_crypto_1.sha256, 512: wasm_crypto_1.sha512 }, { 256: sha256_1.sha256, 512: sha512_1.sha512 });
+/**
+ * @name sha256AsU8a
+ * @summary Creates a sha256 Uint8Array from the input.
+ */
+exports.sha256AsU8a = (0, helpers_js_1.createBitHasher)(256, exports.shaAsU8a);
+/**
+ * @name sha512AsU8a
+ * @summary Creates a sha512 Uint8Array from the input.
+ */
+exports.sha512AsU8a = (0, helpers_js_1.createBitHasher)(512, exports.shaAsU8a);

package/cjs/sha/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @summary Implements Sha-256/512 hashing functions for a variety of input and outputs
+ */
+export { sha256AsU8a, sha512AsU8a, shaAsU8a } from './asU8a.js';

package/cjs/sha/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shaAsU8a = exports.sha512AsU8a = exports.sha256AsU8a = void 0;
+/**
+ * @summary Implements Sha-256/512 hashing functions for a variety of input and outputs
+ */
+var asU8a_js_1 = require("./asU8a.js");
+Object.defineProperty(exports, "sha256AsU8a", { enumerable: true, get: function () { return asU8a_js_1.sha256AsU8a; } });
+Object.defineProperty(exports, "sha512AsU8a", { enumerable: true, get: function () { return asU8a_js_1.sha512AsU8a; } });
+Object.defineProperty(exports, "shaAsU8a", { enumerable: true, get: function () { return asU8a_js_1.shaAsU8a; } });

package/cjs/signature/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @summary Utilities for working with signatures
+ */
+export { signatureVerify } from './verify.js';

package/cjs/signature/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signatureVerify = void 0;
+/**
+ * @summary Utilities for working with signatures
+ */
+var verify_js_1 = require("./verify.js");
+Object.defineProperty(exports, "signatureVerify", { enumerable: true, get: function () { return verify_js_1.signatureVerify; } });

package/cjs/signature/verify.d.ts

@@ -0,0 +1,2 @@
+import type { VerifyResult } from '../types.js';
+export declare function signatureVerify(message: string | Uint8Array, signature: string | Uint8Array, addressOrPublicKey: string | Uint8Array): VerifyResult;

package/cjs/signature/verify.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signatureVerify = signatureVerify;
+const util_1 = require("@pezkuwi/util");
+const decode_js_1 = require("../address/decode.js");
+const verify_js_1 = require("../ed25519/verify.js");
+const verify_js_2 = require("../secp256k1/verify.js");
+const verify_js_3 = require("../sr25519/verify.js");
+const secp256k1VerifyHasher = (hashType) => (message, signature, publicKey) => (0, verify_js_2.secp256k1Verify)(message, signature, publicKey, hashType, true);
+const VERIFIERS_ECDSA = [
+    ['ecdsa', secp256k1VerifyHasher('blake2')],
+    ['ethereum', secp256k1VerifyHasher('keccak')]
+];
+const VERIFIERS = [
+    ['ed25519', verify_js_1.ed25519Verify],
+    ['sr25519', verify_js_3.sr25519Verify]
+];
+function verifyDetect(result, { message, publicKey, signature }, verifiers = [...VERIFIERS, ...VERIFIERS_ECDSA]) {
+    result.isValid = verifiers.some(([crypto, verify]) => {
+        try {
+            if (verify(message, signature, publicKey)) {
+                result.crypto = crypto;
+                return true;
+            }
+        }
+        catch {
+            // do nothing, result.isValid still set to false
+        }
+        return false;
+    });
+    return result;
+}
+function verifyMultisig(result, { message, publicKey, signature }) {
+    if (![0, 1, 2].includes(signature[0]) || ![65, 66].includes(signature.length)) {
+        throw new Error(`Unknown crypto type, expected signature prefix [0..2], found ${signature[0]}`);
+    }
+    // If the signature is 66 bytes it must be an ecdsa signature
+    // containing: prefix [1 byte] + signature [65] bytes.
+    // Remove the and then verify
+    if (signature.length === 66) {
+        result = verifyDetect(result, { message, publicKey, signature: signature.subarray(1) }, VERIFIERS_ECDSA);
+    }
+    else {
+        // The signature contains 65 bytes which is either
+        // - A ed25519 or sr25519 signature [1 byte prefix + 64 bytes]
+        // - An ecdsa signature [65 bytes]
+        result = verifyDetect(result, { message, publicKey, signature: signature.subarray(1) }, VERIFIERS);
+        if (!result.isValid) {
+            result = verifyDetect(result, { message, publicKey, signature }, VERIFIERS_ECDSA);
+        }
+        // If both failed, explicitly set crypto to 'none'
+        if (!result.isValid) {
+            result.crypto = 'none';
+        }
+    }
+    return result;
+}
+function getVerifyFn(signature) {
+    return [0, 1, 2].includes(signature[0]) && [65, 66].includes(signature.length)
+        ? verifyMultisig
+        : verifyDetect;
+}
+function signatureVerify(message, signature, addressOrPublicKey) {
+    const signatureU8a = (0, util_1.u8aToU8a)(signature);
+    if (![64, 65, 66].includes(signatureU8a.length)) {
+        throw new Error(`Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
+    }
+    const publicKey = (0, decode_js_1.decodeAddress)(addressOrPublicKey);
+    const input = { message: (0, util_1.u8aToU8a)(message), publicKey, signature: signatureU8a };
+    const result = { crypto: 'none', isValid: false, isWrapped: (0, util_1.u8aIsWrapped)(input.message, true), publicKey };
+    const isWrappedBytes = (0, util_1.u8aIsWrapped)(input.message, false);
+    const verifyFn = getVerifyFn(signatureU8a);
+    verifyFn(result, input);
+    if (result.crypto !== 'none' || (result.isWrapped && !isWrappedBytes)) {
+        return result;
+    }
+    input.message = isWrappedBytes
+        ? (0, util_1.u8aUnwrapBytes)(input.message)
+        : (0, util_1.u8aWrapBytes)(input.message);
+    return verifyFn(result, input);
+}

package/cjs/sr25519/agreement.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name sr25519Agreement
+ * @description Key agreement between other's public key and self secret key
+ */
+export declare function sr25519Agreement(secretKey: string | Uint8Array, publicKey: string | Uint8Array): Uint8Array;

package/cjs/sr25519/agreement.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519Agreement = sr25519Agreement;
+const sr25519_1 = require("@scure/sr25519");
+const util_1 = require("@pezkuwi/util");
+/**
+ * @name sr25519Agreement
+ * @description Key agreement between other's public key and self secret key
+ */
+function sr25519Agreement(secretKey, publicKey) {
+    const secretKeyU8a = (0, util_1.u8aToU8a)(secretKey);
+    const publicKeyU8a = (0, util_1.u8aToU8a)(publicKey);
+    if (publicKeyU8a.length !== 32) {
+        throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+    }
+    else if (secretKeyU8a.length !== 64) {
+        throw new Error(`Invalid secretKey, received ${secretKeyU8a.length} bytes, expected 64`);
+    }
+    return (0, sr25519_1.getSharedSecret)(secretKeyU8a, publicKeyU8a);
+}

package/cjs/sr25519/derive.d.ts

@@ -0,0 +1,2 @@
+import type { Keypair } from '../types.js';
+export declare function createDeriveFn(derive: (pair: Uint8Array, cc: Uint8Array) => Uint8Array): (keypair: Keypair, chainCode: Uint8Array) => Keypair;

package/cjs/sr25519/derive.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeriveFn = createDeriveFn;
+const tslib_1 = require("tslib");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const util_1 = require("@pezkuwi/util");
+function createDeriveFn(derive) {
+    return (keypair, chainCode) => {
+        if (!(0, util_1.isU8a)(chainCode) || chainCode.length !== 32) {
+            throw new Error('Invalid chainCode passed to derive');
+        }
+        const secretKey = derive(keypair.secretKey, chainCode);
+        const publicKey = sr25519.getPublicKey(secretKey);
+        return { publicKey, secretKey };
+    };
+}

package/cjs/sr25519/deriveHard.d.ts

@@ -0,0 +1 @@
+export declare const sr25519DeriveHard: (keypair: import("../types.js").Keypair, chainCode: Uint8Array) => import("../types.js").Keypair;

package/cjs/sr25519/deriveHard.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519DeriveHard = void 0;
+const tslib_1 = require("tslib");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const derive_js_1 = require("./derive.js");
+exports.sr25519DeriveHard = (0, derive_js_1.createDeriveFn)(sr25519.HDKD.secretHard);

package/cjs/sr25519/derivePublic.d.ts

@@ -0,0 +1 @@
+export declare function sr25519DerivePublic(publicKey: string | Uint8Array, chainCode: Uint8Array): Uint8Array;

package/cjs/sr25519/derivePublic.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519DerivePublic = sr25519DerivePublic;
+const tslib_1 = require("tslib");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const util_1 = require("@pezkuwi/util");
+function sr25519DerivePublic(publicKey, chainCode) {
+    const publicKeyU8a = (0, util_1.u8aToU8a)(publicKey);
+    if (!(0, util_1.isU8a)(chainCode) || chainCode.length !== 32) {
+        throw new Error('Invalid chainCode passed to derive');
+    }
+    else if (publicKeyU8a.length !== 32) {
+        throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+    }
+    return sr25519.HDKD.publicSoft(publicKeyU8a, chainCode);
+}

package/cjs/sr25519/deriveSoft.d.ts

@@ -0,0 +1 @@
+export declare const sr25519DeriveSoft: (keypair: import("../types.js").Keypair, chainCode: Uint8Array) => import("../types.js").Keypair;

package/cjs/sr25519/deriveSoft.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519DeriveSoft = void 0;
+const tslib_1 = require("tslib");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const derive_js_1 = require("./derive.js");
+exports.sr25519DeriveSoft = (0, derive_js_1.createDeriveFn)(sr25519.HDKD.secretSoft);

package/cjs/sr25519/index.d.ts

@@ -0,0 +1,9 @@
+export { sr25519Agreement } from './agreement.js';
+export { sr25519DeriveHard } from './deriveHard.js';
+export { sr25519DerivePublic } from './derivePublic.js';
+export { sr25519DeriveSoft } from './deriveSoft.js';
+export { sr25519PairFromSeed } from './pair/fromSeed.js';
+export { sr25519Sign } from './sign.js';
+export { sr25519Verify } from './verify.js';
+export { sr25519VrfSign } from './vrfSign.js';
+export { sr25519VrfVerify } from './vrfVerify.js';