@pezkuwi/util-crypto 14.0.22 → 14.0.23

package/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-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/build-tsc-cjs/ed25519/pair/fromRandom.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519PairFromRandom = ed25519PairFromRandom;
+const index_js_1 = require("../../random/index.js");
+const fromSeed_js_1 = require("./fromSeed.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: [...] }
+ * ```
+ */
+function ed25519PairFromRandom() {
+    return (0, fromSeed_js_1.ed25519PairFromSeed)((0, index_js_1.randomAsU8a)());
+}

package/build-tsc-cjs/ed25519/pair/fromSecret.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519PairFromSecret = ed25519PairFromSecret;
+/**
+ * @name ed25519PairFromSecret
+ * @summary Creates a new public/secret keypair from a secret.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied secret.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromSecret } from '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+function ed25519PairFromSecret(secretKey) {
+    if (secretKey.length !== 64) {
+        throw new Error('Invalid secretKey provided');
+    }
+    return {
+        publicKey: secretKey.slice(32),
+        secretKey
+    };
+}

package/build-tsc-cjs/ed25519/pair/fromSeed.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519PairFromSeed = ed25519PairFromSeed;
+const ed25519_1 = require("@noble/curves/ed25519");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+/**
+ * @name ed25519PairFromSeed
+ * @summary Creates a new public/secret keypair from a seed.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromSeed } from '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromSeed(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+function ed25519PairFromSeed(seed, onlyJs) {
+    if (!util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())) {
+        const full = (0, wasm_crypto_1.ed25519KeypairFromSeed)(seed);
+        return {
+            publicKey: full.slice(32),
+            secretKey: full.slice(0, 64)
+        };
+    }
+    const publicKey = ed25519_1.ed25519.getPublicKey(seed);
+    return {
+        publicKey,
+        secretKey: (0, util_1.u8aConcatStrict)([seed, publicKey])
+    };
+}

package/build-tsc-cjs/ed25519/pair/fromString.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519PairFromString = ed25519PairFromString;
+const util_1 = require("@pezkuwi/util");
+const asU8a_js_1 = require("../../blake2/asU8a.js");
+const fromSeed_js_1 = require("./fromSeed.js");
+/**
+ * @name ed25519PairFromString
+ * @summary Creates a new public/secret keypair from a string.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied string. The string is hashed and the value used as the input seed.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromString } from '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+function ed25519PairFromString(value) {
+    return (0, fromSeed_js_1.ed25519PairFromSeed)((0, asU8a_js_1.blake2AsU8a)((0, util_1.stringToU8a)(value)));
+}

package/build-tsc-cjs/ed25519/sign.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519Sign = ed25519Sign;
+const ed25519_1 = require("@noble/curves/ed25519");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+/**
+ * @name ed25519Sign
+ * @summary Signs a message using the supplied secretKey
+ * @description
+ * Returns message signature of `message`, using the `secretKey`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519Sign } from '@pezkuwi/util-crypto';
+ *
+ * ed25519Sign([...], [...]); // => [...]
+ * ```
+ */
+function ed25519Sign(message, { publicKey, secretKey }, onlyJs) {
+    if (!secretKey) {
+        throw new Error('Expected a valid secretKey');
+    }
+    else if (!publicKey) {
+        throw new Error('Expected a valid publicKey');
+    }
+    const messageU8a = (0, util_1.u8aToU8a)(message);
+    const privateU8a = secretKey.subarray(0, 32);
+    return !util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())
+        ? (0, wasm_crypto_1.ed25519Sign)(publicKey, privateU8a, messageU8a)
+        : ed25519_1.ed25519.sign(messageU8a, privateU8a);
+}

package/build-tsc-cjs/ed25519/verify.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ed25519Verify = ed25519Verify;
+const ed25519_1 = require("@noble/curves/ed25519");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+/**
+ * @name ed25519Sign
+ * @summary Verifies the signature on the supplied message.
+ * @description
+ * Verifies the `signature` on `message` with the supplied `publicKey`. Returns `true` on sucess, `false` otherwise.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519Verify } from '@pezkuwi/util-crypto';
+ *
+ * ed25519Verify([...], [...], [...]); // => true/false
+ * ```
+ */
+function ed25519Verify(message, signature, publicKey, onlyJs) {
+    const messageU8a = (0, util_1.u8aToU8a)(message);
+    const publicKeyU8a = (0, util_1.u8aToU8a)(publicKey);
+    const signatureU8a = (0, util_1.u8aToU8a)(signature);
+    if (publicKeyU8a.length !== 32) {
+        throw new Error(`Invalid publicKey, received ${publicKeyU8a.length}, expected 32`);
+    }
+    else if (signatureU8a.length !== 64) {
+        throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+    }
+    try {
+        return !util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())
+            ? (0, wasm_crypto_1.ed25519Verify)(signatureU8a, messageU8a, publicKeyU8a)
+            : ed25519_1.ed25519.verify(signatureU8a, messageU8a, publicKeyU8a);
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ethereumEncode = ethereumEncode;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../keccak/index.js");
+const index_js_2 = require("../secp256k1/index.js");
+function getH160(u8a) {
+    if ([33, 65].includes(u8a.length)) {
+        u8a = (0, index_js_1.keccakAsU8a)((0, index_js_2.secp256k1Expand)(u8a));
+    }
+    return u8a.slice(-20);
+}
+function ethereumEncode(addressOrPublic) {
+    if (!addressOrPublic) {
+        return '0x';
+    }
+    const u8aAddress = (0, util_1.u8aToU8a)(addressOrPublic);
+    if (![20, 32, 33, 65].includes(u8aAddress.length)) {
+        throw new Error(`Invalid address or publicKey provided, received ${u8aAddress.length} bytes input`);
+    }
+    const address = (0, util_1.u8aToHex)(getH160(u8aAddress), -1, false);
+    const hash = (0, util_1.u8aToHex)((0, index_js_1.keccakAsU8a)(address), -1, false);
+    let result = '';
+    for (let i = 0; i < 40; i++) {
+        result = `${result}${parseInt(hash[i], 16) > 7 ? address[i].toUpperCase() : address[i]}`;
+    }
+    return `0x${result}`;
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEthereumChecksum = exports.isEthereumAddress = exports.ethereumEncode = void 0;
+var encode_js_1 = require("./encode.js");
+Object.defineProperty(exports, "ethereumEncode", { enumerable: true, get: function () { return encode_js_1.ethereumEncode; } });
+var isAddress_js_1 = require("./isAddress.js");
+Object.defineProperty(exports, "isEthereumAddress", { enumerable: true, get: function () { return isAddress_js_1.isEthereumAddress; } });
+var isChecksum_js_1 = require("./isChecksum.js");
+Object.defineProperty(exports, "isEthereumChecksum", { enumerable: true, get: function () { return isChecksum_js_1.isEthereumChecksum; } });

package/build-tsc-cjs/ethereum/isAddress.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEthereumAddress = isEthereumAddress;
+const util_1 = require("@pezkuwi/util");
+const isChecksum_js_1 = require("./isChecksum.js");
+function isEthereumAddress(address) {
+    if (!address || address.length !== 42 || !(0, util_1.isHex)(address)) {
+        return false;
+    }
+    else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
+        return true;
+    }
+    return (0, isChecksum_js_1.isEthereumChecksum)(address);
+}

package/build-tsc-cjs/ethereum/isChecksum.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEthereumChecksum = isEthereumChecksum;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../keccak/index.js");
+function isInvalidChar(char, byte) {
+    return char !== (byte > 7
+        ? char.toUpperCase()
+        : char.toLowerCase());
+}
+function isEthereumChecksum(_address) {
+    const address = _address.replace('0x', '');
+    const hash = (0, util_1.u8aToHex)((0, index_js_1.keccakAsU8a)(address.toLowerCase()), -1, false);
+    for (let i = 0; i < 40; i++) {
+        if (isInvalidChar(address[i], parseInt(hash[i], 16))) {
+            return false;
+        }
+    }
+    return true;
+}