@pezkuwi/util-crypto 14.0.13 → 14.0.15

package/build/signature/verify.js

@@ -1,78 +0,0 @@
-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/build/sr25519/agreement.d.ts

@@ -1,5 +0,0 @@
-/**
- * @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/build/sr25519/agreement.js

@@ -1,17 +0,0 @@
-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/build/sr25519/derive.d.ts

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

package/build/sr25519/derive.js

@@ -1,12 +0,0 @@
-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/build/sr25519/deriveHard.d.ts

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

package/build/sr25519/deriveHard.js

@@ -1,3 +0,0 @@
-import * as sr25519 from '@scure/sr25519';
-import { createDeriveFn } from './derive.js';
-export const sr25519DeriveHard = /*#__PURE__*/ createDeriveFn(sr25519.HDKD.secretHard);

package/build/sr25519/derivePublic.d.ts

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

package/build/sr25519/derivePublic.js

@@ -1,12 +0,0 @@
-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/build/sr25519/deriveSoft.d.ts

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

package/build/sr25519/deriveSoft.js

@@ -1,3 +0,0 @@
-import * as sr25519 from '@scure/sr25519';
-import { createDeriveFn } from './derive.js';
-export const sr25519DeriveSoft = /*#__PURE__*/ createDeriveFn(sr25519.HDKD.secretSoft);

package/build/sr25519/index.d.ts

@@ -1,9 +0,0 @@
-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/build/sr25519/index.js

@@ -1,9 +0,0 @@
-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/build/sr25519/pair/fromSeed.d.ts

@@ -1,6 +0,0 @@
-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/build/sr25519/pair/fromSeed.js

@@ -1,18 +0,0 @@
-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/build/sr25519/pair/fromU8a.d.ts

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

package/build/sr25519/pair/fromU8a.js

@@ -1,14 +0,0 @@
-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/build/sr25519/pair/toU8a.d.ts

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

package/build/sr25519/pair/toU8a.js

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

package/build/sr25519/sign.d.ts

@@ -1,6 +0,0 @@
-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/build/sr25519/sign.js

@@ -1,15 +0,0 @@
-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/build/sr25519/verify.d.ts

@@ -1,5 +0,0 @@
-/**
- * @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/build/sr25519/verify.js

@@ -1,17 +0,0 @@
-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/build/sr25519/vrfSign.d.ts

@@ -1,6 +0,0 @@
-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/build/sr25519/vrfSign.js

@@ -1,15 +0,0 @@
-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/build/sr25519/vrfVerify.d.ts

@@ -1,5 +0,0 @@
-/**
- * @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/build/sr25519/vrfVerify.js

@@ -1,18 +0,0 @@
-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/build/types.d.ts

@@ -1,26 +0,0 @@
-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/build/types.js

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

package/build/xxhash/asU8a.d.ts

@@ -1,20 +0,0 @@
-/**
- * @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<ArrayBufferLike>, bitLength?: 256 | 512 | 64 | 128 | 384 | 320 | 192 | 448 | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;

package/build/xxhash/asU8a.js

@@ -1,35 +0,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.
- * @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 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.
- */
-export const xxhashAsHex = /*#__PURE__*/ createAsHex(xxhashAsU8a);

package/build/xxhash/index.d.ts

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

package/build/xxhash/index.js

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

package/build/xxhash/xxhash64.d.ts

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

package/build/xxhash/xxhash64.js

@@ -1,100 +0,0 @@
-import { _0n, _1n } from '@pezkuwi/util';
-import { BigInt } from '@pezkuwi/x-bigint';
-const P64_1 = BigInt('11400714785074694791');
-const P64_2 = BigInt('14029467366897019727');
-const P64_3 = BigInt('1609587929392839161');
-const P64_4 = BigInt('9650029242287828579');
-const P64_5 = BigInt('2870177450012600261');
-const U64 = BigInt('0xffffffffffffffff');
-const _7n = BigInt(7);
-const _11n = BigInt(11);
-const _12n = BigInt(12);
-const _16n = BigInt(16);
-const _18n = BigInt(18);
-const _23n = BigInt(23);
-const _27n = BigInt(27);
-const _29n = BigInt(29);
-const _31n = BigInt(31);
-const _32n = BigInt(32);
-const _33n = BigInt(33);
-const _64n = BigInt(64);
-const _256n = 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] = BigInt(u8a[p + offset] | (u8a[p + 1 + offset] << 8));
-    }
-    let result = _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;
-}
-export function xxhash64(input, initSeed) {
-    const { seed, u8a, u8asize, v1, v2, v3, v4 } = init(BigInt(initSeed), input);
-    let p = 0;
-    let h64 = U64 & (BigInt(input.length) + (input.length >= 32
-        ? (((((((((rotl(v1, _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 * 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-deno/README.md

@@ -1,17 +0,0 @@
-# @pezkuwi/util-crypto
-
-Various useful cyrpto utility functions that are used across all projects in the [@pezkuwi](https://pezkuwi.js.org) namespace. It provides utility functions with additional safety checks, allowing not only for consistent coding, but also reducing the general boilerplate.
-
-## Usage
-
-Installation -
-
-```
-yarn add @pezkuwi/util-crypto
-```
-
-Functions can be imported as follows:
-
-```js
-import { mnemonicGenerate } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
-```

package/build-deno/address/addressToEvm.ts

@@ -1,10 +0,0 @@
-
-import { decodeAddress } from './decode.ts';
-
-/**
- * @name addressToEvm
- * @summary Converts an SS58 address to its corresponding EVM address.
- */
-export function addressToEvm (address: string | Uint8Array, ignoreChecksum?: boolean): Uint8Array {
-  return decodeAddress(address, ignoreChecksum).subarray(0, 20);
-}

package/build-deno/address/check.ts

@@ -1,32 +0,0 @@
-
-import type { Prefix } from './types.ts';
-
-import { base58Decode } from '../base58/index.ts';
-import { checkAddressChecksum } from './checksum.ts';
-import { defaults } from './defaults.ts';
-
-/**
- * @name checkAddress
- * @summary Validates an ss58 address.
- * @description
- * From the provided input, validate that the address is a valid input.
- */
-export function checkAddress (address: string, prefix: Prefix): [boolean, string | null] {
-  let decoded;
-
-  try {
-    decoded = base58Decode(address);
-  } catch (error) {
-    return [false, (error as Error).message];
-  }
-
-  const [isValid,,, ss58Decoded] = checkAddressChecksum(decoded);
-
-  if (ss58Decoded !== prefix) {
-    return [false, `Prefix mismatch, expected ${prefix}, found ${ss58Decoded}`];
-  } else if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
-    return [false, 'Invalid decoded address length'];
-  }
-
-  return [isValid, isValid ? null : 'Invalid decoded address checksum'];
-}

package/build-deno/address/checksum.ts

@@ -1,23 +0,0 @@
-
-import { sshash } from './sshash.ts';
-
-export function checkAddressChecksum (decoded: Uint8Array): [boolean, number, number, number] {
-  const ss58Length = (decoded[0] & 0b0100_0000) ? 2 : 1;
-  const ss58Decoded = ss58Length === 1
-    ? decoded[0]
-    : ((decoded[0] & 0b0011_1111) << 2) | (decoded[1] >> 6) | ((decoded[1] & 0b0011_1111) << 8);
-
-  // 32/33 bytes public + 2 bytes checksum + prefix
-  const isPublicKey = [34 + ss58Length, 35 + ss58Length].includes(decoded.length);
-  const length = decoded.length - (isPublicKey ? 2 : 1);
-
-  // calculate the hash and do the checksum byte checks
-  const hash = sshash(decoded.subarray(0, length));
-  const isValid = (decoded[0] & 0b1000_0000) === 0 && ![46, 47].includes(decoded[0]) && (
-    isPublicKey
-      ? decoded[decoded.length - 2] === hash[0] && decoded[decoded.length - 1] === hash[1]
-      : decoded[decoded.length - 1] === hash[0]
-  );
-
-  return [isValid, length, ss58Length, ss58Decoded];
-}