@pezkuwi/util-crypto 14.0.1 → 14.0.3

package/ed25519/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @summary Implements ed25519 operations
+ */
+export { ed25519DeriveHard } from './deriveHard.js';
+export { ed25519PairFromRandom } from './pair/fromRandom.js';
+export { ed25519PairFromSecret } from './pair/fromSecret.js';
+export { ed25519PairFromSeed } from './pair/fromSeed.js';
+export { ed25519PairFromString } from './pair/fromString.js';
+export { ed25519Sign } from './sign.js';
+export { ed25519Verify } from './verify.js';

package/ed25519/index.js

@@ -0,0 +1,10 @@
+/**
+ * @summary Implements ed25519 operations
+ */
+export { ed25519DeriveHard } from './deriveHard.js';
+export { ed25519PairFromRandom } from './pair/fromRandom.js';
+export { ed25519PairFromSecret } from './pair/fromSecret.js';
+export { ed25519PairFromSeed } from './pair/fromSeed.js';
+export { ed25519PairFromString } from './pair/fromString.js';
+export { ed25519Sign } from './sign.js';
+export { ed25519Verify } from './verify.js';

package/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/{src/ed25519/pair/fromRandom.ts → ed25519/pair/fromRandom.js}

@@ -1,11 +1,5 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../../types.js';
-
 import { randomAsU8a } from '../../random/index.js';
 import { ed25519PairFromSeed } from './fromSeed.js';
-
 /**
  * @name ed25519PairFromRandom
  * @summary Creates a new public/secret keypair.
@@ -20,6 +14,6 @@ import { ed25519PairFromSeed } from './fromSeed.js';
  * ed25519PairFromRandom(); // => { secretKey: [...], publicKey: [...] }
  * ```
  */
-export function ed25519PairFromRandom (): Keypair {
-  return ed25519PairFromSeed(randomAsU8a());
+export function ed25519PairFromRandom() {
+    return ed25519PairFromSeed(randomAsU8a());
 }

package/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/ed25519/pair/fromSecret.js

@@ -0,0 +1,23 @@
+/**
+ * @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 '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export function ed25519PairFromSecret(secretKey) {
+    if (secretKey.length !== 64) {
+        throw new Error('Invalid secretKey provided');
+    }
+    return {
+        publicKey: secretKey.slice(32),
+        secretKey
+    };
+}

package/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/{src/ed25519/pair/fromSeed.ts → ed25519/pair/fromSeed.js}

@@ -1,13 +1,6 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../../types.js';
-
 import { ed25519 } from '@noble/curves/ed25519';
-
 import { hasBigInt, u8aConcatStrict } from '@pezkuwi/util';
 import { ed25519KeypairFromSeed, isReady } from '@pezkuwi/wasm-crypto';
-
 /**
  * @name ed25519PairFromSeed
  * @summary Creates a new public/secret keypair from a seed.
@@ -22,20 +15,17 @@ import { ed25519KeypairFromSeed, isReady } from '@pezkuwi/wasm-crypto';
  * ed25519PairFromSeed(...); // => { secretKey: [...], publicKey: [...] }
  * ```
  */
-export function ed25519PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keypair {
-  if (!hasBigInt || (!onlyJs && isReady())) {
-    const full = ed25519KeypairFromSeed(seed);
-
+export function ed25519PairFromSeed(seed, onlyJs) {
+    if (!hasBigInt || (!onlyJs && isReady())) {
+        const full = ed25519KeypairFromSeed(seed);
+        return {
+            publicKey: full.slice(32),
+            secretKey: full.slice(0, 64)
+        };
+    }
+    const publicKey = ed25519.getPublicKey(seed);
     return {
-      publicKey: full.slice(32),
-      secretKey: full.slice(0, 64)
+        publicKey,
+        secretKey: u8aConcatStrict([seed, publicKey])
     };
-  }
-
-  const publicKey = ed25519.getPublicKey(seed);
-
-  return {
-    publicKey,
-    secretKey: u8aConcatStrict([seed, publicKey])
-  };
 }

package/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/{src/ed25519/pair/fromString.ts → ed25519/pair/fromString.js}

@@ -1,13 +1,6 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../../types.js';
-
 import { stringToU8a } from '@pezkuwi/util';
-
 import { blake2AsU8a } from '../../blake2/asU8a.js';
 import { ed25519PairFromSeed } from './fromSeed.js';
-
 /**
  * @name ed25519PairFromString
  * @summary Creates a new public/secret keypair from a string.
@@ -22,10 +15,6 @@ import { ed25519PairFromSeed } from './fromSeed.js';
  * ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }
  * ```
  */
-export function ed25519PairFromString (value: string): Keypair {
-  return ed25519PairFromSeed(
-    blake2AsU8a(
-      stringToU8a(value)
-    )
-  );
+export function ed25519PairFromString(value) {
+    return ed25519PairFromSeed(blake2AsU8a(stringToU8a(value)));
 }

package/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/ed25519/sign.js

@@ -0,0 +1,30 @@
+import { ed25519 } from '@noble/curves/ed25519';
+import { hasBigInt, u8aToU8a } from '@pezkuwi/util';
+import { ed25519Sign as wasmSign, isReady } from '@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([...], [...]); // => [...]
+ * ```
+ */
+export 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 = u8aToU8a(message);
+    const privateU8a = secretKey.subarray(0, 32);
+    return !hasBigInt || (!onlyJs && isReady())
+        ? wasmSign(publicKey, privateU8a, messageU8a)
+        : ed25519.sign(messageU8a, privateU8a);
+}

package/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/ed25519/verify.js

@@ -0,0 +1,36 @@
+import { ed25519 } from '@noble/curves/ed25519';
+import { hasBigInt, u8aToU8a } from '@pezkuwi/util';
+import { ed25519Verify as wasmVerify, isReady } from '@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
+ * ```
+ */
+export function ed25519Verify(message, signature, publicKey, onlyJs) {
+    const messageU8a = u8aToU8a(message);
+    const publicKeyU8a = u8aToU8a(publicKey);
+    const signatureU8a = 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 !hasBigInt || (!onlyJs && isReady())
+            ? wasmVerify(signatureU8a, messageU8a, publicKeyU8a)
+            : ed25519.verify(signatureU8a, messageU8a, publicKeyU8a);
+    }
+    catch {
+        return false;
+    }
+}

package/ethereum/encode.d.ts

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

package/ethereum/encode.js

@@ -0,0 +1,25 @@
+import { u8aToHex, u8aToU8a } from '@pezkuwi/util';
+import { keccakAsU8a } from '../keccak/index.js';
+import { secp256k1Expand } from '../secp256k1/index.js';
+function getH160(u8a) {
+    if ([33, 65].includes(u8a.length)) {
+        u8a = keccakAsU8a(secp256k1Expand(u8a));
+    }
+    return u8a.slice(-20);
+}
+export function ethereumEncode(addressOrPublic) {
+    if (!addressOrPublic) {
+        return '0x';
+    }
+    const u8aAddress = 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 = u8aToHex(getH160(u8aAddress), -1, false);
+    const hash = u8aToHex(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/ethereum/index.d.ts

@@ -0,0 +1,3 @@
+export { ethereumEncode } from './encode.js';
+export { isEthereumAddress } from './isAddress.js';
+export { isEthereumChecksum } from './isChecksum.js';

package/ethereum/index.js

@@ -0,0 +1,3 @@
+export { ethereumEncode } from './encode.js';
+export { isEthereumAddress } from './isAddress.js';
+export { isEthereumChecksum } from './isChecksum.js';

package/ethereum/isAddress.d.ts

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

package/ethereum/isAddress.js

@@ -0,0 +1,11 @@
+import { isHex } from '@pezkuwi/util';
+import { isEthereumChecksum } from './isChecksum.js';
+export function isEthereumAddress(address) {
+    if (!address || address.length !== 42 || !isHex(address)) {
+        return false;
+    }
+    else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
+        return true;
+    }
+    return isEthereumChecksum(address);
+}

package/ethereum/isChecksum.d.ts

@@ -0,0 +1 @@
+export declare function isEthereumChecksum(_address: string): boolean;

package/ethereum/isChecksum.js

@@ -0,0 +1,17 @@
+import { u8aToHex } from '@pezkuwi/util';
+import { keccakAsU8a } from '../keccak/index.js';
+function isInvalidChar(char, byte) {
+    return char !== (byte > 7
+        ? char.toUpperCase()
+        : char.toLowerCase());
+}
+export function isEthereumChecksum(_address) {
+    const address = _address.replace('0x', '');
+    const hash = u8aToHex(keccakAsU8a(address.toLowerCase()), -1, false);
+    for (let i = 0; i < 40; i++) {
+        if (isInvalidChar(address[i], parseInt(hash[i], 16))) {
+            return false;
+        }
+    }
+    return true;
+}

package/hd/ethereum/index.d.ts

@@ -0,0 +1,2 @@
+import type { Keypair } from '../../types.js';
+export declare function hdEthereum(seed: Uint8Array, path?: string): Keypair;

package/hd/ethereum/index.js

@@ -0,0 +1,44 @@
+import { bnToU8a, stringToU8a, u8aConcat } from '@pezkuwi/util';
+import { BN_BE_32_OPTS } from '../../bn.js';
+import { hmacShaAsU8a } from '../../hmac/index.js';
+import { secp256k1PairFromSeed, secp256k1PrivateKeyTweakAdd } from '../../secp256k1/index.js';
+import { HARDENED, hdValidatePath } from '../validatePath.js';
+const MASTER_SECRET = stringToU8a('Bitcoin seed');
+function createCoded(secretKey, chainCode) {
+    return {
+        chainCode,
+        publicKey: secp256k1PairFromSeed(secretKey).publicKey,
+        secretKey
+    };
+}
+function deriveChild(hd, index) {
+    const indexBuffer = bnToU8a(index, BN_BE_32_OPTS);
+    const data = index >= HARDENED
+        ? u8aConcat(new Uint8Array(1), hd.secretKey, indexBuffer)
+        : u8aConcat(hd.publicKey, indexBuffer);
+    try {
+        const I = hmacShaAsU8a(hd.chainCode, data, 512);
+        return createCoded(secp256k1PrivateKeyTweakAdd(hd.secretKey, I.slice(0, 32)), I.slice(32));
+    }
+    catch {
+        // In case parse256(IL) >= n or ki == 0, proceed with the next value for i
+        return deriveChild(hd, index + 1);
+    }
+}
+export function hdEthereum(seed, path = '') {
+    const I = hmacShaAsU8a(MASTER_SECRET, seed, 512);
+    let hd = createCoded(I.slice(0, 32), I.slice(32));
+    if (!path || path === 'm' || path === 'M' || path === "m'" || path === "M'") {
+        return hd;
+    }
+    if (!hdValidatePath(path)) {
+        throw new Error('Invalid derivation path');
+    }
+    const parts = path.split('/').slice(1);
+    for (const p of parts) {
+        hd = deriveChild(hd, parseInt(p, 10) + ((p.length > 1) && p.endsWith("'")
+            ? HARDENED
+            : 0));
+    }
+    return hd;
+}

package/hd/index.d.ts

@@ -0,0 +1,3 @@
+export { hdEthereum } from './ethereum/index.js';
+export { hdLedger } from './ledger/index.js';
+export { hdValidatePath } from './validatePath.js';

package/hd/index.js

@@ -0,0 +1,3 @@
+export { hdEthereum } from './ethereum/index.js';
+export { hdLedger } from './ledger/index.js';
+export { hdValidatePath } from './validatePath.js';

package/hd/ledger/derivePrivate.d.ts

@@ -0,0 +1 @@
+export declare function ledgerDerivePrivate(xprv: Uint8Array, index: number): Uint8Array;

package/hd/ledger/derivePrivate.js

@@ -0,0 +1,12 @@
+import { BN_EIGHT, bnToU8a, u8aConcat, u8aToBn } from '@pezkuwi/util';
+import { BN_LE_32_OPTS, BN_LE_512_OPTS, BN_LE_OPTS } from '../../bn.js';
+import { hmacShaAsU8a } from '../../hmac/index.js';
+export function ledgerDerivePrivate(xprv, index) {
+    const kl = xprv.subarray(0, 32);
+    const kr = xprv.subarray(32, 64);
+    const cc = xprv.subarray(64, 96);
+    const data = u8aConcat([0], kl, kr, bnToU8a(index, BN_LE_32_OPTS));
+    const z = hmacShaAsU8a(cc, data, 512);
+    data[0] = 0x01;
+    return u8aConcat(bnToU8a(u8aToBn(kl, BN_LE_OPTS).iadd(u8aToBn(z.subarray(0, 28), BN_LE_OPTS).imul(BN_EIGHT)), BN_LE_512_OPTS).subarray(0, 32), bnToU8a(u8aToBn(kr, BN_LE_OPTS).iadd(u8aToBn(z.subarray(32, 64), BN_LE_OPTS)), BN_LE_512_OPTS).subarray(0, 32), hmacShaAsU8a(cc, data, 512).subarray(32, 64));
+}

package/hd/ledger/index.d.ts

@@ -0,0 +1,2 @@
+import type { Keypair } from '../../types.js';
+export declare function hdLedger(_mnemonic: string, path: string): Keypair;

package/hd/ledger/index.js

@@ -0,0 +1,30 @@
+import { ed25519PairFromSeed } from '../../ed25519/index.js';
+import { mnemonicValidate } from '../../mnemonic/index.js';
+import { HARDENED, hdValidatePath } from '../validatePath.js';
+import { ledgerDerivePrivate } from './derivePrivate.js';
+import { ledgerMaster } from './master.js';
+export function hdLedger(_mnemonic, path) {
+    const words = _mnemonic
+        .split(' ')
+        .map((s) => s.trim())
+        .filter((s) => s);
+    if (![12, 24, 25].includes(words.length)) {
+        throw new Error('Expected a mnemonic with 24 words (or 25 including a password)');
+    }
+    const [mnemonic, password] = words.length === 25
+        ? [words.slice(0, 24).join(' '), words[24]]
+        : [words.join(' '), ''];
+    if (!mnemonicValidate(mnemonic)) {
+        throw new Error('Invalid mnemonic passed to ledger derivation');
+    }
+    else if (!hdValidatePath(path)) {
+        throw new Error('Invalid derivation path');
+    }
+    const parts = path.split('/').slice(1);
+    let seed = ledgerMaster(mnemonic, password);
+    for (const p of parts) {
+        const n = parseInt(p.replace(/'$/, ''), 10);
+        seed = ledgerDerivePrivate(seed, (n < HARDENED) ? (n + HARDENED) : n);
+    }
+    return ed25519PairFromSeed(seed.slice(0, 32));
+}

package/hd/ledger/master.d.ts

@@ -0,0 +1 @@
+export declare function ledgerMaster(mnemonic: string, password?: string): Uint8Array;

package/hd/ledger/master.js

@@ -0,0 +1,16 @@
+import { u8aConcat } from '@pezkuwi/util';
+import { hmacShaAsU8a } from '../../hmac/index.js';
+import { mnemonicToSeedSync } from '../../mnemonic/bip39.js';
+const ED25519_CRYPTO = 'ed25519 seed';
+export function ledgerMaster(mnemonic, password) {
+    const seed = mnemonicToSeedSync(mnemonic, password);
+    const chainCode = hmacShaAsU8a(ED25519_CRYPTO, new Uint8Array([1, ...seed]), 256);
+    let priv;
+    while (!priv || (priv[31] & 0b0010_0000)) {
+        priv = hmacShaAsU8a(ED25519_CRYPTO, priv || seed, 512);
+    }
+    priv[0] &= 0b1111_1000;
+    priv[31] &= 0b0111_1111;
+    priv[31] |= 0b0100_0000;
+    return u8aConcat(priv, chainCode);
+}

package/hd/validatePath.d.ts

@@ -0,0 +1,2 @@
+export declare const HARDENED = 2147483648;
+export declare function hdValidatePath(path: string): boolean;

package/hd/validatePath.js

@@ -0,0 +1,16 @@
+export const HARDENED = 0x80000000;
+export function hdValidatePath(path) {
+    if (!path.startsWith('m/')) {
+        return false;
+    }
+    const parts = path.split('/').slice(1);
+    for (const p of parts) {
+        const n = /^\d+'?$/.test(p)
+            ? parseInt(p.replace(/'$/, ''), 10)
+            : Number.NaN;
+        if (isNaN(n) || (n >= HARDENED) || (n < 0)) {
+            return false;
+        }
+    }
+    return true;
+}

package/helpers.d.ts

@@ -0,0 +1,12 @@
+import type { HexString } from '@polkadot/util/types';
+export type { HexString } from '@polkadot/util/types';
+interface DualHash {
+    256: (u8a: Uint8Array) => Uint8Array;
+    512: (u8a: Uint8Array) => Uint8Array;
+}
+/** @internal */
+export declare function createAsHex<T extends (...args: never[]) => Uint8Array>(fn: T): (...args: Parameters<T>) => HexString;
+/** @internal */
+export declare function createBitHasher(bitLength: 256 | 512, fn: (data: string | Uint8Array, bitLength: 256 | 512, onlyJs?: boolean) => Uint8Array): (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/** @internal */
+export declare function createDualHasher(wa: DualHash, js: DualHash): (value: string | Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array;

package/helpers.js

@@ -0,0 +1,19 @@
+import { hasBigInt, u8aToHex, u8aToU8a } from '@pezkuwi/util';
+import { isReady } from '@pezkuwi/wasm-crypto';
+/** @internal */
+export function createAsHex(fn) {
+    return (...args) => u8aToHex(fn(...args));
+}
+/** @internal */
+export function createBitHasher(bitLength, fn) {
+    return (data, onlyJs) => fn(data, bitLength, onlyJs);
+}
+/** @internal */
+export function createDualHasher(wa, js) {
+    return (value, bitLength = 256, onlyJs) => {
+        const u8a = u8aToU8a(value);
+        return !hasBigInt || (!onlyJs && isReady())
+            ? wa[bitLength](u8a)
+            : js[bitLength](u8a);
+    };
+}

package/hmac/index.d.ts

@@ -0,0 +1 @@
+export { hmacSha256AsU8a, hmacSha512AsU8a, hmacShaAsU8a } from './shaAsU8a.js';

package/hmac/index.js

@@ -0,0 +1 @@
+export { hmacSha256AsU8a, hmacSha512AsU8a, hmacShaAsU8a } from './shaAsU8a.js';

package/hmac/shaAsU8a.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name hmacShaAsU8a
+ * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
+ */
+export declare function hmacShaAsU8a(key: Uint8Array | string, data: Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean): Uint8Array;
+/**
+ * @name hmacSha256AsU8a
+ * @description creates a Hmac Sha256 Uint8Array from the key & data
+ */
+export declare const hmacSha256AsU8a: (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name hmacSha512AsU8a
+ * @description creates a Hmac Sha512 Uint8Array from the key & data
+ */
+export declare const hmacSha512AsU8a: (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array;