@pezkuwi/util-crypto 14.0.2 → 14.0.4

package/address/types.d.ts

@@ -0,0 +1 @@
+export type Prefix = number;

package/address/types.js

@@ -0,0 +1 @@
+export {};

package/address/util.d.ts

@@ -0,0 +1 @@
+export declare function addressToU8a(who: string | Uint8Array): Uint8Array;

package/address/util.js

@@ -0,0 +1,4 @@
+import { decodeAddress } from './decode.js';
+export function addressToU8a(who) {
+    return decodeAddress(who);
+}

package/address/validate.d.ts

@@ -0,0 +1,2 @@
+import type { Prefix } from './types.js';
+export declare function validateAddress(encoded?: string | null, ignoreChecksum?: boolean, ss58Format?: Prefix): encoded is string;

package/address/validate.js

@@ -0,0 +1,4 @@
+import { decodeAddress } from './decode.js';
+export function validateAddress(encoded, ignoreChecksum, ss58Format) {
+    return !!decodeAddress(encoded, ignoreChecksum, ss58Format);
+}

package/base32/bs32.d.ts

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

package/{src/base32/bs32.ts → base32/bs32.js}

@@ -1,27 +1,17 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { utils } from '@scure/base';
-
 import { createDecode, createEncode, createIs, createValidate } from './helpers.js';
-
 const chars = 'abcdefghijklmnopqrstuvwxyz234567';
-
 const config = {
-  chars,
-  coder: utils.chain(
+    chars,
+    coder: utils.chain(
     // We define our own chain, the default base32 has padding
-    utils.radix2(5),
-    utils.alphabet(chars),
-    {
-      decode: (input: string) => input.split(''),
-      encode: (input: string[]) => input.join('')
-    }
-  ),
-  ipfs: 'b',
-  type: 'base32'
+    utils.radix2(5), utils.alphabet(chars), {
+        decode: (input) => input.split(''),
+        encode: (input) => input.join('')
+    }),
+    ipfs: 'b',
+    type: 'base32'
 };
-
 /**
  * @name base32Validate
  * @summary Validates a base32 value.
@@ -29,13 +19,11 @@ const config = {
  * Validates that the supplied value is valid base32, throwing exceptions if not
  */
 export const base32Validate = /*#__PURE__*/ createValidate(config);
-
 /**
 * @name isBase32
 * @description Checks if the input is in base32, returning true/false
 */
 export const isBase32 = /*#__PURE__*/ createIs(base32Validate);
-
 /**
  * @name base32Decode
  * @summary Delookup a base32 value.
@@ -43,7 +31,6 @@ export const isBase32 = /*#__PURE__*/ createIs(base32Validate);
  * From the provided input, decode the base32 and return the result as an `Uint8Array`.
  */
 export const base32Decode = /*#__PURE__*/ createDecode(config, base32Validate);
-
 /**
 * @name base32Encode
 * @summary Creates a base32 value.

package/base32/helpers.d.ts

@@ -0,0 +1,25 @@
+import type { U8aLike } from '@polkadot/util/types';
+export type { U8aLike } from '@polkadot/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/base32/helpers.js

@@ -0,0 +1,61 @@
+import { u8aToU8a } from '@pezkuwi/util';
+/** @internal */
+export function createDecode({ coder, ipfs }, validate) {
+    return (value, ipfsCompat) => {
+        validate(value, ipfsCompat);
+        return coder.decode(ipfs && ipfsCompat
+            ? value.substring(1)
+            : value);
+    };
+}
+/** @internal */
+export function createEncode({ coder, ipfs }) {
+    return (value, ipfsCompat) => {
+        const out = coder.encode(u8aToU8a(value));
+        return ipfs && ipfsCompat
+            ? `${ipfs}${out}`
+            : out;
+    };
+}
+/** @internal */
+export function createIs(validate) {
+    return (value, ipfsCompat) => {
+        try {
+            return validate(value, ipfsCompat);
+        }
+        catch {
+            return false;
+        }
+    };
+}
+/** @internal */
+export 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/{src/base32/index.ts → base32/index.d.ts}

@@ -1,8 +1,4 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Encode and decode base32 values
  */
-
 export { base32Decode, base32Encode, base32Validate, isBase32 } from './bs32.js';

package/base32/index.js

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

package/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("@polkadot/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/{src/base58/bs58.ts → base58/bs58.js}

@@ -1,17 +1,11 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { base58 } from '@scure/base';
-
 import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers.js';
-
 const config = {
-  chars: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
-  coder: base58,
-  ipfs: 'z',
-  type: 'base58'
+    chars: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
+    coder: base58,
+    ipfs: 'z',
+    type: 'base58'
 };
-
 /**
  * @name base58Validate
  * @summary Validates a base58 value.
@@ -19,7 +13,6 @@ const config = {
  * Validates that the supplied value is valid base58, throwing exceptions if not
  */
 export const base58Validate = /*#__PURE__*/ createValidate(config);
-
 /**
  * @name base58Decode
  * @summary Decodes a base58 value.
@@ -27,7 +20,6 @@ export const base58Validate = /*#__PURE__*/ createValidate(config);
  * From the provided input, decode the base58 and return the result as an `Uint8Array`.
  */
 export const base58Decode = /*#__PURE__*/ createDecode(config, base58Validate);
-
 /**
 * @name base58Encode
 * @summary Creates a base58 value.
@@ -35,7 +27,6 @@ export const base58Decode = /*#__PURE__*/ createDecode(config, base58Validate);
 * From the provided input, create the base58 and return the result as a string.
 */
 export const base58Encode = /*#__PURE__*/ createEncode(config);
-
 /**
 * @name isBase58
 * @description Checks if the input is in base58, returning true/false

package/{src/base58/index.ts → base58/index.d.ts}

@@ -1,8 +1,4 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Encode and decode base58 values
  */
-
 export { base58Decode, base58Encode, base58Validate, isBase58 } from './bs58.js';

package/base58/index.js

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

package/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("@polkadot/util/types").U8aLike, ipfsCompat?: boolean) => string;

package/{src/base64/bs64.ts → base64/bs64.js}

@@ -1,17 +1,11 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { base64 } from '@scure/base';
-
 import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers.js';
-
 const config = {
-  chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
-  coder: base64,
-  type: 'base64',
-  withPadding: true
+    chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+    coder: base64,
+    type: 'base64',
+    withPadding: true
 };
-
 /**
  * @name base64Validate
  * @summary Validates a base64 value.
@@ -19,13 +13,11 @@ const config = {
  * Validates that the supplied value is valid base64
  */
 export const base64Validate = /*#__PURE__*/ createValidate(config);
-
 /**
  * @name isBase64
  * @description Checks if the input is in base64, returning true/false
  */
 export const isBase64 = /*#__PURE__*/ createIs(base64Validate);
-
 /**
  * @name base64Decode
  * @summary Decodes a base64 value.
@@ -33,7 +25,6 @@ export const isBase64 = /*#__PURE__*/ createIs(base64Validate);
  * From the provided input, decode the base64 and return the result as an `Uint8Array`.
  */
 export const base64Decode = /*#__PURE__*/ createDecode(config, base64Validate);
-
 /**
  * @name base64Encode
  * @summary Creates a base64 value.

package/{src/base64/index.ts → base64/index.d.ts}

@@ -1,10 +1,6 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @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/base64/index.js

@@ -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/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/base64/pad.js

@@ -0,0 +1,7 @@
+/**
+ * @name base64Pad
+ * @description Adds padding characters for correct length
+ */
+export function base64Pad(value) {
+    return value.padEnd(value.length + (value.length % 4), '=');
+}

package/base64/trim.d.ts

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

package/base64/trim.js

@@ -0,0 +1,10 @@
+/**
+ * @name base64Trim
+ * @description Trims padding characters
+ */
+export function base64Trim(value) {
+    while (value.length && value.endsWith('=')) {
+        value = value.slice(0, -1);
+    }
+    return value;
+}

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

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

@@ -1,13 +1,7 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { blake2b as blake2bJs } from '@noble/hashes/blake2b';
-
 import { hasBigInt, u8aToU8a } from '@pezkuwi/util';
 import { blake2b, isReady } from '@pezkuwi/wasm-crypto';
-
 import { createAsHex } from '../helpers.js';
-
 /**
  * @name blake2AsU8a
  * @summary Creates a blake2b u8a from the input.
@@ -22,17 +16,15 @@ import { createAsHex } from '../helpers.js';
  * blake2AsU8a('abc'); // => [0xba, 0x80, 0xa5, 0x3f, 0x98, 0x1c, 0x4d, 0x0d]
  * ```
  */
-export function blake2AsU8a (data: string | Uint8Array, bitLength: 64 | 128 | 256 | 384 | 512 = 256, key?: Uint8Array | null, onlyJs?: boolean): Uint8Array {
-  const byteLength = Math.ceil(bitLength / 8);
-  const u8a = u8aToU8a(data);
-
-  return !hasBigInt || (!onlyJs && isReady())
-    ? blake2b(u8a, u8aToU8a(key), byteLength)
-    : key
-      ? blake2bJs(u8a, { dkLen: byteLength, key })
-      : blake2bJs(u8a, { dkLen: byteLength });
+export function blake2AsU8a(data, bitLength = 256, key, onlyJs) {
+    const byteLength = Math.ceil(bitLength / 8);
+    const u8a = u8aToU8a(data);
+    return !hasBigInt || (!onlyJs && isReady())
+        ? blake2b(u8a, u8aToU8a(key), byteLength)
+        : key
+            ? blake2bJs(u8a, { dkLen: byteLength, key })
+            : blake2bJs(u8a, { dkLen: byteLength });
 }
-
 /**
  * @name blake2AsHex
  * @description Creates a blake2b hex from the input.

package/{src/blake2/index.ts → blake2/index.d.ts}

@@ -1,8 +1,4 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Create blake2b values with specified bitlengths
  */
-
 export { blake2AsHex, blake2AsU8a } from './asU8a.js';

package/blake2/index.js

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

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

@@ -1,15 +1,8 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export const BN_BE_OPTS = { isLe: false };
 export const BN_LE_OPTS = { isLe: true };
-
 export const BN_LE_16_OPTS = { bitLength: 16, isLe: true };
-
 export const BN_BE_32_OPTS = { bitLength: 32, isLe: false };
 export const BN_LE_32_OPTS = { bitLength: 32, isLe: true };
-
 export const BN_BE_256_OPTS = { bitLength: 256, isLe: false };
 export const BN_LE_256_OPTS = { bitLength: 256, isLe: true };
-
 export const BN_LE_512_OPTS = { bitLength: 512, isLe: true };

package/bridge.d.ts

@@ -0,0 +1,82 @@
+import type { BridgeBase, InitFn, WasmBaseInstance } from './types.js';
+/**
+ * @name Bridge
+ * @description
+ * Creates a bridge between the JS and WASM environments.
+ *
+ * For any bridge it is passed an function which is then called internally at the
+ * time of initialization. This affectively implements the layer between WASM and
+ * the native environment, providing all the plumbing needed for the Wbg classes.
+ */
+export declare class Bridge<C extends WasmBaseInstance> implements BridgeBase<C> {
+    #private;
+    constructor(createWasm: InitFn<C>);
+    /** @description Returns the init error */
+    get error(): string | null;
+    /** @description Returns the init type */
+    get type(): 'asm' | 'wasm' | 'none';
+    /** @description Returns the created wasm interface */
+    get wasm(): C | null;
+    /** @description Performs the wasm initialization */
+    init(createWasm?: InitFn<C>): Promise<C | null>;
+    /**
+     * @internal
+     * @description Gets an object from the heap
+     */
+    getObject(idx: number): unknown;
+    /**
+     * @internal
+     * @description Removes an object from the heap
+     */
+    dropObject(idx: number): void;
+    /**
+     * @internal
+     * @description Retrieves and removes an object to the heap
+     */
+    takeObject(idx: number): unknown;
+    /**
+     * @internal
+     * @description Adds an object to the heap
+     */
+    addObject(obj: unknown): number;
+    /**
+     * @internal
+     * @description Retrieve an Int32 in the WASM interface
+     */
+    getInt32(): Int32Array;
+    /**
+     * @internal
+     * @description Retrieve an Uint8Array in the WASM interface
+     */
+    getUint8(): Uint8Array;
+    /**
+     * @internal
+     * @description Retrieves an Uint8Array in the WASM interface
+     */
+    getU8a(ptr: number, len: number): Uint8Array;
+    /**
+     * @internal
+     * @description Retrieves a string in the WASM interface
+     */
+    getString(ptr: number, len: number): string;
+    /**
+     * @internal
+     * @description Allocates an Uint8Array in the WASM interface
+     */
+    allocU8a(arg: Uint8Array): [number, number];
+    /**
+     * @internal
+     * @description Allocates a string in the WASM interface
+     */
+    allocString(arg: string): [number, number];
+    /**
+     * @internal
+     * @description Retrieves an Uint8Array from the WASM interface
+     */
+    resultU8a(): Uint8Array;
+    /**
+     * @internal
+     * @description Retrieve a string from the WASM interface
+     */
+    resultString(): string;
+}