@pezkuwi/util-crypto 14.0.10 → 14.0.12

package/cjs/base32/bs32.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base32Encode = exports.base32Decode = exports.isBase32 = exports.base32Validate = void 0;
+const base_1 = require("@scure/base");
+const helpers_js_1 = require("./helpers.js");
+const chars = 'abcdefghijklmnopqrstuvwxyz234567';
+const config = {
+    chars,
+    coder: base_1.utils.chain(
+    // We define our own chain, the default base32 has padding
+    base_1.utils.radix2(5), base_1.utils.alphabet(chars), {
+        decode: (input) => input.split(''),
+        encode: (input) => input.join('')
+    }),
+    ipfs: 'b',
+    type: 'base32'
+};
+/**
+ * @name base32Validate
+ * @summary Validates a base32 value.
+ * @description
+ * Validates that the supplied value is valid base32, throwing exceptions if not
+ */
+exports.base32Validate = (0, helpers_js_1.createValidate)(config);
+/**
+* @name isBase32
+* @description Checks if the input is in base32, returning true/false
+*/
+exports.isBase32 = (0, helpers_js_1.createIs)(exports.base32Validate);
+/**
+ * @name base32Decode
+ * @summary Delookup a base32 value.
+ * @description
+ * From the provided input, decode the base32 and return the result as an `Uint8Array`.
+ */
+exports.base32Decode = (0, helpers_js_1.createDecode)(config, exports.base32Validate);
+/**
+* @name base32Encode
+* @summary Creates a base32 value.
+* @description
+* From the provided input, create the base32 and return the result as a string.
+*/
+exports.base32Encode = (0, helpers_js_1.createEncode)(config);

package/cjs/base32/helpers.d.ts

@@ -0,0 +1,25 @@
+import type { U8aLike } from '@pezkuwi/util/types';
+export type { U8aLike } from '@pezkuwi/util/types';
+interface Coder {
+    decode: (value: string) => Uint8Array;
+    encode: (value: Uint8Array) => string;
+}
+interface Config {
+    chars: string;
+    coder: Coder;
+    ipfs?: string;
+    regex?: RegExp;
+    type: string;
+    withPadding?: boolean;
+}
+type DecodeFn = (value: string, ipfsCompat?: boolean) => Uint8Array;
+type EncodeFn = (value: U8aLike, ipfsCompat?: boolean) => string;
+type ValidateFn = (value?: unknown, ipfsCompat?: boolean) => value is string;
+/** @internal */
+export declare function createDecode({ coder, ipfs }: Config, validate: ValidateFn): DecodeFn;
+/** @internal */
+export declare function createEncode({ coder, ipfs }: Config): EncodeFn;
+/** @internal */
+export declare function createIs(validate: ValidateFn): ValidateFn;
+/** @internal */
+export declare function createValidate({ chars, ipfs, type, withPadding }: Config): ValidateFn;

package/cjs/base32/helpers.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDecode = createDecode;
+exports.createEncode = createEncode;
+exports.createIs = createIs;
+exports.createValidate = createValidate;
+const util_1 = require("@pezkuwi/util");
+/** @internal */
+function createDecode({ coder, ipfs }, validate) {
+    return (value, ipfsCompat) => {
+        validate(value, ipfsCompat);
+        return coder.decode(ipfs && ipfsCompat
+            ? value.substring(1)
+            : value);
+    };
+}
+/** @internal */
+function createEncode({ coder, ipfs }) {
+    return (value, ipfsCompat) => {
+        const out = coder.encode((0, util_1.u8aToU8a)(value));
+        return ipfs && ipfsCompat
+            ? `${ipfs}${out}`
+            : out;
+    };
+}
+/** @internal */
+function createIs(validate) {
+    return (value, ipfsCompat) => {
+        try {
+            return validate(value, ipfsCompat);
+        }
+        catch {
+            return false;
+        }
+    };
+}
+/** @internal */
+function createValidate({ chars, ipfs, type, withPadding }) {
+    return (value, ipfsCompat) => {
+        if (typeof value !== 'string') {
+            throw new Error(`Expected ${type} string input`);
+        }
+        else if (ipfs && ipfsCompat && !value.startsWith(ipfs)) {
+            throw new Error(`Expected ipfs-compatible ${type} to start with '${ipfs}'`);
+        }
+        for (let i = (ipfsCompat ? 1 : 0), count = value.length; i < count; i++) {
+            if (chars.includes(value[i])) {
+                // all ok, character found
+            }
+            else if (withPadding && value[i] === '=') {
+                if (i === count - 1) {
+                    // last character, everything ok
+                }
+                else if (value[i + 1] === '=') {
+                    // next one is also padding, sequence ok
+                }
+                else {
+                    throw new Error(`Invalid ${type} padding sequence "${value[i]}${value[i + 1]}" at index ${i}`);
+                }
+            }
+            else {
+                throw new Error(`Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
+            }
+        }
+        return true;
+    };
+}

package/cjs/base32/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @summary Encode and decode base32 values
+ */
+export { base32Decode, base32Encode, base32Validate, isBase32 } from './bs32.js';

package/cjs/base32/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBase32 = exports.base32Validate = exports.base32Encode = exports.base32Decode = void 0;
+/**
+ * @summary Encode and decode base32 values
+ */
+var bs32_js_1 = require("./bs32.js");
+Object.defineProperty(exports, "base32Decode", { enumerable: true, get: function () { return bs32_js_1.base32Decode; } });
+Object.defineProperty(exports, "base32Encode", { enumerable: true, get: function () { return bs32_js_1.base32Encode; } });
+Object.defineProperty(exports, "base32Validate", { enumerable: true, get: function () { return bs32_js_1.base32Validate; } });
+Object.defineProperty(exports, "isBase32", { enumerable: true, get: function () { return bs32_js_1.isBase32; } });

package/cjs/base58/bs58.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @name base58Validate
+ * @summary Validates a base58 value.
+ * @description
+ * Validates that the supplied value is valid base58, throwing exceptions if not
+ */
+export declare const base58Validate: (value?: unknown, ipfsCompat?: boolean) => value is string;
+/**
+ * @name base58Decode
+ * @summary Decodes a base58 value.
+ * @description
+ * From the provided input, decode the base58 and return the result as an `Uint8Array`.
+ */
+export declare const base58Decode: (value: string, ipfsCompat?: boolean) => Uint8Array;
+/**
+* @name base58Encode
+* @summary Creates a base58 value.
+* @description
+* From the provided input, create the base58 and return the result as a string.
+*/
+export declare const base58Encode: (value: import("@pezkuwi/util/types").U8aLike, ipfsCompat?: boolean) => string;
+/**
+* @name isBase58
+* @description Checks if the input is in base58, returning true/false
+*/
+export declare const isBase58: (value?: unknown, ipfsCompat?: boolean) => value is string;

package/cjs/base58/bs58.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBase58 = exports.base58Encode = exports.base58Decode = exports.base58Validate = void 0;
+const base_1 = require("@scure/base");
+const helpers_js_1 = require("../base32/helpers.js");
+const config = {
+    chars: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
+    coder: base_1.base58,
+    ipfs: 'z',
+    type: 'base58'
+};
+/**
+ * @name base58Validate
+ * @summary Validates a base58 value.
+ * @description
+ * Validates that the supplied value is valid base58, throwing exceptions if not
+ */
+exports.base58Validate = (0, helpers_js_1.createValidate)(config);
+/**
+ * @name base58Decode
+ * @summary Decodes a base58 value.
+ * @description
+ * From the provided input, decode the base58 and return the result as an `Uint8Array`.
+ */
+exports.base58Decode = (0, helpers_js_1.createDecode)(config, exports.base58Validate);
+/**
+* @name base58Encode
+* @summary Creates a base58 value.
+* @description
+* From the provided input, create the base58 and return the result as a string.
+*/
+exports.base58Encode = (0, helpers_js_1.createEncode)(config);
+/**
+* @name isBase58
+* @description Checks if the input is in base58, returning true/false
+*/
+exports.isBase58 = (0, helpers_js_1.createIs)(exports.base58Validate);

package/cjs/base58/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @summary Encode and decode base58 values
+ */
+export { base58Decode, base58Encode, base58Validate, isBase58 } from './bs58.js';

package/cjs/base58/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBase58 = exports.base58Validate = exports.base58Encode = exports.base58Decode = void 0;
+/**
+ * @summary Encode and decode base58 values
+ */
+var bs58_js_1 = require("./bs58.js");
+Object.defineProperty(exports, "base58Decode", { enumerable: true, get: function () { return bs58_js_1.base58Decode; } });
+Object.defineProperty(exports, "base58Encode", { enumerable: true, get: function () { return bs58_js_1.base58Encode; } });
+Object.defineProperty(exports, "base58Validate", { enumerable: true, get: function () { return bs58_js_1.base58Validate; } });
+Object.defineProperty(exports, "isBase58", { enumerable: true, get: function () { return bs58_js_1.isBase58; } });

package/cjs/base64/bs64.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @name base64Validate
+ * @summary Validates a base64 value.
+ * @description
+ * Validates that the supplied value is valid base64
+ */
+export declare const base64Validate: (value?: unknown, ipfsCompat?: boolean) => value is string;
+/**
+ * @name isBase64
+ * @description Checks if the input is in base64, returning true/false
+ */
+export declare const isBase64: (value?: unknown, ipfsCompat?: boolean) => value is string;
+/**
+ * @name base64Decode
+ * @summary Decodes a base64 value.
+ * @description
+ * From the provided input, decode the base64 and return the result as an `Uint8Array`.
+ */
+export declare const base64Decode: (value: string, ipfsCompat?: boolean) => Uint8Array;
+/**
+ * @name base64Encode
+ * @summary Creates a base64 value.
+ * @description
+ * From the provided input, create the base64 and return the result as a string.
+ */
+export declare const base64Encode: (value: import("@pezkuwi/util/types").U8aLike, ipfsCompat?: boolean) => string;

package/cjs/base64/bs64.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Encode = exports.base64Decode = exports.isBase64 = exports.base64Validate = void 0;
+const base_1 = require("@scure/base");
+const helpers_js_1 = require("../base32/helpers.js");
+const config = {
+    chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+    coder: base_1.base64,
+    type: 'base64',
+    withPadding: true
+};
+/**
+ * @name base64Validate
+ * @summary Validates a base64 value.
+ * @description
+ * Validates that the supplied value is valid base64
+ */
+exports.base64Validate = (0, helpers_js_1.createValidate)(config);
+/**
+ * @name isBase64
+ * @description Checks if the input is in base64, returning true/false
+ */
+exports.isBase64 = (0, helpers_js_1.createIs)(exports.base64Validate);
+/**
+ * @name base64Decode
+ * @summary Decodes a base64 value.
+ * @description
+ * From the provided input, decode the base64 and return the result as an `Uint8Array`.
+ */
+exports.base64Decode = (0, helpers_js_1.createDecode)(config, exports.base64Validate);
+/**
+ * @name base64Encode
+ * @summary Creates a base64 value.
+ * @description
+ * From the provided input, create the base64 and return the result as a string.
+ */
+exports.base64Encode = (0, helpers_js_1.createEncode)(config);

package/cjs/base64/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @summary Encode and decode base64 values
+ */
+export { base64Decode, base64Encode, base64Validate, isBase64 } from './bs64.js';
+export { base64Pad } from './pad.js';
+export { base64Trim } from './trim.js';

package/cjs/base64/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Trim = exports.base64Pad = exports.isBase64 = exports.base64Validate = exports.base64Encode = exports.base64Decode = void 0;
+/**
+ * @summary Encode and decode base64 values
+ */
+var bs64_js_1 = require("./bs64.js");
+Object.defineProperty(exports, "base64Decode", { enumerable: true, get: function () { return bs64_js_1.base64Decode; } });
+Object.defineProperty(exports, "base64Encode", { enumerable: true, get: function () { return bs64_js_1.base64Encode; } });
+Object.defineProperty(exports, "base64Validate", { enumerable: true, get: function () { return bs64_js_1.base64Validate; } });
+Object.defineProperty(exports, "isBase64", { enumerable: true, get: function () { return bs64_js_1.isBase64; } });
+var pad_js_1 = require("./pad.js");
+Object.defineProperty(exports, "base64Pad", { enumerable: true, get: function () { return pad_js_1.base64Pad; } });
+var trim_js_1 = require("./trim.js");
+Object.defineProperty(exports, "base64Trim", { enumerable: true, get: function () { return trim_js_1.base64Trim; } });

package/cjs/base64/pad.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name base64Pad
+ * @description Adds padding characters for correct length
+ */
+export declare function base64Pad(value: string): string;

package/cjs/base64/pad.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Pad = base64Pad;
+/**
+ * @name base64Pad
+ * @description Adds padding characters for correct length
+ */
+function base64Pad(value) {
+    return value.padEnd(value.length + (value.length % 4), '=');
+}

package/cjs/base64/trim.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name base64Trim
+ * @description Trims padding characters
+ */
+export declare function base64Trim(value: string): string;

package/cjs/base64/trim.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Trim = base64Trim;
+/**
+ * @name base64Trim
+ * @description Trims padding characters
+ */
+function base64Trim(value) {
+    while (value.length && value.endsWith('=')) {
+        value = value.slice(0, -1);
+    }
+    return value;
+}

package/cjs/blake2/asU8a.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @name blake2AsU8a
+ * @summary Creates a blake2b u8a from the input.
+ * @description
+ * From a `Uint8Array` input, create the blake2b and return the result as a u8a with the specified `bitLength`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { blake2AsU8a } from '@pezkuwi/util-crypto';
+ *
+ * blake2AsU8a('abc'); // => [0xba, 0x80, 0xa5, 0x3f, 0x98, 0x1c, 0x4d, 0x0d]
+ * ```
+ */
+export declare function blake2AsU8a(data: string | Uint8Array, bitLength?: 64 | 128 | 256 | 384 | 512, key?: Uint8Array | null, onlyJs?: boolean): Uint8Array;
+/**
+ * @name blake2AsHex
+ * @description Creates a blake2b hex from the input.
+ */
+export declare const blake2AsHex: (data: string | Uint8Array, bitLength?: 256 | 512 | 64 | 128 | 384 | undefined, key?: Uint8Array | null | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;

package/cjs/blake2/asU8a.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blake2AsHex = void 0;
+exports.blake2AsU8a = blake2AsU8a;
+const blake2b_1 = require("@noble/hashes/blake2b");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const helpers_js_1 = require("../helpers.js");
+/**
+ * @name blake2AsU8a
+ * @summary Creates a blake2b u8a from the input.
+ * @description
+ * From a `Uint8Array` input, create the blake2b and return the result as a u8a with the specified `bitLength`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { blake2AsU8a } from '@pezkuwi/util-crypto';
+ *
+ * blake2AsU8a('abc'); // => [0xba, 0x80, 0xa5, 0x3f, 0x98, 0x1c, 0x4d, 0x0d]
+ * ```
+ */
+function blake2AsU8a(data, bitLength = 256, key, onlyJs) {
+    const byteLength = Math.ceil(bitLength / 8);
+    const u8a = (0, util_1.u8aToU8a)(data);
+    return !util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())
+        ? (0, wasm_crypto_1.blake2b)(u8a, (0, util_1.u8aToU8a)(key), byteLength)
+        : key
+            ? (0, blake2b_1.blake2b)(u8a, { dkLen: byteLength, key })
+            : (0, blake2b_1.blake2b)(u8a, { dkLen: byteLength });
+}
+/**
+ * @name blake2AsHex
+ * @description Creates a blake2b hex from the input.
+ */
+exports.blake2AsHex = (0, helpers_js_1.createAsHex)(blake2AsU8a);

package/cjs/blake2/index.d.ts

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

package/cjs/blake2/index.js

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

package/cjs/bn.d.ts

@@ -0,0 +1,30 @@
+export declare const BN_BE_OPTS: {
+    isLe: boolean;
+};
+export declare const BN_LE_OPTS: {
+    isLe: boolean;
+};
+export declare const BN_LE_16_OPTS: {
+    bitLength: number;
+    isLe: boolean;
+};
+export declare const BN_BE_32_OPTS: {
+    bitLength: number;
+    isLe: boolean;
+};
+export declare const BN_LE_32_OPTS: {
+    bitLength: number;
+    isLe: boolean;
+};
+export declare const BN_BE_256_OPTS: {
+    bitLength: number;
+    isLe: boolean;
+};
+export declare const BN_LE_256_OPTS: {
+    bitLength: number;
+    isLe: boolean;
+};
+export declare const BN_LE_512_OPTS: {
+    bitLength: number;
+    isLe: boolean;
+};

package/cjs/bn.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BN_LE_512_OPTS = exports.BN_LE_256_OPTS = exports.BN_BE_256_OPTS = exports.BN_LE_32_OPTS = exports.BN_BE_32_OPTS = exports.BN_LE_16_OPTS = exports.BN_LE_OPTS = exports.BN_BE_OPTS = void 0;
+exports.BN_BE_OPTS = { isLe: false };
+exports.BN_LE_OPTS = { isLe: true };
+exports.BN_LE_16_OPTS = { bitLength: 16, isLe: true };
+exports.BN_BE_32_OPTS = { bitLength: 32, isLe: false };
+exports.BN_LE_32_OPTS = { bitLength: 32, isLe: true };
+exports.BN_BE_256_OPTS = { bitLength: 256, isLe: false };
+exports.BN_LE_256_OPTS = { bitLength: 256, isLe: true };
+exports.BN_LE_512_OPTS = { bitLength: 512, isLe: true };

package/cjs/bundle.d.ts

@@ -0,0 +1,26 @@
+import './bundleInit.js';
+export { packageInfo } from './packageInfo.js';
+export * from './address/index.js';
+export * from './base32/index.js';
+export * from './base58/index.js';
+export * from './base64/index.js';
+export * from './blake2/index.js';
+export * from './crypto.js';
+export * from './ed25519/index.js';
+export * from './ethereum/index.js';
+export * from './hd/index.js';
+export * from './hmac/index.js';
+export * from './json/index.js';
+export * from './keccak/index.js';
+export * from './key/index.js';
+export * from './mnemonic/index.js';
+export * from './nacl/index.js';
+export * from './networks.js';
+export * from './pbkdf2/index.js';
+export * from './random/index.js';
+export * from './scrypt/index.js';
+export * from './secp256k1/index.js';
+export * from './sha/index.js';
+export * from './signature/index.js';
+export * from './sr25519/index.js';
+export * from './xxhash/index.js';

package/cjs/bundle.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+const tslib_1 = require("tslib");
+require("./bundleInit.js");
+var packageInfo_js_1 = require("./packageInfo.js");
+Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+tslib_1.__exportStar(require("./address/index.js"), exports);
+tslib_1.__exportStar(require("./base32/index.js"), exports);
+tslib_1.__exportStar(require("./base58/index.js"), exports);
+tslib_1.__exportStar(require("./base64/index.js"), exports);
+tslib_1.__exportStar(require("./blake2/index.js"), exports);
+tslib_1.__exportStar(require("./crypto.js"), exports);
+tslib_1.__exportStar(require("./ed25519/index.js"), exports);
+tslib_1.__exportStar(require("./ethereum/index.js"), exports);
+tslib_1.__exportStar(require("./hd/index.js"), exports);
+tslib_1.__exportStar(require("./hmac/index.js"), exports);
+tslib_1.__exportStar(require("./json/index.js"), exports);
+tslib_1.__exportStar(require("./keccak/index.js"), exports);
+tslib_1.__exportStar(require("./key/index.js"), exports);
+tslib_1.__exportStar(require("./mnemonic/index.js"), exports);
+tslib_1.__exportStar(require("./nacl/index.js"), exports);
+tslib_1.__exportStar(require("./networks.js"), exports);
+tslib_1.__exportStar(require("./pbkdf2/index.js"), exports);
+tslib_1.__exportStar(require("./random/index.js"), exports);
+tslib_1.__exportStar(require("./scrypt/index.js"), exports);
+tslib_1.__exportStar(require("./secp256k1/index.js"), exports);
+tslib_1.__exportStar(require("./sha/index.js"), exports);
+tslib_1.__exportStar(require("./signature/index.js"), exports);
+tslib_1.__exportStar(require("./sr25519/index.js"), exports);
+tslib_1.__exportStar(require("./xxhash/index.js"), exports);

package/cjs/bundleInit.d.ts

@@ -0,0 +1 @@
+import '@pezkuwi/x-bigint/shim';

package/cjs/bundleInit.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@pezkuwi/x-bigint/shim");
+const crypto_js_1 = require("./crypto.js");
+(0, crypto_js_1.cryptoWaitReady)().catch(() => {
+    // shouldn't happen, logged and caught inside cryptoWaitReady
+});

package/cjs/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/cjs/crypto.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cryptoIsReady = void 0;
+exports.cryptoWaitReady = cryptoWaitReady;
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+exports.cryptoIsReady = wasm_crypto_1.isReady;
+function cryptoWaitReady() {
+    return (0, wasm_crypto_1.waitReady)()
+        .then(() => {
+        if (!(0, wasm_crypto_1.isReady)()) {
+            throw new Error('Unable to initialize @pezkuwi/util-crypto');
+        }
+        return true;
+    })
+        .catch(() => false);
+}

package/cjs/ed25519/deriveHard.d.ts

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

package/cjs/ed25519/deriveHard.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519DeriveHard = ed25519DeriveHard;
+const util_1 = require("@pezkuwi/util");
+const asU8a_js_1 = require("../blake2/asU8a.js");
+const HDKD = (0, util_1.compactAddLength)((0, util_1.stringToU8a)('Ed25519HDKD'));
+function ed25519DeriveHard(seed, chainCode) {
+    if (!(0, util_1.isU8a)(chainCode) || chainCode.length !== 32) {
+        throw new Error('Invalid chainCode passed to derive');
+    }
+    return (0, asU8a_js_1.blake2AsU8a)((0, util_1.u8aConcat)(HDKD, seed, chainCode));
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519Verify = exports.ed25519Sign = exports.ed25519PairFromString = exports.ed25519PairFromSeed = exports.ed25519PairFromSecret = exports.ed25519PairFromRandom = exports.ed25519DeriveHard = void 0;
+/**
+ * @summary Implements ed25519 operations
+ */
+var deriveHard_js_1 = require("./deriveHard.js");
+Object.defineProperty(exports, "ed25519DeriveHard", { enumerable: true, get: function () { return deriveHard_js_1.ed25519DeriveHard; } });
+var fromRandom_js_1 = require("./pair/fromRandom.js");
+Object.defineProperty(exports, "ed25519PairFromRandom", { enumerable: true, get: function () { return fromRandom_js_1.ed25519PairFromRandom; } });
+var fromSecret_js_1 = require("./pair/fromSecret.js");
+Object.defineProperty(exports, "ed25519PairFromSecret", { enumerable: true, get: function () { return fromSecret_js_1.ed25519PairFromSecret; } });
+var fromSeed_js_1 = require("./pair/fromSeed.js");
+Object.defineProperty(exports, "ed25519PairFromSeed", { enumerable: true, get: function () { return fromSeed_js_1.ed25519PairFromSeed; } });
+var fromString_js_1 = require("./pair/fromString.js");
+Object.defineProperty(exports, "ed25519PairFromString", { enumerable: true, get: function () { return fromString_js_1.ed25519PairFromString; } });
+var sign_js_1 = require("./sign.js");
+Object.defineProperty(exports, "ed25519Sign", { enumerable: true, get: function () { return sign_js_1.ed25519Sign; } });
+var verify_js_1 = require("./verify.js");
+Object.defineProperty(exports, "ed25519Verify", { enumerable: true, get: function () { return verify_js_1.ed25519Verify; } });

package/cjs/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 '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromRandom(); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export declare function ed25519PairFromRandom(): Keypair;