@pezkuwi/util-crypto 14.0.4 → 14.0.6

package/build/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/build/cjs/secp256k1/types.js

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

package/build/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/build/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/build/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/build/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/build/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/build/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/build/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/build/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/build/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/build/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/build/cjs/sr25519/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519VrfVerify = exports.sr25519VrfSign = exports.sr25519Verify = exports.sr25519Sign = exports.sr25519PairFromSeed = exports.sr25519DeriveSoft = exports.sr25519DerivePublic = exports.sr25519DeriveHard = exports.sr25519Agreement = void 0;
+var agreement_js_1 = require("./agreement.js");
+Object.defineProperty(exports, "sr25519Agreement", { enumerable: true, get: function () { return agreement_js_1.sr25519Agreement; } });
+var deriveHard_js_1 = require("./deriveHard.js");
+Object.defineProperty(exports, "sr25519DeriveHard", { enumerable: true, get: function () { return deriveHard_js_1.sr25519DeriveHard; } });
+var derivePublic_js_1 = require("./derivePublic.js");
+Object.defineProperty(exports, "sr25519DerivePublic", { enumerable: true, get: function () { return derivePublic_js_1.sr25519DerivePublic; } });
+var deriveSoft_js_1 = require("./deriveSoft.js");
+Object.defineProperty(exports, "sr25519DeriveSoft", { enumerable: true, get: function () { return deriveSoft_js_1.sr25519DeriveSoft; } });
+var fromSeed_js_1 = require("./pair/fromSeed.js");
+Object.defineProperty(exports, "sr25519PairFromSeed", { enumerable: true, get: function () { return fromSeed_js_1.sr25519PairFromSeed; } });
+var sign_js_1 = require("./sign.js");
+Object.defineProperty(exports, "sr25519Sign", { enumerable: true, get: function () { return sign_js_1.sr25519Sign; } });
+var verify_js_1 = require("./verify.js");
+Object.defineProperty(exports, "sr25519Verify", { enumerable: true, get: function () { return verify_js_1.sr25519Verify; } });
+var vrfSign_js_1 = require("./vrfSign.js");
+Object.defineProperty(exports, "sr25519VrfSign", { enumerable: true, get: function () { return vrfSign_js_1.sr25519VrfSign; } });
+var vrfVerify_js_1 = require("./vrfVerify.js");
+Object.defineProperty(exports, "sr25519VrfVerify", { enumerable: true, get: function () { return vrfVerify_js_1.sr25519VrfVerify; } });

package/build/cjs/sr25519/pair/fromSeed.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519PairFromSeed = sr25519PairFromSeed;
+const tslib_1 = require("tslib");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const util_1 = require("@pezkuwi/util");
+/**
+ * @name sr25519PairFromSeed
+ * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ */
+function sr25519PairFromSeed(seed) {
+    const seedU8a = (0, util_1.u8aToU8a)(seed);
+    if (seedU8a.length !== 32) {
+        throw new Error(`Expected a seed matching 32 bytes, found ${seedU8a.length}`);
+    }
+    const sec = sr25519.secretFromSeed(seedU8a);
+    const pub = sr25519.getPublicKey(sec);
+    return {
+        publicKey: pub,
+        secretKey: sec
+    };
+}

package/build/cjs/sr25519/pair/fromU8a.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519PairFromU8a = sr25519PairFromU8a;
+const util_1 = require("@pezkuwi/util");
+const SEC_LEN = 64;
+const PUB_LEN = 32;
+const TOT_LEN = SEC_LEN + PUB_LEN;
+function sr25519PairFromU8a(full) {
+    const fullU8a = (0, util_1.u8aToU8a)(full);
+    if (fullU8a.length !== TOT_LEN) {
+        throw new Error(`Expected keypair with ${TOT_LEN} bytes, found ${fullU8a.length}`);
+    }
+    return {
+        publicKey: fullU8a.slice(SEC_LEN, TOT_LEN),
+        secretKey: fullU8a.slice(0, SEC_LEN)
+    };
+}

package/build/cjs/sr25519/pair/toU8a.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519KeypairToU8a = sr25519KeypairToU8a;
+const util_1 = require("@pezkuwi/util");
+function sr25519KeypairToU8a({ publicKey, secretKey }) {
+    return (0, util_1.u8aConcat)(secretKey, publicKey).slice();
+}

package/build/cjs/sr25519/sign.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519Sign = sr25519Sign;
+const tslib_1 = require("tslib");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const util_1 = require("@pezkuwi/util");
+/**
+ * @name sr25519Sign
+ * @description Returns message signature of `message`, using the supplied pair
+ */
+function sr25519Sign(message, { publicKey, secretKey }) {
+    if (publicKey?.length !== 32) {
+        throw new Error('Expected a valid publicKey, 32-bytes');
+    }
+    else if (secretKey?.length !== 64) {
+        throw new Error('Expected a valid secretKey, 64-bytes');
+    }
+    return sr25519.sign(secretKey, (0, util_1.u8aToU8a)(message));
+}

package/build/cjs/sr25519/verify.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519Verify = sr25519Verify;
+const tslib_1 = require("tslib");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const util_1 = require("@pezkuwi/util");
+/**
+ * @name sr25519Verify
+ * @description Verifies the signature of `message`, using the supplied pair
+ */
+function sr25519Verify(message, signature, publicKey) {
+    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} bytes, expected 32`);
+    }
+    else if (signatureU8a.length !== 64) {
+        throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+    }
+    return sr25519.verify((0, util_1.u8aToU8a)(message), signatureU8a, publicKeyU8a);
+}

package/build/cjs/sr25519/vrfSign.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519VrfSign = sr25519VrfSign;
+const tslib_1 = require("tslib");
+const utils_1 = require("@noble/hashes/utils");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const util_1 = require("@pezkuwi/util");
+const EMPTY_U8A = new Uint8Array();
+/**
+ * @name sr25519VrfSign
+ * @description Sign with sr25519 vrf signing (deterministic)
+ */
+function sr25519VrfSign(message, { secretKey }, context = EMPTY_U8A, extra = EMPTY_U8A) {
+    if (secretKey?.length !== 64) {
+        throw new Error('Invalid secretKey, expected 64-bytes');
+    }
+    return sr25519.vrf.sign((0, util_1.u8aToU8a)(message), secretKey, (0, util_1.u8aToU8a)(context), (0, util_1.u8aToU8a)(extra), utils_1.randomBytes);
+    // return vrfSign(secretKey, u8aToU8a(context), u8aToU8a(message), u8aToU8a(extra));
+}

package/build/cjs/sr25519/vrfVerify.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519VrfVerify = sr25519VrfVerify;
+const tslib_1 = require("tslib");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const util_1 = require("@pezkuwi/util");
+const EMPTY_U8A = new Uint8Array();
+/**
+ * @name sr25519VrfVerify
+ * @description Verify with sr25519 vrf verification
+ */
+function sr25519VrfVerify(message, signOutput, publicKey, context = EMPTY_U8A, extra = EMPTY_U8A) {
+    const publicKeyU8a = (0, util_1.u8aToU8a)(publicKey);
+    const proofU8a = (0, util_1.u8aToU8a)(signOutput);
+    if (publicKeyU8a.length !== 32) {
+        throw new Error('Invalid publicKey, expected 32-bytes');
+    }
+    else if (proofU8a.length !== 96) {
+        throw new Error('Invalid vrfSign output, expected 96 bytes');
+    }
+    return sr25519.vrf.verify((0, util_1.u8aToU8a)(message), proofU8a, publicKeyU8a, (0, util_1.u8aToU8a)(context), (0, util_1.u8aToU8a)(extra));
+}

package/build/cjs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./address/types.js"), exports);
+tslib_1.__exportStar(require("./json/types.js"), exports);

package/build/cjs/xxhash/asU8a.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @name xxhashAsU8a
+ * @summary Creates a xxhash64 u8a from the input.
+ * @description
+ * From either a `string`, `Uint8Array` or a `Buffer` input, create the xxhash64 and return the result as a `Uint8Array` with the specified `bitLength`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { xxhashAsU8a } from '@pezkuwi/util-crypto';
+ *
+ * xxhashAsU8a('abc'); // => 0x44bc2cf5ad770999
+ * ```
+ */
+export declare function xxhashAsU8a(data: string | Uint8Array, bitLength?: 64 | 128 | 192 | 256 | 320 | 384 | 448 | 512, onlyJs?: boolean): Uint8Array;
+/**
+ * @name xxhashAsHex
+ * @description Creates a xxhash64 hex from the input.
+ */
+export declare const xxhashAsHex: (data: string | Uint8Array, bitLength?: 256 | 512 | 64 | 128 | 384 | 320 | 192 | 448 | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;

package/build/cjs/xxhash/asU8a.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xxhashAsHex = void 0;
+exports.xxhashAsU8a = xxhashAsU8a;
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const helpers_js_1 = require("../helpers.js");
+const xxhash64_js_1 = require("./xxhash64.js");
+/**
+ * @name xxhashAsU8a
+ * @summary Creates a xxhash64 u8a from the input.
+ * @description
+ * From either a `string`, `Uint8Array` or a `Buffer` input, create the xxhash64 and return the result as a `Uint8Array` with the specified `bitLength`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { xxhashAsU8a } from '@pezkuwi/util-crypto';
+ *
+ * xxhashAsU8a('abc'); // => 0x44bc2cf5ad770999
+ * ```
+ */
+function xxhashAsU8a(data, bitLength = 64, onlyJs) {
+    const rounds = Math.ceil(bitLength / 64);
+    const u8a = (0, util_1.u8aToU8a)(data);
+    if (!util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())) {
+        return (0, wasm_crypto_1.twox)(u8a, rounds);
+    }
+    const result = new Uint8Array(rounds * 8);
+    for (let seed = 0; seed < rounds; seed++) {
+        result.set((0, xxhash64_js_1.xxhash64)(u8a, seed).reverse(), seed * 8);
+    }
+    return result;
+}
+/**
+ * @name xxhashAsHex
+ * @description Creates a xxhash64 hex from the input.
+ */
+exports.xxhashAsHex = (0, helpers_js_1.createAsHex)(xxhashAsU8a);

package/build/cjs/xxhash/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xxhashAsU8a = exports.xxhashAsHex = void 0;
+/**
+ * @summary Create xxhash64 values with specified bitlengths
+ */
+var asU8a_js_1 = require("./asU8a.js");
+Object.defineProperty(exports, "xxhashAsHex", { enumerable: true, get: function () { return asU8a_js_1.xxhashAsHex; } });
+Object.defineProperty(exports, "xxhashAsU8a", { enumerable: true, get: function () { return asU8a_js_1.xxhashAsU8a; } });

package/build/cjs/xxhash/xxhash64.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xxhash64 = xxhash64;
+const util_1 = require("@pezkuwi/util");
+const x_bigint_1 = require("@pezkuwi/x-bigint");
+const P64_1 = (0, x_bigint_1.BigInt)('11400714785074694791');
+const P64_2 = (0, x_bigint_1.BigInt)('14029467366897019727');
+const P64_3 = (0, x_bigint_1.BigInt)('1609587929392839161');
+const P64_4 = (0, x_bigint_1.BigInt)('9650029242287828579');
+const P64_5 = (0, x_bigint_1.BigInt)('2870177450012600261');
+const U64 = (0, x_bigint_1.BigInt)('0xffffffffffffffff');
+const _7n = (0, x_bigint_1.BigInt)(7);
+const _11n = (0, x_bigint_1.BigInt)(11);
+const _12n = (0, x_bigint_1.BigInt)(12);
+const _16n = (0, x_bigint_1.BigInt)(16);
+const _18n = (0, x_bigint_1.BigInt)(18);
+const _23n = (0, x_bigint_1.BigInt)(23);
+const _27n = (0, x_bigint_1.BigInt)(27);
+const _29n = (0, x_bigint_1.BigInt)(29);
+const _31n = (0, x_bigint_1.BigInt)(31);
+const _32n = (0, x_bigint_1.BigInt)(32);
+const _33n = (0, x_bigint_1.BigInt)(33);
+const _64n = (0, x_bigint_1.BigInt)(64);
+const _256n = (0, x_bigint_1.BigInt)(256);
+function rotl(a, b) {
+    const c = a & U64;
+    return ((c << b) | (c >> (_64n - b))) & U64;
+}
+function fromU8a(u8a, p, count) {
+    const bigints = new Array(count);
+    let offset = 0;
+    for (let i = 0; i < count; i++, offset += 2) {
+        bigints[i] = (0, x_bigint_1.BigInt)(u8a[p + offset] | (u8a[p + 1 + offset] << 8));
+    }
+    let result = util_1._0n;
+    for (let i = count - 1; i >= 0; i--) {
+        result = (result << _16n) + bigints[i];
+    }
+    return result;
+}
+function init(seed, input) {
+    const state = {
+        seed,
+        u8a: new Uint8Array(32),
+        u8asize: 0,
+        v1: seed + P64_1 + P64_2,
+        v2: seed + P64_2,
+        v3: seed,
+        v4: seed - P64_1
+    };
+    if (input.length < 32) {
+        state.u8a.set(input);
+        state.u8asize = input.length;
+        return state;
+    }
+    const limit = input.length - 32;
+    let p = 0;
+    if (limit >= 0) {
+        const adjustV = (v) => P64_1 * rotl(v + P64_2 * fromU8a(input, p, 4), _31n);
+        do {
+            state.v1 = adjustV(state.v1);
+            p += 8;
+            state.v2 = adjustV(state.v2);
+            p += 8;
+            state.v3 = adjustV(state.v3);
+            p += 8;
+            state.v4 = adjustV(state.v4);
+            p += 8;
+        } while (p <= limit);
+    }
+    if (p < input.length) {
+        state.u8a.set(input.subarray(p, input.length));
+        state.u8asize = input.length - p;
+    }
+    return state;
+}
+function xxhash64(input, initSeed) {
+    const { seed, u8a, u8asize, v1, v2, v3, v4 } = init((0, x_bigint_1.BigInt)(initSeed), input);
+    let p = 0;
+    let h64 = U64 & ((0, x_bigint_1.BigInt)(input.length) + (input.length >= 32
+        ? (((((((((rotl(v1, util_1._1n) + rotl(v2, _7n) + rotl(v3, _12n) + rotl(v4, _18n)) ^ (P64_1 * rotl(v1 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v2 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v3 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v4 * P64_2, _31n))) * P64_1 + P64_4)
+        : (seed + P64_5)));
+    while (p <= (u8asize - 8)) {
+        h64 = U64 & (P64_4 + P64_1 * rotl(h64 ^ (P64_1 * rotl(P64_2 * fromU8a(u8a, p, 4), _31n)), _27n));
+        p += 8;
+    }
+    if ((p + 4) <= u8asize) {
+        h64 = U64 & (P64_3 + P64_2 * rotl(h64 ^ (P64_1 * fromU8a(u8a, p, 2)), _23n));
+        p += 4;
+    }
+    while (p < u8asize) {
+        h64 = U64 & (P64_1 * rotl(h64 ^ (P64_5 * (0, x_bigint_1.BigInt)(u8a[p++])), _11n));
+    }
+    h64 = U64 & (P64_2 * (h64 ^ (h64 >> _33n)));
+    h64 = U64 & (P64_3 * (h64 ^ (h64 >> _29n)));
+    h64 = U64 & (h64 ^ (h64 >> _32n));
+    const result = new Uint8Array(8);
+    for (let i = 7; i >= 0; i--) {
+        result[i] = Number(h64 % _256n);
+        h64 = h64 / _256n;
+    }
+    return result;
+}

package/build/crypto.d.ts

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

package/build/crypto.js

@@ -0,0 +1,12 @@
+import { isReady, waitReady } from '@pezkuwi/wasm-crypto';
+export const cryptoIsReady = isReady;
+export function cryptoWaitReady() {
+    return waitReady()
+        .then(() => {
+        if (!isReady()) {
+            throw new Error('Unable to initialize @pezkuwi/util-crypto');
+        }
+        return true;
+    })
+        .catch(() => false);
+}

package/build/ed25519/deriveHard.d.ts

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

package/build/ed25519/deriveHard.js

@@ -0,0 +1,9 @@
+import { compactAddLength, isU8a, stringToU8a, u8aConcat } from '@pezkuwi/util';
+import { blake2AsU8a } from '../blake2/asU8a.js';
+const HDKD = compactAddLength(stringToU8a('Ed25519HDKD'));
+export function ed25519DeriveHard(seed, chainCode) {
+    if (!isU8a(chainCode) || chainCode.length !== 32) {
+        throw new Error('Invalid chainCode passed to derive');
+    }
+    return blake2AsU8a(u8aConcat(HDKD, seed, chainCode));
+}