@pezkuwi/util-crypto 14.0.5 → 14.0.6

package/README.md

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

package/build/README.md

@@ -0,0 +1,17 @@
+# @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 '@pezkuwi/util-crypto';
+```

package/build/address/addressToEvm.js

@@ -0,0 +1,8 @@
+import { decodeAddress } from './decode.js';
+/**
+ * @name addressToEvm
+ * @summary Converts an SS58 address to its corresponding EVM address.
+ */
+export function addressToEvm(address, ignoreChecksum) {
+    return decodeAddress(address, ignoreChecksum).subarray(0, 20);
+}

package/build/address/check.js

@@ -0,0 +1,26 @@
+import { base58Decode } from '../base58/index.js';
+import { checkAddressChecksum } from './checksum.js';
+import { defaults } from './defaults.js';
+/**
+ * @name checkAddress
+ * @summary Validates an ss58 address.
+ * @description
+ * From the provided input, validate that the address is a valid input.
+ */
+export function checkAddress(address, prefix) {
+    let decoded;
+    try {
+        decoded = base58Decode(address);
+    }
+    catch (error) {
+        return [false, 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/address/checksum.js

@@ -0,0 +1,16 @@
+import { sshash } from './sshash.js';
+export function checkAddressChecksum(decoded) {
+    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];
+}

package/build/address/decode.js

@@ -0,0 +1,29 @@
+import { isHex, isU8a, u8aToU8a } from '@pezkuwi/util';
+import { base58Decode } from '../base58/index.js';
+import { checkAddressChecksum } from './checksum.js';
+import { defaults } from './defaults.js';
+export function decodeAddress(encoded, ignoreChecksum, ss58Format = -1) {
+    if (!encoded) {
+        throw new Error('Invalid empty address passed');
+    }
+    if (isU8a(encoded) || isHex(encoded)) {
+        return u8aToU8a(encoded);
+    }
+    try {
+        const decoded = base58Decode(encoded);
+        if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
+            throw new Error('Invalid decoded address length');
+        }
+        const [isValid, endPos, ss58Length, ss58Decoded] = checkAddressChecksum(decoded);
+        if (!isValid && !ignoreChecksum) {
+            throw new Error('Invalid decoded address checksum');
+        }
+        else if (ss58Format !== -1 && ss58Format !== ss58Decoded) {
+            throw new Error(`Expected ss58Format ${ss58Format}, received ${ss58Decoded}`);
+        }
+        return decoded.slice(ss58Length, endPos);
+    }
+    catch (error) {
+        throw new Error(`Decoding ${encoded}: ${error.message}`);
+    }
+}

package/build/address/defaults.js

@@ -0,0 +1,8 @@
+import { availableNetworks } from '../networks.js';
+export const defaults = {
+    allowedDecodedLengths: [1, 2, 4, 8, 32, 33],
+    // publicKey has prefix + 2 checksum bytes, short only prefix + 1 checksum byte
+    allowedEncodedLengths: [3, 4, 6, 10, 35, 36, 37, 38],
+    allowedPrefix: availableNetworks.map(({ prefix }) => prefix),
+    prefix: 42
+};

package/build/address/derive.js

@@ -0,0 +1,24 @@
+import { keyExtractPath } from '../key/index.js';
+import { sr25519DerivePublic } from '../sr25519/index.js';
+import { decodeAddress } from './decode.js';
+import { encodeAddress } from './encode.js';
+function filterHard({ isHard }) {
+    return isHard;
+}
+/**
+ * @name deriveAddress
+ * @summary Creates a sr25519 derived address from the supplied and path.
+ * @description
+ * Creates a sr25519 derived address based on the input address/publicKey and the uri supplied.
+ */
+export function deriveAddress(who, suri, ss58Format) {
+    const { path } = keyExtractPath(suri);
+    if (!path.length || path.every(filterHard)) {
+        throw new Error('Expected suri to contain a combination of non-hard paths');
+    }
+    let publicKey = decodeAddress(who);
+    for (const { chainCode } of path) {
+        publicKey = sr25519DerivePublic(publicKey, chainCode);
+    }
+    return encodeAddress(publicKey, ss58Format);
+}

package/build/address/encode.js

@@ -0,0 +1,23 @@
+import { u8aConcat } from '@pezkuwi/util';
+import { base58Encode } from '../base58/index.js';
+import { decodeAddress } from './decode.js';
+import { defaults } from './defaults.js';
+import { sshash } from './sshash.js';
+export function encodeAddress(key, ss58Format = defaults.prefix) {
+    // decode it, this means we can re-encode an address
+    const u8a = decodeAddress(key);
+    if ((ss58Format < 0) || (ss58Format > 16383 && !ss58Exceptions.includes(ss58Format)) || [46, 47].includes(ss58Format)) {
+        throw new Error('Out of range ss58Format specified');
+    }
+    else if (!defaults.allowedDecodedLengths.includes(u8a.length)) {
+        throw new Error(`Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
+    }
+    const input = u8aConcat(ss58Format < 64
+        ? [ss58Format]
+        : [
+            ((ss58Format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,
+            (ss58Format >> 8) | ((ss58Format & 0b0000_0000_0000_0011) << 6)
+        ], u8a);
+    return base58Encode(u8aConcat(input, sshash(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1)));
+}
+const ss58Exceptions = [29972];

package/build/address/encodeDerived.d.ts

@@ -0,0 +1,9 @@
+import type { BN } from '@pezkuwi/util';
+import type { Prefix } from './types.js';
+/**
+ * @name encodeDerivedAddress
+ * @summary Creates a derived address as used in Substrate utility.
+ * @description
+ * Creates a Substrate derived address based on the input address/publicKey and the index supplied.
+ */
+export declare function encodeDerivedAddress(who: string | Uint8Array, index: bigint | BN | number, ss58Format?: Prefix): string;

package/build/address/encodeDerived.js

@@ -0,0 +1,12 @@
+import { decodeAddress } from './decode.js';
+import { encodeAddress } from './encode.js';
+import { createKeyDerived } from './keyDerived.js';
+/**
+ * @name encodeDerivedAddress
+ * @summary Creates a derived address as used in Substrate utility.
+ * @description
+ * Creates a Substrate derived address based on the input address/publicKey and the index supplied.
+ */
+export function encodeDerivedAddress(who, index, ss58Format) {
+    return encodeAddress(createKeyDerived(decodeAddress(who), index), ss58Format);
+}

package/build/address/encodeMulti.d.ts

@@ -0,0 +1,9 @@
+import type { BN } from '@pezkuwi/util';
+import type { Prefix } from './types.js';
+/**
+ * @name encodeMultiAddress
+ * @summary Creates a multisig address.
+ * @description
+ * Creates a Substrate multisig address based on the input address and the required threshold.
+ */
+export declare function encodeMultiAddress(who: (string | Uint8Array)[], threshold: bigint | BN | number, ss58Format?: Prefix): string;

package/build/address/encodeMulti.js

@@ -0,0 +1,11 @@
+import { encodeAddress } from './encode.js';
+import { createKeyMulti } from './keyMulti.js';
+/**
+ * @name encodeMultiAddress
+ * @summary Creates a multisig address.
+ * @description
+ * Creates a Substrate multisig address based on the input address and the required threshold.
+ */
+export function encodeMultiAddress(who, threshold, ss58Format) {
+    return encodeAddress(createKeyMulti(who, threshold), ss58Format);
+}

package/build/address/eq.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name addressEq
+ * @summary Compares two addresses, either in ss58, Uint8Array or hex format.
+ * @description
+ * For the input values, return true is the underlying public keys do match.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aEq } from '@pezkuwi/util';
+ *
+ * u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true
+ * ```
+ */
+export declare function addressEq(a: string | Uint8Array, b: string | Uint8Array): boolean;

package/build/address/eq.js

@@ -0,0 +1,19 @@
+import { u8aEq } from '@pezkuwi/util';
+import { decodeAddress } from './decode.js';
+/**
+ * @name addressEq
+ * @summary Compares two addresses, either in ss58, Uint8Array or hex format.
+ * @description
+ * For the input values, return true is the underlying public keys do match.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aEq } from '@pezkuwi/util';
+ *
+ * u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true
+ * ```
+ */
+export function addressEq(a, b) {
+    return u8aEq(decodeAddress(a), decodeAddress(b));
+}

package/build/address/evmToAddress.js

@@ -0,0 +1,14 @@
+import { u8aConcat } from '@pezkuwi/util';
+import { hasher } from '../secp256k1/hasher.js';
+import { encodeAddress } from './encode.js';
+/**
+ * @name evmToAddress
+ * @summary Converts an EVM address to its corresponding SS58 address.
+ */
+export function evmToAddress(evmAddress, ss58Format, hashType = 'blake2') {
+    const message = u8aConcat('evm:', evmAddress);
+    if (message.length !== 24) {
+        throw new Error(`Converting ${evmAddress}: Invalid evm address length`);
+    }
+    return encodeAddress(hasher(hashType, message), ss58Format);
+}

package/build/address/index.js

@@ -0,0 +1,16 @@
+export { addressToEvm } from './addressToEvm.js';
+export { checkAddress } from './check.js';
+export { checkAddressChecksum } from './checksum.js';
+export { decodeAddress } from './decode.js';
+export { deriveAddress } from './derive.js';
+export { encodeAddress } from './encode.js';
+export { encodeDerivedAddress } from './encodeDerived.js';
+export { encodeMultiAddress } from './encodeMulti.js';
+export { addressEq } from './eq.js';
+export { evmToAddress } from './evmToAddress.js';
+export { isAddress } from './is.js';
+export { createKeyDerived } from './keyDerived.js';
+export { createKeyMulti } from './keyMulti.js';
+export { sortAddresses } from './sort.js';
+export { validateAddress } from './validate.js';
+export { setSS58Format } from './setSS58Format.js';

package/build/address/is.js

@@ -0,0 +1,9 @@
+import { validateAddress } from './validate.js';
+export function isAddress(address, ignoreChecksum, ss58Format) {
+    try {
+        return validateAddress(address, ignoreChecksum, ss58Format);
+    }
+    catch {
+        return false;
+    }
+}

package/build/address/keyDerived.d.ts

@@ -0,0 +1,2 @@
+import type { BN } from '@pezkuwi/util';
+export declare function createKeyDerived(who: string | Uint8Array, index: bigint | BN | number): Uint8Array;

package/build/address/keyDerived.js

@@ -0,0 +1,8 @@
+import { bnToU8a, stringToU8a, u8aConcat } from '@pezkuwi/util';
+import { blake2AsU8a } from '../blake2/asU8a.js';
+import { BN_LE_16_OPTS } from '../bn.js';
+import { decodeAddress } from './decode.js';
+const PREFIX = stringToU8a('modlpy/utilisuba');
+export function createKeyDerived(who, index) {
+    return blake2AsU8a(u8aConcat(PREFIX, decodeAddress(who), bnToU8a(index, BN_LE_16_OPTS)));
+}

package/build/address/keyMulti.d.ts

@@ -0,0 +1,2 @@
+import type { BN } from '@pezkuwi/util';
+export declare function createKeyMulti(who: (string | Uint8Array)[], threshold: bigint | BN | number): Uint8Array;

package/build/address/keyMulti.js

@@ -0,0 +1,8 @@
+import { bnToU8a, compactToU8a, stringToU8a, u8aConcat, u8aSorted } from '@pezkuwi/util';
+import { blake2AsU8a } from '../blake2/asU8a.js';
+import { BN_LE_16_OPTS } from '../bn.js';
+import { addressToU8a } from './util.js';
+const PREFIX = stringToU8a('modlpy/utilisuba');
+export function createKeyMulti(who, threshold) {
+    return blake2AsU8a(u8aConcat(PREFIX, compactToU8a(who.length), ...u8aSorted(who.map(addressToU8a)), bnToU8a(threshold, BN_LE_16_OPTS)));
+}

package/build/address/setSS58Format.js

@@ -0,0 +1,11 @@
+import { logger } from '@pezkuwi/util';
+import { defaults } from './defaults.js';
+const l = logger('setSS58Format');
+/**
+ * @description Sets the global SS58 format to use for address encoding
+ * @deprecated Use keyring.setSS58Format
+ */
+export function setSS58Format(prefix) {
+    l.warn('Global setting of the ss58Format is deprecated and not recommended. Set format on the keyring (if used) or as part of the address encode function');
+    defaults.prefix = prefix;
+}

package/build/address/sort.js

@@ -0,0 +1,7 @@
+import { u8aSorted } from '@pezkuwi/util';
+import { encodeAddress } from './encode.js';
+import { addressToU8a } from './util.js';
+export function sortAddresses(addresses, ss58Format) {
+    const u8aToAddress = (u8a) => encodeAddress(u8a, ss58Format);
+    return u8aSorted(addresses.map(addressToU8a)).map(u8aToAddress);
+}

package/build/address/sshash.js

@@ -0,0 +1,6 @@
+import { stringToU8a, u8aConcat } from '@pezkuwi/util';
+import { blake2AsU8a } from '../blake2/asU8a.js';
+const SS58_PREFIX = stringToU8a('SS58PRE');
+export function sshash(key) {
+    return blake2AsU8a(u8aConcat(SS58_PREFIX, key), 512);
+}

package/build/address/util.js

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

package/build/address/validate.js

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

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

package/build/base32/bs32.js

@@ -0,0 +1,40 @@
+import { utils } from '@scure/base';
+import { createDecode, createEncode, createIs, createValidate } from './helpers.js';
+const chars = 'abcdefghijklmnopqrstuvwxyz234567';
+const config = {
+    chars,
+    coder: utils.chain(
+    // We define our own chain, the default base32 has padding
+    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.
+ * @description
+ * 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.
+ * @description
+ * 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.
+* @description
+* From the provided input, create the base32 and return the result as a string.
+*/
+export const base32Encode = /*#__PURE__*/ createEncode(config);

package/build/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/build/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/build/base32/index.js

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

package/build/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/build/base58/bs58.js

@@ -0,0 +1,34 @@
+import { base58 } from '@scure/base';
+import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers.js';
+const config = {
+    chars: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
+    coder: 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
+ */
+export const base58Validate = /*#__PURE__*/ createValidate(config);
+/**
+ * @name base58Decode
+ * @summary Decodes a base58 value.
+ * @description
+ * 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.
+* @description
+* 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
+*/
+export const isBase58 = /*#__PURE__*/ createIs(base58Validate);

package/build/base58/index.js

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

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