@pezkuwi/util-crypto 14.0.2 → 14.0.4

package/signature/verify.js

@@ -0,0 +1,78 @@
+import { u8aIsWrapped, u8aToU8a, u8aUnwrapBytes, u8aWrapBytes } from '@pezkuwi/util';
+import { decodeAddress } from '../address/decode.js';
+import { ed25519Verify } from '../ed25519/verify.js';
+import { secp256k1Verify } from '../secp256k1/verify.js';
+import { sr25519Verify } from '../sr25519/verify.js';
+const secp256k1VerifyHasher = (hashType) => (message, signature, publicKey) => secp256k1Verify(message, signature, publicKey, hashType, true);
+const VERIFIERS_ECDSA = [
+    ['ecdsa', secp256k1VerifyHasher('blake2')],
+    ['ethereum', secp256k1VerifyHasher('keccak')]
+];
+const VERIFIERS = [
+    ['ed25519', ed25519Verify],
+    ['sr25519', 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;
+}
+export function signatureVerify(message, signature, addressOrPublicKey) {
+    const signatureU8a = u8aToU8a(signature);
+    if (![64, 65, 66].includes(signatureU8a.length)) {
+        throw new Error(`Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
+    }
+    const publicKey = decodeAddress(addressOrPublicKey);
+    const input = { message: u8aToU8a(message), publicKey, signature: signatureU8a };
+    const result = { crypto: 'none', isValid: false, isWrapped: u8aIsWrapped(input.message, true), publicKey };
+    const isWrappedBytes = u8aIsWrapped(input.message, false);
+    const verifyFn = getVerifyFn(signatureU8a);
+    verifyFn(result, input);
+    if (result.crypto !== 'none' || (result.isWrapped && !isWrappedBytes)) {
+        return result;
+    }
+    input.message = isWrappedBytes
+        ? u8aUnwrapBytes(input.message)
+        : u8aWrapBytes(input.message);
+    return verifyFn(result, input);
+}

package/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/sr25519/agreement.js

@@ -0,0 +1,17 @@
+import { getSharedSecret } from '@scure/sr25519';
+import { u8aToU8a } from '@pezkuwi/util';
+/**
+ * @name sr25519Agreement
+ * @description Key agreement between other's public key and self secret key
+ */
+export function sr25519Agreement(secretKey, publicKey) {
+    const secretKeyU8a = u8aToU8a(secretKey);
+    const publicKeyU8a = 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 getSharedSecret(secretKeyU8a, publicKeyU8a);
+}

package/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/sr25519/derive.js

@@ -0,0 +1,12 @@
+import * as sr25519 from '@scure/sr25519';
+import { isU8a } from '@pezkuwi/util';
+export function createDeriveFn(derive) {
+    return (keypair, chainCode) => {
+        if (!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/sr25519/deriveHard.d.ts

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

package/{src/sr25519/deriveHard.ts → sr25519/deriveHard.js}

@@ -1,9 +1,3 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import * as sr25519 from '@scure/sr25519';
-
 import { createDeriveFn } from './derive.js';
-
-// eslint-disable-next-line @typescript-eslint/unbound-method
 export const sr25519DeriveHard = /*#__PURE__*/ createDeriveFn(sr25519.HDKD.secretHard);

package/sr25519/derivePublic.d.ts

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

package/sr25519/derivePublic.js

@@ -0,0 +1,12 @@
+import * as sr25519 from '@scure/sr25519';
+import { isU8a, u8aToU8a } from '@pezkuwi/util';
+export function sr25519DerivePublic(publicKey, chainCode) {
+    const publicKeyU8a = u8aToU8a(publicKey);
+    if (!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/sr25519/deriveSoft.d.ts

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

package/{src/sr25519/deriveSoft.ts → sr25519/deriveSoft.js}

@@ -1,9 +1,3 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import * as sr25519 from '@scure/sr25519';
-
 import { createDeriveFn } from './derive.js';
-
-// eslint-disable-next-line @typescript-eslint/unbound-method
 export const sr25519DeriveSoft = /*#__PURE__*/ createDeriveFn(sr25519.HDKD.secretSoft);

package/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';

package/sr25519/index.js

@@ -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';

package/sr25519/pair/fromSeed.d.ts

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

package/sr25519/pair/fromSeed.js

@@ -0,0 +1,18 @@
+import * as sr25519 from '@scure/sr25519';
+import { u8aToU8a } from '@pezkuwi/util';
+/**
+ * @name sr25519PairFromSeed
+ * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ */
+export function sr25519PairFromSeed(seed) {
+    const seedU8a = 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/sr25519/pair/fromU8a.d.ts

@@ -0,0 +1,2 @@
+import type { Keypair } from '../../types.js';
+export declare function sr25519PairFromU8a(full: string | Uint8Array): Keypair;

package/sr25519/pair/fromU8a.js

@@ -0,0 +1,14 @@
+import { u8aToU8a } from '@pezkuwi/util';
+const SEC_LEN = 64;
+const PUB_LEN = 32;
+const TOT_LEN = SEC_LEN + PUB_LEN;
+export function sr25519PairFromU8a(full) {
+    const fullU8a = 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/sr25519/pair/toU8a.d.ts

@@ -0,0 +1,2 @@
+import type { Keypair } from '../../types.js';
+export declare function sr25519KeypairToU8a({ publicKey, secretKey }: Keypair): Uint8Array;

package/sr25519/pair/toU8a.js

@@ -0,0 +1,4 @@
+import { u8aConcat } from '@pezkuwi/util';
+export function sr25519KeypairToU8a({ publicKey, secretKey }) {
+    return u8aConcat(secretKey, publicKey).slice();
+}

package/sr25519/sign.d.ts

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

package/sr25519/sign.js

@@ -0,0 +1,15 @@
+import * as sr25519 from '@scure/sr25519';
+import { u8aToU8a } from '@pezkuwi/util';
+/**
+ * @name sr25519Sign
+ * @description Returns message signature of `message`, using the supplied pair
+ */
+export 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, u8aToU8a(message));
+}

package/sr25519/verify.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name sr25519Verify
+ * @description Verifies the signature of `message`, using the supplied pair
+ */
+export declare function sr25519Verify(message: string | Uint8Array, signature: string | Uint8Array, publicKey: string | Uint8Array): boolean;

package/sr25519/verify.js

@@ -0,0 +1,17 @@
+import * as sr25519 from '@scure/sr25519';
+import { u8aToU8a } from '@pezkuwi/util';
+/**
+ * @name sr25519Verify
+ * @description Verifies the signature of `message`, using the supplied pair
+ */
+export function sr25519Verify(message, signature, publicKey) {
+    const publicKeyU8a = u8aToU8a(publicKey);
+    const signatureU8a = 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(u8aToU8a(message), signatureU8a, publicKeyU8a);
+}

package/sr25519/vrfSign.d.ts

@@ -0,0 +1,6 @@
+import type { Keypair } from '../types.js';
+/**
+ * @name sr25519VrfSign
+ * @description Sign with sr25519 vrf signing (deterministic)
+ */
+export declare function sr25519VrfSign(message: string | Uint8Array, { secretKey }: Partial<Keypair>, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array;

package/sr25519/vrfSign.js

@@ -0,0 +1,15 @@
+import { randomBytes } from '@noble/hashes/utils';
+import * as sr25519 from '@scure/sr25519';
+import { u8aToU8a } from '@pezkuwi/util';
+const EMPTY_U8A = new Uint8Array();
+/**
+ * @name sr25519VrfSign
+ * @description Sign with sr25519 vrf signing (deterministic)
+ */
+export 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(u8aToU8a(message), secretKey, u8aToU8a(context), u8aToU8a(extra), randomBytes);
+    // return vrfSign(secretKey, u8aToU8a(context), u8aToU8a(message), u8aToU8a(extra));
+}

package/sr25519/vrfVerify.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name sr25519VrfVerify
+ * @description Verify with sr25519 vrf verification
+ */
+export declare function sr25519VrfVerify(message: string | Uint8Array, signOutput: string | Uint8Array, publicKey: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean;

package/sr25519/vrfVerify.js

@@ -0,0 +1,18 @@
+import * as sr25519 from '@scure/sr25519';
+import { u8aToU8a } from '@pezkuwi/util';
+const EMPTY_U8A = new Uint8Array();
+/**
+ * @name sr25519VrfVerify
+ * @description Verify with sr25519 vrf verification
+ */
+export function sr25519VrfVerify(message, signOutput, publicKey, context = EMPTY_U8A, extra = EMPTY_U8A) {
+    const publicKeyU8a = u8aToU8a(publicKey);
+    const proofU8a = 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(u8aToU8a(message), proofU8a, publicKeyU8a, u8aToU8a(context), u8aToU8a(extra));
+}

package/types.d.ts

@@ -0,0 +1,26 @@
+export * from './address/types.js';
+export * from './json/types.js';
+export interface Keypair {
+    /** The publicKey for this pair */
+    publicKey: Uint8Array;
+    /** The secretKey for this pair */
+    secretKey: Uint8Array;
+}
+export interface Seedpair {
+    /** The publicKey for this pair */
+    publicKey: Uint8Array;
+    /** The seed used to construct the pair */
+    seed: Uint8Array;
+}
+/** The supported types of pairs */
+export type KeypairType = 'ed25519' | 'sr25519' | 'ecdsa' | 'ethereum';
+export interface VerifyResult {
+    /** The detected crypto interface, or 'none' if not detected */
+    crypto: 'none' | KeypairType;
+    /** The validity for this result, false if invalid */
+    isValid: boolean;
+    /** Flag to indicate if the passed data was wrapped in <Bytes>...</Bytes> */
+    isWrapped: boolean;
+    /** The extracted publicKey */
+    publicKey: Uint8Array;
+}

package/types.js

@@ -0,0 +1,2 @@
+export * from './address/types.js';
+export * from './json/types.js';

package/wbg.d.ts

@@ -0,0 +1,36 @@
+import type { BridgeBase, WasmBaseInstance } from './types.js';
+/**
+ * @name Wbg
+ * @description
+ * This defines the internal interfaces that wasm-bindgen used to communicate
+ * with the host layer. None of these functions are available to the user, rather
+ * they are called internally from the WASM code itself.
+ *
+ * The interfaces here are exposed in the imports on the created WASM interfaces.
+ *
+ * Internally the implementation does a thin layer into the supplied bridge.
+ */
+export declare class Wbg<C extends WasmBaseInstance> {
+    #private;
+    constructor(bridge: BridgeBase<C>);
+    /** @internal */
+    abort: () => never;
+    /** @internal */
+    __wbindgen_is_undefined: (idx: number) => boolean;
+    /** @internal */
+    __wbindgen_throw: (ptr: number, len: number) => boolean;
+    /** @internal */
+    __wbg_self_1b7a39e3a92c949c: () => number;
+    /** @internal */
+    __wbg_require_604837428532a733: (ptr: number, len: number) => never;
+    /** @internal */
+    __wbg_crypto_968f1772287e2df0: (_idx: number) => number;
+    /** @internal */
+    __wbg_getRandomValues_a3d34b4fee3c2869: (_idx: number) => number;
+    /** @internal */
+    __wbg_getRandomValues_f5e14ab7ac8e995d: (_arg0: number, ptr: number, len: number) => void;
+    /** @internal */
+    __wbg_randomFillSync_d5bd2d655fdf256a: (_idx: number, _ptr: number, _len: number) => never;
+    /** @internal */
+    __wbindgen_object_drop_ref: (idx: number) => void;
+}

package/wbg.js

@@ -0,0 +1,61 @@
+import { getRandomValues } from '@pezkuwi/x-randomvalues';
+const DEFAULT_CRYPTO = { getRandomValues };
+const DEFAULT_SELF = { crypto: DEFAULT_CRYPTO };
+/**
+ * @name Wbg
+ * @description
+ * This defines the internal interfaces that wasm-bindgen used to communicate
+ * with the host layer. None of these functions are available to the user, rather
+ * they are called internally from the WASM code itself.
+ *
+ * The interfaces here are exposed in the imports on the created WASM interfaces.
+ *
+ * Internally the implementation does a thin layer into the supplied bridge.
+ */
+export class Wbg {
+    #bridge;
+    constructor(bridge) {
+        this.#bridge = bridge;
+    }
+    /** @internal */
+    abort = () => {
+        throw new Error('abort');
+    };
+    /** @internal */
+    __wbindgen_is_undefined = (idx) => {
+        return this.#bridge.getObject(idx) === undefined;
+    };
+    /** @internal */
+    __wbindgen_throw = (ptr, len) => {
+        throw new Error(this.#bridge.getString(ptr, len));
+    };
+    /** @internal */
+    __wbg_self_1b7a39e3a92c949c = () => {
+        return this.#bridge.addObject(DEFAULT_SELF);
+    };
+    /** @internal */
+    __wbg_require_604837428532a733 = (ptr, len) => {
+        throw new Error(`Unable to require ${this.#bridge.getString(ptr, len)}`);
+    };
+    /** @internal */
+    __wbg_crypto_968f1772287e2df0 = (_idx) => {
+        return this.#bridge.addObject(DEFAULT_CRYPTO);
+    };
+    /** @internal */
+    __wbg_getRandomValues_a3d34b4fee3c2869 = (_idx) => {
+        return this.#bridge.addObject(DEFAULT_CRYPTO.getRandomValues);
+    };
+    /** @internal */
+    __wbg_getRandomValues_f5e14ab7ac8e995d = (_arg0, ptr, len) => {
+        DEFAULT_CRYPTO.getRandomValues(this.#bridge.getU8a(ptr, len));
+    };
+    /** @internal */
+    __wbg_randomFillSync_d5bd2d655fdf256a = (_idx, _ptr, _len) => {
+        throw new Error('randomFillsync is not available');
+        // getObject(idx).randomFillSync(getU8a(ptr, len));
+    };
+    /** @internal */
+    __wbindgen_object_drop_ref = (idx) => {
+        this.#bridge.takeObject(idx);
+    };
+}

package/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 '@polkadot/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("@polkadot/util/types").HexString;

package/{src/xxhash/asU8a.ts → xxhash/asU8a.js}

@@ -1,12 +1,7 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { hasBigInt, u8aToU8a } from '@pezkuwi/util';
 import { isReady, twox } from '@pezkuwi/wasm-crypto';
-
 import { createAsHex } from '../helpers.js';
 import { xxhash64 } from './xxhash64.js';
-
 /**
  * @name xxhashAsU8a
  * @summary Creates a xxhash64 u8a from the input.
@@ -21,23 +16,18 @@ import { xxhash64 } from './xxhash64.js';
  * xxhashAsU8a('abc'); // => 0x44bc2cf5ad770999
  * ```
  */
-export function xxhashAsU8a (data: string | Uint8Array, bitLength: 64 | 128 | 192 | 256 | 320 | 384 | 448 | 512 = 64, onlyJs?: boolean): Uint8Array {
-  const rounds = Math.ceil(bitLength / 64);
-  const u8a = u8aToU8a(data);
-
-  if (!hasBigInt || (!onlyJs && isReady())) {
-    return twox(u8a, rounds);
-  }
-
-  const result = new Uint8Array(rounds * 8);
-
-  for (let seed = 0; seed < rounds; seed++) {
-    result.set(xxhash64(u8a, seed).reverse(), seed * 8);
-  }
-
-  return result;
+export function xxhashAsU8a(data, bitLength = 64, onlyJs) {
+    const rounds = Math.ceil(bitLength / 64);
+    const u8a = u8aToU8a(data);
+    if (!hasBigInt || (!onlyJs && isReady())) {
+        return twox(u8a, rounds);
+    }
+    const result = new Uint8Array(rounds * 8);
+    for (let seed = 0; seed < rounds; seed++) {
+        result.set(xxhash64(u8a, seed).reverse(), seed * 8);
+    }
+    return result;
 }
-
 /**
  * @name xxhashAsHex
  * @description Creates a xxhash64 hex from the input.

package/xxhash/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @summary Create xxhash64 values with specified bitlengths
+ */
+export { xxhashAsHex, xxhashAsU8a } from './asU8a.js';

package/xxhash/index.js

@@ -0,0 +1,4 @@
+/**
+ * @summary Create xxhash64 values with specified bitlengths
+ */
+export { xxhashAsHex, xxhashAsU8a } from './asU8a.js';

package/xxhash/xxhash64.d.ts

@@ -0,0 +1 @@
+export declare function xxhash64(input: Uint8Array, initSeed: bigint | number): Uint8Array;