@ocap/mcrypto 1.16.16 → 1.16.17

package/lib/crypter/aes.d.ts

@@ -0,0 +1,8 @@
+import Crypter from '../protocols/crypter';
+declare class AesCrypter extends Crypter {
+    encrypt(message: string | object, secret: string): string;
+    decrypt(cipher: string, secret: string, outputEncoding?: string): string;
+}
+declare const _default: AesCrypter;
+export default _default;
+export { AesCrypter };

package/lib/crypter/aes.js

@@ -1,32 +1,55 @@
-/* eslint-disable class-methods-use-this */
-/* eslint-disable no-useless-constructor */
-/* eslint-disable global-require */
-const AES = require('crypto-js/aes');
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AesCrypter = void 0;
+const AES = __importStar(require("crypto-js/aes"));
+const enc_latin1_1 = __importDefault(require("crypto-js/enc-latin1"));
+const enc_utf8_1 = __importDefault(require("crypto-js/enc-utf8"));
+const enc_utf16_1 = __importDefault(require("crypto-js/enc-utf16"));
+const enc_base64_1 = __importDefault(require("crypto-js/enc-base64"));
+const enc_hex_1 = __importDefault(require("crypto-js/enc-hex"));
+const crypter_1 = __importDefault(require("../protocols/crypter"));
 const encoders = {
-  latin1: require('crypto-js/enc-latin1'),
-  utf8: require('crypto-js/enc-utf8'),
-  hex: require('crypto-js/enc-hex'),
-  utf16: require('crypto-js/enc-utf16'),
-  base64: require('crypto-js/enc-base64'),
+    latin1: enc_latin1_1.default,
+    utf8: enc_utf8_1.default,
+    hex: enc_hex_1.default,
+    utf16: enc_utf16_1.default,
+    base64: enc_base64_1.default,
 };
-
-const Crypter = require('../protocols/crypter');
-
 // AES-CBC-256
-class AesCrypter extends Crypter {
-  constructor() {
-    super();
-  }
-
-  encrypt(message, secret) {
-    const text = typeof message === 'string' ? message : JSON.stringify(message);
-    return AES.encrypt(text, secret).toString();
-  }
-
-  decrypt(cipher, secret, outputEncoding = 'utf8') {
-    return AES.decrypt(cipher, secret).toString(encoders[outputEncoding]);
-  }
+class AesCrypter extends crypter_1.default {
+    encrypt(message, secret) {
+        const text = typeof message === 'string' ? message : JSON.stringify(message);
+        return AES.encrypt(text, secret).toString();
+    }
+    decrypt(cipher, secret, outputEncoding = 'utf8') {
+        return AES.decrypt(cipher, secret).toString(encoders[outputEncoding]);
+    }
 }
-
-module.exports = new AesCrypter();
+exports.AesCrypter = AesCrypter;
+exports.default = new AesCrypter();

package/lib/encode.d.ts

@@ -1,2 +1,2 @@
-declare function _exports(data: any, encoding?: string): any;
-export = _exports;
+import { BytesType, EncodingType } from '@ocap/util';
+export default function encode(data: BytesType, encoding?: EncodingType): BytesType;

package/lib/encode.js

@@ -1,25 +1,22 @@
-const { toHex, toUint8Array, toBase58, toBase64, toBuffer } = require('@ocap/util');
-
-module.exports = function encode(data, encoding = 'hex') {
-  if (['hex', 'base16'].includes(encoding)) {
-    return toHex(data);
-  }
-
-  if (encoding === 'base58') {
-    return toBase58(data);
-  }
-
-  if (encoding === 'base64') {
-    return toBase64(data);
-  }
-
-  if (encoding === 'Uint8Array') {
-    return toUint8Array(data);
-  }
-
-  if (encoding === 'buffer') {
-    return toBuffer(data);
-  }
-
-  return data;
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("@ocap/util");
+function encode(data, encoding = 'hex') {
+    if (['hex', 'base16'].includes(encoding)) {
+        return (0, util_1.toHex)(data);
+    }
+    if (encoding === 'base58') {
+        return (0, util_1.toBase58)(data);
+    }
+    if (encoding === 'base64') {
+        return (0, util_1.toBase64)(data);
+    }
+    if (encoding === 'Uint8Array') {
+        return (0, util_1.toUint8Array)(data);
+    }
+    if (encoding === 'buffer') {
+        return (0, util_1.toBuffer)(data);
+    }
+    return data;
+}
+exports.default = encode;

package/lib/hasher/keccak.d.ts

@@ -0,0 +1,13 @@
+import { BytesType, EncodingType } from '@ocap/util';
+/**
+ * Keccak support with different hash length
+ *
+ * @class KeccakHasher
+ */
+declare class KeccakHasher {
+    [x: string]: (data: BytesType, round?: number, encoding?: EncodingType) => BytesType;
+    constructor();
+}
+declare const _default: KeccakHasher;
+export default _default;
+export { KeccakHasher };

package/lib/hasher/keccak.js

@@ -1,85 +1,43 @@
-const sha3 = require('js-sha3');
-const { toUint8Array } = require('@ocap/util');
-const encode = require('../encode');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeccakHasher = void 0;
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const js_sha3_1 = __importDefault(require("js-sha3"));
+const util_1 = require("@ocap/util");
+const encode_1 = __importDefault(require("../encode"));
 /**
  * Keccak support with different hash length
  *
  * @class KeccakHasher
  */
 class KeccakHasher {
-  constructor() {
-    [224, 256, 384, 512].forEach((x) => {
-      const name = `hash${x}`;
-      const hasher = (data) => sha3[`keccak${x}`](data);
-      const hashFn = (input, round) => {
-        if (round === 1) {
-          return hasher(input);
-        }
-
-        return hashFn(hasher(input), round - 1);
-      };
-
-      this[name] = (data, round = 1, encoding = 'hex') => {
-        let input = data;
-        try {
-          input = toUint8Array(data);
-        } catch (err) {
-          // Do nothing
-        }
-        const res = hashFn(input, round);
-        return encode(`0x${res}`, encoding);
-      };
-    });
-  }
+    constructor() {
+        [224, 256, 384, 512].forEach((x) => {
+            const name = `hash${x}`;
+            // @ts-ignore
+            const hasher = (data) => js_sha3_1.default[`keccak${x}`](data);
+            const hashFn = (input, round) => {
+                if (round === 1) {
+                    return hasher(input);
+                }
+                return hashFn(hasher(input), round - 1);
+            };
+            this[name] = (data, round = 1, encoding = 'hex') => {
+                let input = data;
+                try {
+                    input = (0, util_1.toUint8Array)(data);
+                }
+                catch (err) {
+                    // Do nothing
+                }
+                const res = hashFn(input, round);
+                return (0, encode_1.default)(`0x${res}`, encoding);
+            };
+        });
+    }
 }
-
-/**
- * Do hash with length of 224
- *
- * @function
- * @name KeccakHasher#hash224
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=1] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof KeccakHasher
- */
-
-/**
- * Do hash with length of 256
- *
- * @function
- * @name KeccakHasher#hash256
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=1] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof KeccakHasher
- */
-
-/**
- * Do hash with length of 384
- *
- * @function
- * @name KeccakHasher#hash384
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=1] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof KeccakHasher
- */
-
-/**
- * Do hash with length of 512
- *
- * @function
- * @name KeccakHasher#hash512
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=1] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof KeccakHasher
- */
-
-module.exports = new KeccakHasher();
+exports.KeccakHasher = KeccakHasher;
+exports.default = new KeccakHasher();

package/lib/hasher/sha2.d.ts

@@ -0,0 +1,13 @@
+import { BytesType, EncodingType } from '@ocap/util';
+/**
+ * Sha2 support with different hash length
+ *
+ * @class
+ */
+declare class Sha2Hasher {
+    [x: string]: (data: BytesType, round?: number, encoding?: EncodingType) => BytesType;
+    constructor();
+}
+declare const _default: Sha2Hasher;
+export default _default;
+export { Sha2Hasher };

package/lib/hasher/sha2.js

@@ -1,91 +1,49 @@
-/* eslint-disable global-require */
-const { toUint8Array } = require('@ocap/util');
-const encode = require('../encode');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sha2Hasher = void 0;
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const util_1 = require("@ocap/util");
+const hash_js_1 = require("hash.js");
+const encode_1 = __importDefault(require("../encode"));
 const hashFns = {
-  sha224: require('hash.js/lib/hash/sha/224'),
-  sha256: require('hash.js/lib/hash/sha/256'),
-  sha384: require('hash.js/lib/hash/sha/384'),
-  sha512: require('hash.js/lib/hash/sha/512'),
+    sha224: hash_js_1.sha224,
+    sha256: hash_js_1.sha256,
+    sha384: hash_js_1.sha384,
+    sha512: hash_js_1.sha512,
 };
-
 /**
  * Sha2 support with different hash length
  *
  * @class
  */
 class Sha2Hasher {
-  constructor() {
-    [224, 256, 384, 512].forEach((x) => {
-      const name = `hash${x}`;
-      const hasher = hashFns[`sha${x}`];
-      const hashFn = (input, round) => {
-        let inputBytes = input;
-        try {
-          inputBytes = toUint8Array(input);
-        } catch (err) {
-          // Do nothing
-        }
-        if (round === 1) {
-          return `0x${hasher().update(inputBytes).digest('hex')}`;
-        }
-
-        return hashFn(hashFn(inputBytes, 1), round - 1);
-      };
-
-      this[name] = (data, round = 2, encoding = 'hex') => {
-        const res = hashFn(data, round);
-        return encode(res, encoding);
-      };
-    });
-  }
+    constructor() {
+        [224, 256, 384, 512].forEach((x) => {
+            const name = `hash${x}`;
+            // @ts-ignore
+            const hasher = hashFns[`sha${x}`];
+            const hashFn = (input, round) => {
+                let inputBytes = input;
+                try {
+                    inputBytes = (0, util_1.toUint8Array)(input);
+                }
+                catch (err) {
+                    // Do nothing
+                }
+                if (round === 1) {
+                    return `0x${hasher().update(inputBytes).digest('hex')}`;
+                }
+                return hashFn(hashFn(inputBytes, 1), round - 1);
+            };
+            this[name] = (data, round = 2, encoding = 'hex') => {
+                const res = hashFn(data, round);
+                return (0, encode_1.default)(res, encoding);
+            };
+        });
+    }
 }
-
-/**
- * Do hash with length of 224
- *
- * @function
- * @name Sha2Hasher#hash224
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=2] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof Sha2Hasher
- */
-
-/**
- * Do hash with length of 256
- *
- * @function
- * @name Sha2Hasher#hash256
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=2] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof Sha2Hasher
- */
-
-/**
- * Do hash with length of 384
- *
- * @function
- * @name Sha2Hasher#hash384
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=2] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof Sha2Hasher
- */
-
-/**
- * Do hash with length of 512
- *
- * @function
- * @name Sha2Hasher#hash512
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=2] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof Sha2Hasher
- */
-module.exports = new Sha2Hasher();
+exports.Sha2Hasher = Sha2Hasher;
+exports.default = new Sha2Hasher();

package/lib/hasher/sha3.d.ts

@@ -0,0 +1,13 @@
+import { BytesType, EncodingType } from '@ocap/util';
+/**
+ * Sha3 support with different hash length
+ *
+ * @class Sha3Hasher
+ */
+declare class Sha3Hasher {
+    [x: string]: (data: BytesType, round?: number, encoding?: EncodingType) => BytesType;
+    constructor();
+}
+declare const _default: Sha3Hasher;
+export default _default;
+export { Sha3Hasher };

package/lib/hasher/sha3.js

@@ -1,85 +1,43 @@
-const sha3 = require('js-sha3');
-const { toUint8Array } = require('@ocap/util');
-const encode = require('../encode');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sha3Hasher = void 0;
+const js_sha3_1 = __importDefault(require("js-sha3"));
+const util_1 = require("@ocap/util");
+const encode_1 = __importDefault(require("../encode"));
 /**
  * Sha3 support with different hash length
  *
  * @class Sha3Hasher
  */
 class Sha3Hasher {
-  constructor() {
-    [224, 256, 384, 512].forEach((x) => {
-      const name = `hash${x}`;
-      const hasher = sha3[`sha3_${x}`];
-      const hashFn = (input, round) => {
-        if (round === 1) {
-          return hasher(input);
-        }
-
-        return hashFn(hasher(input), round - 1);
-      };
-
-      this[name] = (data, round = 1, encoding = 'hex') => {
-        let input = data;
-        try {
-          input = toUint8Array(data);
-        } catch (err) {
-          // Do nothing
-        }
-        const res = hashFn(input, round);
-        return encode(`0x${res}`, encoding);
-      };
-    });
-  }
+    constructor() {
+        [224, 256, 384, 512].forEach((x) => {
+            const name = `hash${x}`;
+            /* eslint-disable @typescript-eslint/ban-ts-comment */
+            // @ts-ignore
+            const hasher = js_sha3_1.default[`sha3_${x}`];
+            const hashFn = (input, round) => {
+                if (round === 1) {
+                    return hasher(input);
+                }
+                return hashFn(hasher(input), round - 1);
+            };
+            this[name] = (data, round = 1, encoding = 'hex') => {
+                let input = data;
+                try {
+                    input = (0, util_1.toUint8Array)(data);
+                }
+                catch (err) {
+                    // Do nothing
+                }
+                const res = hashFn(input, round);
+                return (0, encode_1.default)(`0x${res}`, encoding);
+            };
+        });
+    }
 }
-
-/**
- * Do hash with length of 224
- *
- * @function
- * @name Sha3Hasher#hash224
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=1] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof Sha3Hasher
- */
-
-/**
- * Do hash with length of 256
- *
- * @function
- * @name Sha3Hasher#hash256
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=1] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof Sha3Hasher
- */
-
-/**
- * Do hash with length of 384
- *
- * @function
- * @name Sha3Hasher#hash384
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=1] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof Sha3Hasher
- */
-
-/**
- * Do hash with length of 512
- *
- * @function
- * @name Sha3Hasher#hash512
- * @param {hex|buffer|base58|Uint8Array|string} input - data to hash
- * @param {number} [round=1] - how many round to do the hash, larger = safer = slower
- * @param {string} [encoding="hex"] - output encoding
- * @returns {string} depends on encoding param, hex by default
- * @memberof Sha3Hasher
- */
-
-module.exports = new Sha3Hasher();
+exports.Sha3Hasher = Sha3Hasher;
+exports.default = new Sha3Hasher();