@pezkuwi/util-crypto 14.0.21 → 14.0.23

package/build-tsc/secp256k1/types.d.ts

@@ -0,0 +1 @@
+export type HashType = 'blake2' | 'keccak';

package/build-tsc/secp256k1/verify.d.ts

@@ -0,0 +1,6 @@
+import type { HashType } from './types.js';
+/**
+ * @name secp256k1Verify
+ * @description Verifies the signature of `message`, using the supplied pair
+ */
+export declare function secp256k1Verify(msgHash: string | Uint8Array, signature: string | Uint8Array, address: string | Uint8Array, hashType?: HashType, onlyJs?: boolean): boolean;

package/build-tsc/sha/asU8a.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name shaAsU8a
+ * @summary Creates a sha Uint8Array from the input.
+ */
+export declare const shaAsU8a: (value: string | Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name sha256AsU8a
+ * @summary Creates a sha256 Uint8Array from the input.
+ */
+export declare const sha256AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name sha512AsU8a
+ * @summary Creates a sha512 Uint8Array from the input.
+ */
+export declare const sha512AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;

package/build-tsc/sha/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @summary Implements Sha-256/512 hashing functions for a variety of input and outputs
+ */
+export { sha256AsU8a, sha512AsU8a, shaAsU8a } from './asU8a.js';

package/build-tsc/signature/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @summary Utilities for working with signatures
+ */
+export { signatureVerify } from './verify.js';

package/build-tsc/signature/verify.d.ts

@@ -0,0 +1,2 @@
+import type { VerifyResult } from '../types.js';
+export declare function signatureVerify(message: string | Uint8Array, signature: string | Uint8Array, addressOrPublicKey: string | Uint8Array): VerifyResult;

package/build-tsc/sr25519/agreement.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @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-tsc/sr25519/derive.d.ts

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

package/build-tsc/sr25519/deriveHard.d.ts

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

package/build-tsc/sr25519/derivePublic.d.ts

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

package/build-tsc/sr25519/deriveSoft.d.ts

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

package/build-tsc/sr25519/index.d.ts

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

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

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

package/build-tsc/sr25519/pair/toU8a.d.ts

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

package/build-tsc/sr25519/sign.d.ts

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

@@ -0,0 +1,5 @@
+/**
+ * @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-tsc/sr25519/vrfSign.d.ts

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

@@ -0,0 +1,5 @@
+/**
+ * @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-tsc/types.d.ts

@@ -0,0 +1,26 @@
+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-tsc/xxhash/asU8a.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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-tsc/xxhash/index.d.ts

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

package/build-tsc/xxhash/xxhash64.d.ts

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

package/build-tsc-cjs/address/addressToEvm.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressToEvm = addressToEvm;
+const decode_js_1 = require("./decode.js");
+/**
+ * @name addressToEvm
+ * @summary Converts an SS58 address to its corresponding EVM address.
+ */
+function addressToEvm(address, ignoreChecksum) {
+    return (0, decode_js_1.decodeAddress)(address, ignoreChecksum).subarray(0, 20);
+}

package/build-tsc-cjs/address/check.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAddress = checkAddress;
+const index_js_1 = require("../base58/index.js");
+const checksum_js_1 = require("./checksum.js");
+const defaults_js_1 = require("./defaults.js");
+/**
+ * @name checkAddress
+ * @summary Validates an ss58 address.
+ * @description
+ * From the provided input, validate that the address is a valid input.
+ */
+function checkAddress(address, prefix) {
+    let decoded;
+    try {
+        decoded = (0, index_js_1.base58Decode)(address);
+    }
+    catch (error) {
+        return [false, error.message];
+    }
+    const [isValid, , , ss58Decoded] = (0, checksum_js_1.checkAddressChecksum)(decoded);
+    if (ss58Decoded !== prefix) {
+        return [false, `Prefix mismatch, expected ${prefix}, found ${ss58Decoded}`];
+    }
+    else if (!defaults_js_1.defaults.allowedEncodedLengths.includes(decoded.length)) {
+        return [false, 'Invalid decoded address length'];
+    }
+    return [isValid, isValid ? null : 'Invalid decoded address checksum'];
+}

package/build-tsc-cjs/address/checksum.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAddressChecksum = checkAddressChecksum;
+const sshash_js_1 = require("./sshash.js");
+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 = (0, sshash_js_1.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-tsc-cjs/address/decode.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeAddress = decodeAddress;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../base58/index.js");
+const checksum_js_1 = require("./checksum.js");
+const defaults_js_1 = require("./defaults.js");
+function decodeAddress(encoded, ignoreChecksum, ss58Format = -1) {
+    if (!encoded) {
+        throw new Error('Invalid empty address passed');
+    }
+    if ((0, util_1.isU8a)(encoded) || (0, util_1.isHex)(encoded)) {
+        return (0, util_1.u8aToU8a)(encoded);
+    }
+    try {
+        const decoded = (0, index_js_1.base58Decode)(encoded);
+        if (!defaults_js_1.defaults.allowedEncodedLengths.includes(decoded.length)) {
+            throw new Error('Invalid decoded address length');
+        }
+        const [isValid, endPos, ss58Length, ss58Decoded] = (0, checksum_js_1.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-tsc-cjs/address/defaults.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaults = void 0;
+const networks_js_1 = require("../networks.js");
+exports.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: networks_js_1.availableNetworks.map(({ prefix }) => prefix),
+    prefix: 42
+};

package/build-tsc-cjs/address/derive.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveAddress = deriveAddress;
+const index_js_1 = require("../key/index.js");
+const index_js_2 = require("../sr25519/index.js");
+const decode_js_1 = require("./decode.js");
+const encode_js_1 = require("./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.
+ */
+function deriveAddress(who, suri, ss58Format) {
+    const { path } = (0, index_js_1.keyExtractPath)(suri);
+    if (!path.length || path.every(filterHard)) {
+        throw new Error('Expected suri to contain a combination of non-hard paths');
+    }
+    let publicKey = (0, decode_js_1.decodeAddress)(who);
+    for (const { chainCode } of path) {
+        publicKey = (0, index_js_2.sr25519DerivePublic)(publicKey, chainCode);
+    }
+    return (0, encode_js_1.encodeAddress)(publicKey, ss58Format);
+}

package/build-tsc-cjs/address/encode.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeAddress = encodeAddress;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../base58/index.js");
+const decode_js_1 = require("./decode.js");
+const defaults_js_1 = require("./defaults.js");
+const sshash_js_1 = require("./sshash.js");
+function encodeAddress(key, ss58Format = defaults_js_1.defaults.prefix) {
+    // decode it, this means we can re-encode an address
+    const u8a = (0, decode_js_1.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_js_1.defaults.allowedDecodedLengths.includes(u8a.length)) {
+        throw new Error(`Expected a valid key to convert, with length ${defaults_js_1.defaults.allowedDecodedLengths.join(', ')}`);
+    }
+    const input = (0, util_1.u8aConcat)(ss58Format < 64
+        ? [ss58Format]
+        : [
+            ((ss58Format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,
+            (ss58Format >> 8) | ((ss58Format & 0b0000_0000_0000_0011) << 6)
+        ], u8a);
+    return (0, index_js_1.base58Encode)((0, util_1.u8aConcat)(input, (0, sshash_js_1.sshash)(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1)));
+}
+const ss58Exceptions = [29972];

package/build-tsc-cjs/address/encodeDerived.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeDerivedAddress = encodeDerivedAddress;
+const decode_js_1 = require("./decode.js");
+const encode_js_1 = require("./encode.js");
+const keyDerived_js_1 = require("./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.
+ */
+function encodeDerivedAddress(who, index, ss58Format) {
+    return (0, encode_js_1.encodeAddress)((0, keyDerived_js_1.createKeyDerived)((0, decode_js_1.decodeAddress)(who), index), ss58Format);
+}

package/build-tsc-cjs/address/encodeMulti.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeMultiAddress = encodeMultiAddress;
+const encode_js_1 = require("./encode.js");
+const keyMulti_js_1 = require("./keyMulti.js");
+/**
+ * @name encodeMultiAddress
+ * @summary Creates a multisig address.
+ * @description
+ * Creates a Substrate multisig address based on the input address and the required threshold.
+ */
+function encodeMultiAddress(who, threshold, ss58Format) {
+    return (0, encode_js_1.encodeAddress)((0, keyMulti_js_1.createKeyMulti)(who, threshold), ss58Format);
+}

package/build-tsc-cjs/address/eq.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressEq = addressEq;
+const util_1 = require("@pezkuwi/util");
+const decode_js_1 = require("./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
+ * ```
+ */
+function addressEq(a, b) {
+    return (0, util_1.u8aEq)((0, decode_js_1.decodeAddress)(a), (0, decode_js_1.decodeAddress)(b));
+}

package/build-tsc-cjs/address/evmToAddress.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evmToAddress = evmToAddress;
+const util_1 = require("@pezkuwi/util");
+const hasher_js_1 = require("../secp256k1/hasher.js");
+const encode_js_1 = require("./encode.js");
+/**
+ * @name evmToAddress
+ * @summary Converts an EVM address to its corresponding SS58 address.
+ */
+function evmToAddress(evmAddress, ss58Format, hashType = 'blake2') {
+    const message = (0, util_1.u8aConcat)('evm:', evmAddress);
+    if (message.length !== 24) {
+        throw new Error(`Converting ${evmAddress}: Invalid evm address length`);
+    }
+    return (0, encode_js_1.encodeAddress)((0, hasher_js_1.hasher)(hashType, message), ss58Format);
+}

package/build-tsc-cjs/address/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSS58Format = exports.validateAddress = exports.sortAddresses = exports.createKeyMulti = exports.createKeyDerived = exports.isAddress = exports.evmToAddress = exports.addressEq = exports.encodeMultiAddress = exports.encodeDerivedAddress = exports.encodeAddress = exports.deriveAddress = exports.decodeAddress = exports.checkAddressChecksum = exports.checkAddress = exports.addressToEvm = void 0;
+var addressToEvm_js_1 = require("./addressToEvm.js");
+Object.defineProperty(exports, "addressToEvm", { enumerable: true, get: function () { return addressToEvm_js_1.addressToEvm; } });
+var check_js_1 = require("./check.js");
+Object.defineProperty(exports, "checkAddress", { enumerable: true, get: function () { return check_js_1.checkAddress; } });
+var checksum_js_1 = require("./checksum.js");
+Object.defineProperty(exports, "checkAddressChecksum", { enumerable: true, get: function () { return checksum_js_1.checkAddressChecksum; } });
+var decode_js_1 = require("./decode.js");
+Object.defineProperty(exports, "decodeAddress", { enumerable: true, get: function () { return decode_js_1.decodeAddress; } });
+var derive_js_1 = require("./derive.js");
+Object.defineProperty(exports, "deriveAddress", { enumerable: true, get: function () { return derive_js_1.deriveAddress; } });
+var encode_js_1 = require("./encode.js");
+Object.defineProperty(exports, "encodeAddress", { enumerable: true, get: function () { return encode_js_1.encodeAddress; } });
+var encodeDerived_js_1 = require("./encodeDerived.js");
+Object.defineProperty(exports, "encodeDerivedAddress", { enumerable: true, get: function () { return encodeDerived_js_1.encodeDerivedAddress; } });
+var encodeMulti_js_1 = require("./encodeMulti.js");
+Object.defineProperty(exports, "encodeMultiAddress", { enumerable: true, get: function () { return encodeMulti_js_1.encodeMultiAddress; } });
+var eq_js_1 = require("./eq.js");
+Object.defineProperty(exports, "addressEq", { enumerable: true, get: function () { return eq_js_1.addressEq; } });
+var evmToAddress_js_1 = require("./evmToAddress.js");
+Object.defineProperty(exports, "evmToAddress", { enumerable: true, get: function () { return evmToAddress_js_1.evmToAddress; } });
+var is_js_1 = require("./is.js");
+Object.defineProperty(exports, "isAddress", { enumerable: true, get: function () { return is_js_1.isAddress; } });
+var keyDerived_js_1 = require("./keyDerived.js");
+Object.defineProperty(exports, "createKeyDerived", { enumerable: true, get: function () { return keyDerived_js_1.createKeyDerived; } });
+var keyMulti_js_1 = require("./keyMulti.js");
+Object.defineProperty(exports, "createKeyMulti", { enumerable: true, get: function () { return keyMulti_js_1.createKeyMulti; } });
+var sort_js_1 = require("./sort.js");
+Object.defineProperty(exports, "sortAddresses", { enumerable: true, get: function () { return sort_js_1.sortAddresses; } });
+var validate_js_1 = require("./validate.js");
+Object.defineProperty(exports, "validateAddress", { enumerable: true, get: function () { return validate_js_1.validateAddress; } });
+var setSS58Format_js_1 = require("./setSS58Format.js");
+Object.defineProperty(exports, "setSS58Format", { enumerable: true, get: function () { return setSS58Format_js_1.setSS58Format; } });

package/build-tsc-cjs/address/is.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAddress = isAddress;
+const validate_js_1 = require("./validate.js");
+function isAddress(address, ignoreChecksum, ss58Format) {
+    try {
+        return (0, validate_js_1.validateAddress)(address, ignoreChecksum, ss58Format);
+    }
+    catch {
+        return false;
+    }
+}

package/build-tsc-cjs/address/keyDerived.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeyDerived = createKeyDerived;
+const util_1 = require("@pezkuwi/util");
+const asU8a_js_1 = require("../blake2/asU8a.js");
+const bn_js_1 = require("../bn.js");
+const decode_js_1 = require("./decode.js");
+const PREFIX = (0, util_1.stringToU8a)('modlpy/utilisuba');
+function createKeyDerived(who, index) {
+    return (0, asU8a_js_1.blake2AsU8a)((0, util_1.u8aConcat)(PREFIX, (0, decode_js_1.decodeAddress)(who), (0, util_1.bnToU8a)(index, bn_js_1.BN_LE_16_OPTS)));
+}

package/build-tsc-cjs/address/keyMulti.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeyMulti = createKeyMulti;
+const util_1 = require("@pezkuwi/util");
+const asU8a_js_1 = require("../blake2/asU8a.js");
+const bn_js_1 = require("../bn.js");
+const util_js_1 = require("./util.js");
+const PREFIX = (0, util_1.stringToU8a)('modlpy/utilisuba');
+function createKeyMulti(who, threshold) {
+    return (0, asU8a_js_1.blake2AsU8a)((0, util_1.u8aConcat)(PREFIX, (0, util_1.compactToU8a)(who.length), ...(0, util_1.u8aSorted)(who.map(util_js_1.addressToU8a)), (0, util_1.bnToU8a)(threshold, bn_js_1.BN_LE_16_OPTS)));
+}

package/build-tsc-cjs/address/setSS58Format.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSS58Format = setSS58Format;
+const util_1 = require("@pezkuwi/util");
+const defaults_js_1 = require("./defaults.js");
+const l = (0, util_1.logger)('setSS58Format');
+/**
+ * @description Sets the global SS58 format to use for address encoding
+ * @deprecated Use keyring.setSS58Format
+ */
+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_js_1.defaults.prefix = prefix;
+}

package/build-tsc-cjs/address/sort.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortAddresses = sortAddresses;
+const util_1 = require("@pezkuwi/util");
+const encode_js_1 = require("./encode.js");
+const util_js_1 = require("./util.js");
+function sortAddresses(addresses, ss58Format) {
+    const u8aToAddress = (u8a) => (0, encode_js_1.encodeAddress)(u8a, ss58Format);
+    return (0, util_1.u8aSorted)(addresses.map(util_js_1.addressToU8a)).map(u8aToAddress);
+}

package/build-tsc-cjs/address/sshash.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sshash = sshash;
+const util_1 = require("@pezkuwi/util");
+const asU8a_js_1 = require("../blake2/asU8a.js");
+const SS58_PREFIX = (0, util_1.stringToU8a)('SS58PRE');
+function sshash(key) {
+    return (0, asU8a_js_1.blake2AsU8a)((0, util_1.u8aConcat)(SS58_PREFIX, key), 512);
+}

package/build-tsc-cjs/address/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build-tsc-cjs/address/util.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressToU8a = addressToU8a;
+const decode_js_1 = require("./decode.js");
+function addressToU8a(who) {
+    return (0, decode_js_1.decodeAddress)(who);
+}

package/build-tsc-cjs/address/validate.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAddress = validateAddress;
+const decode_js_1 = require("./decode.js");
+function validateAddress(encoded, ignoreChecksum, ss58Format) {
+    return !!(0, decode_js_1.decodeAddress)(encoded, ignoreChecksum, ss58Format);
+}

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