@ocap/mcrypto 1.27.16 → 1.28.1

package/esm/index.js

@@ -1,220 +1,183 @@
-import randomBytes from 'randombytes';
-import { encode } from './encode';
-import keccak from './hasher/keccak';
-import sha2 from './hasher/sha2';
-import sha3 from './hasher/sha3';
-import ed25519 from './signer/ed25519';
-import ethereum from './signer/ethereum';
-import secp256k1 from './signer/secp256k1';
-import passkey from './signer/passkey';
+import { encode } from "./encode.js";
+import keccak_default from "./hasher/keccak.js";
+import sha2_default from "./hasher/sha2.js";
+import sha3_default from "./hasher/sha3.js";
+import ed25519_default from "./signer/ed25519.js";
+import secp256k1_default from "./signer/secp256k1.js";
+import ethereum_default from "./signer/ethereum.js";
+import passkey_default from "./signer/passkey.js";
+import randomBytes from "randombytes";
+
+//#region src/index.ts
 /**
- * Contains all supported signers, eg: `Ed25519` and `Secp256k1`
- *
- * @readonly
- * @type {object}
- * @name Signer
- * @static
- * @example
- * const { Signer } = require('@ocap/mcrypto');
- * const message = 'some message to sign';
- *
- * // Use Signer directly
- * const keyPair = Signer.Ed25519.genKeyPair();
- * const signature = Signer.Ed25519.sign(message, keyPair.secretKey);
- * const result = Signer.Ed25519.verify(message, signature, keyPair.publicKey);
- * assert.ok(result);
- */
-export const Signer = {
-    Ed25519: ed25519,
-    Secp256k1: secp256k1,
-    Ethereum: ethereum,
-    Passkey: passkey,
+* Contains all supported signers, eg: `Ed25519` and `Secp256k1`
+*
+* @readonly
+* @type {object}
+* @name Signer
+* @static
+* @example
+* const { Signer } = require('@ocap/mcrypto');
+* const message = 'some message to sign';
+*
+* // Use Signer directly
+* const keyPair = Signer.Ed25519.genKeyPair();
+* const signature = Signer.Ed25519.sign(message, keyPair.secretKey);
+* const result = Signer.Ed25519.verify(message, signature, keyPair.publicKey);
+* assert.ok(result);
+*/
+const Signer = {
+	Ed25519: ed25519_default,
+	Secp256k1: secp256k1_default,
+	Ethereum: ethereum_default,
+	Passkey: passkey_default
 };
 /**
- * Contains all supported hasher, eg: `SHA2`,`SHA3` and `Keccak`, each of them supports `hash224`, `hash256`, `hash384`, `hash512`
- *
- * @readonly
- * @type {object}
- * @name Hasher
- * @static
- * @example
- * const { Hasher } = require('@ocap/mcrypto');
- *
- * const message = 'message to hash';
- * const hash = Hasher.SHA2.hash256(message);
- */
-export const Hasher = {
-    SHA2: sha2,
-    SHA3: sha3,
-    Keccak: keccak,
+* Contains all supported hasher, eg: `SHA2`,`SHA3` and `Keccak`, each of them supports `hash224`, `hash256`, `hash384`, `hash512`
+*
+* @readonly
+* @type {object}
+* @name Hasher
+* @static
+* @example
+* const { Hasher } = require('@ocap/mcrypto');
+*
+* const message = 'message to hash';
+* const hash = Hasher.SHA2.hash256(message);
+*/
+const Hasher = {
+	SHA2: sha2_default,
+	SHA3: sha3_default,
+	Keccak: keccak_default
 };
 /**
- * Contains type constants that represent can be used to compose different crypto method, each crypto method consist one of:
- * FIXME: enum definition of forge-abi and abt-did-elixir are not exactly the same
- *
- * @readonly
- * @type {object}
- * @name types
- * @static
- * @example
- * const { types } = require('@ocap/mcrypto');
- *
- * // types.RoleType.ROLE_ACCOUNT
- * // types.KeyType.ED25519
- * // types.HashType.SHA3
- * // types.EncodingType.BASE58
- */
-export const types = {
-    /**
-     * Key-pair derivation algorithms
-     *
-     * @readonly
-     * @enum {number}
-     * @name types.KeyType
-     * @memberof types
-     * @static
-     */
-    KeyType: {
-        ED25519: 0,
-        SECP256K1: 1,
-        ETHEREUM: 2,
-        PASSKEY: 3,
-    },
-    /**
-     * Hashing algorithms
-     *
-     * @readonly
-     * @enum {number}
-     * @name types.HashType
-     * @memberof types
-     * @static
-     */
-    HashType: {
-        KECCAK: 0,
-        SHA3: 1,
-        KECCAK_384: 2,
-        SHA3_384: 3,
-        KECCAK_512: 4,
-        SHA3_512: 5,
-        SHA2: 6,
-    },
-    /**
-     * DID wallet role type
-     *
-     * @readonly
-     * @enum {number}
-     * @name types.RoleType
-     * @memberof types
-     * @static
-     */
-    RoleType: {
-        ROLE_ACCOUNT: 0,
-        ROLE_NODE: 1,
-        ROLE_DEVICE: 2,
-        ROLE_APPLICATION: 3,
-        ROLE_SMART_CONTRACT: 4,
-        ROLE_BOT: 5,
-        ROLE_ASSET: 6,
-        ROLE_STAKE: 7,
-        ROLE_VALIDATOR: 8,
-        ROLE_GROUP: 9,
-        ROLE_TX: 10,
-        ROLE_TETHER: 11,
-        ROLE_SWAP: 12,
-        ROLE_DELEGATION: 13,
-        ROLE_VC: 14,
-        ROLE_BLOCKLET: 15,
-        ROLE_STORE: 16,
-        ROLE_TOKEN: 17,
-        ROLE_FACTORY: 18,
-        ROLE_ROLLUP: 19,
-        ROLE_STORAGE: 20,
-        ROLE_PROFILE: 21,
-        ROLE_PASSKEY: 22,
-        ROLE_TOKEN_FACTORY: 23,
-        ROLE_ANY: 63,
-    },
-    /**
-     * Address encoding algorithm, defaults to `base58btc`
-     *
-     * @readonly
-     * @enum {number}
-     * @name types.RoleType
-     * @memberof types
-     * @static
-     */
-    EncodingType: {
-        BASE16: 0,
-        BASE58: 1,
-    },
+* Contains type constants that represent can be used to compose different crypto method, each crypto method consist one of:
+* FIXME: enum definition of forge-abi and abt-did-elixir are not exactly the same
+*
+* @readonly
+* @type {object}
+* @name types
+* @static
+* @example
+* const { types } = require('@ocap/mcrypto');
+*
+* // types.RoleType.ROLE_ACCOUNT
+* // types.KeyType.ED25519
+* // types.HashType.SHA3
+* // types.EncodingType.BASE58
+*/
+const types = {
+	KeyType: {
+		ED25519: 0,
+		SECP256K1: 1,
+		ETHEREUM: 2,
+		PASSKEY: 3
+	},
+	HashType: {
+		KECCAK: 0,
+		SHA3: 1,
+		KECCAK_384: 2,
+		SHA3_384: 3,
+		KECCAK_512: 4,
+		SHA3_512: 5,
+		SHA2: 6
+	},
+	RoleType: {
+		ROLE_ACCOUNT: 0,
+		ROLE_NODE: 1,
+		ROLE_DEVICE: 2,
+		ROLE_APPLICATION: 3,
+		ROLE_SMART_CONTRACT: 4,
+		ROLE_BOT: 5,
+		ROLE_ASSET: 6,
+		ROLE_STAKE: 7,
+		ROLE_VALIDATOR: 8,
+		ROLE_GROUP: 9,
+		ROLE_TX: 10,
+		ROLE_TETHER: 11,
+		ROLE_SWAP: 12,
+		ROLE_DELEGATION: 13,
+		ROLE_VC: 14,
+		ROLE_BLOCKLET: 15,
+		ROLE_STORE: 16,
+		ROLE_TOKEN: 17,
+		ROLE_FACTORY: 18,
+		ROLE_ROLLUP: 19,
+		ROLE_STORAGE: 20,
+		ROLE_PROFILE: 21,
+		ROLE_PASSKEY: 22,
+		ROLE_TOKEN_FACTORY: 23,
+		ROLE_ANY: 63
+	},
+	EncodingType: {
+		BASE16: 0,
+		BASE58: 1
+	}
 };
 /**
- * Get signer instance
- *
- * @function
- * @param {number} type - algorithm used to derive key pair, possible values are
- * - types.KeyType.ED25519
- * - types.KeyType.SECP256k1
- * - types.KeyType.ETHEREUM
- * @returns {object} signer instance
- * @example
- * const { getSigner, types } = require('@ocap/mcrypto');
- * const message = 'some message to sign';
- *
- * const signer = getSigner(types.KeyType.ED25519);
- * const keyPair1 = signer.genKeyPair();
- * const signature1 = signer.sign(message, keyPair1.secretKey);
- * const result1 = signer.verify(message, signature1, keyPair1.publicKey);
- * assert.ok(result1);
- */
-export function getSigner(type) {
-    if (typeof Signers[type] === 'undefined') {
-        throw new Error(`Unsupported signer type: ${type}`);
-    }
-    // @ts-ignore
-    return Signers[type];
+* Get signer instance
+*
+* @function
+* @param {number} type - algorithm used to derive key pair, possible values are
+* - types.KeyType.ED25519
+* - types.KeyType.SECP256k1
+* - types.KeyType.ETHEREUM
+* @returns {object} signer instance
+* @example
+* const { getSigner, types } = require('@ocap/mcrypto');
+* const message = 'some message to sign';
+*
+* const signer = getSigner(types.KeyType.ED25519);
+* const keyPair1 = signer.genKeyPair();
+* const signature1 = signer.sign(message, keyPair1.secretKey);
+* const result1 = signer.verify(message, signature1, keyPair1.publicKey);
+* assert.ok(result1);
+*/
+function getSigner(type) {
+	const Signers = Object.freeze({
+		[types.KeyType.ED25519]: Signer.Ed25519,
+		[types.KeyType.SECP256K1]: Signer.Secp256k1,
+		[types.KeyType.ETHEREUM]: Signer.Ethereum,
+		[types.KeyType.PASSKEY]: Signer.Passkey
+	});
+	if (typeof Signers[type] === "undefined") throw new Error(`Unsupported signer type: ${type}`);
+	return Signers[type];
 }
 /**
- * Get hasher instance
- *
- * @function
- * @param {number} type - algorithm used to hash data, possible values
- * - types.HashType.KECCAK
- * - types.HashType.KECCAK_384
- * - types.HashType.KECCAK_512
- * - types.HashType.SHA3
- * - types.HashType.SHA3_384
- * - types.HashType.SHA3_512
- * @returns {object} hasher instance
- * @example
- * const { getHasher, types } = require('@ocap/mcrypto');
- *
- * const hashFn = getHasher(types.HashType.SHA3);
- * const hash2 = hashFn(message);
- */
-export function getHasher(type) {
-    if (typeof Hashers[type] === 'undefined') {
-        throw new Error(`Unsupported hash type: ${type}`);
-    }
-    // @ts-ignore
-    return Hashers[type];
+* Get hasher instance
+*
+* @function
+* @param {number} type - algorithm used to hash data, possible values
+* - types.HashType.KECCAK
+* - types.HashType.KECCAK_384
+* - types.HashType.KECCAK_512
+* - types.HashType.SHA3
+* - types.HashType.SHA3_384
+* - types.HashType.SHA3_512
+* @returns {object} hasher instance
+* @example
+* const { getHasher, types } = require('@ocap/mcrypto');
+*
+* const hashFn = getHasher(types.HashType.SHA3);
+* const hash2 = hashFn(message);
+*/
+function getHasher(type) {
+	const Hashers = Object.freeze({
+		[types.HashType.KECCAK]: Hasher.Keccak.hash256,
+		[types.HashType.KECCAK_384]: Hasher.Keccak.hash384,
+		[types.HashType.KECCAK_512]: Hasher.Keccak.hash512,
+		[types.HashType.SHA3]: Hasher.SHA3.hash256,
+		[types.HashType.SHA3_384]: Hasher.SHA3.hash384,
+		[types.HashType.SHA3_512]: Hasher.SHA3.hash512,
+		[types.HashType.SHA2]: Hasher.SHA2.hash256
+	});
+	if (typeof Hashers[type] === "undefined") throw new Error(`Unsupported hash type: ${type}`);
+	return Hashers[type];
 }
-export function getRandomBytes(length = 32, encoding = 'hex') {
-    return encode(randomBytes(length), encoding);
+function getRandomBytes(length = 32, encoding = "hex") {
+	return encode(randomBytes(length), encoding);
 }
-export const Signers = Object.freeze({
-    [types.KeyType.ED25519]: Signer.Ed25519,
-    [types.KeyType.SECP256K1]: Signer.Secp256k1,
-    [types.KeyType.ETHEREUM]: Signer.Ethereum,
-    [types.KeyType.PASSKEY]: Signer.Passkey,
-});
-export const Hashers = Object.freeze({
-    [types.HashType.KECCAK]: Hasher.Keccak.hash256,
-    [types.HashType.KECCAK_384]: Hasher.Keccak.hash384,
-    [types.HashType.KECCAK_512]: Hasher.Keccak.hash512,
-    [types.HashType.SHA3]: Hasher.SHA3.hash256,
-    [types.HashType.SHA3_384]: Hasher.SHA3.hash384,
-    [types.HashType.SHA3_512]: Hasher.SHA3.hash512,
-    [types.HashType.SHA2]: Hasher.SHA2.hash256,
-});
-export const toTxHash = (buf) => Hasher.SHA2.hash256(buf, 1, 'hex').replace(/^0x/, '').toUpperCase();
+const toTxHash = (buf) => Hasher.SHA2.hash256(buf, 1, "hex").replace(/^0x/, "").toUpperCase();
+
+//#endregion
+export { Hasher, Signer, getHasher, getRandomBytes, getSigner, toTxHash, types };

package/esm/protocols/crypter.d.ts

@@ -1,2 +1,4 @@
+//#region src/protocols/crypter.d.ts
 declare const _default: any;
-export default _default;
+//#endregion
+export { _default as default };

package/esm/protocols/crypter.js

@@ -1,4 +1,7 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-// @ts-ignore
-import Interface from 'interface';
-export default Interface.create('encrypt', 'decrypt');
+import Interface from "interface";
+
+//#region src/protocols/crypter.ts
+var crypter_default = Interface.create("encrypt", "decrypt");
+
+//#endregion
+export { crypter_default as default };

package/esm/protocols/hasher.d.ts

@@ -1,2 +1,4 @@
+//#region src/protocols/hasher.d.ts
 declare const _default: any;
-export default _default;
+//#endregion
+export { _default as default };

package/esm/protocols/hasher.js

@@ -1,4 +1,7 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-// @ts-ignore
-import Interface from 'interface';
-export default Interface.create('sha224', 'sha256', 'sha384', 'sha512');
+import Interface from "interface";
+
+//#region src/protocols/hasher.ts
+var hasher_default = Interface.create("sha224", "sha256", "sha384", "sha512");
+
+//#endregion
+export { hasher_default as default };

package/esm/protocols/signer.d.ts

@@ -1,2 +1,4 @@
+//#region src/protocols/signer.d.ts
 declare const _default: any;
-export default _default;
+//#endregion
+export { _default as default };

package/esm/protocols/signer.js

@@ -1,4 +1,7 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-// @ts-ignore
-import Interface from 'interface';
-export default Interface.create('genKeyPair', 'getPublicKey', 'sign', 'verify');
+import Interface from "interface";
+
+//#region src/protocols/signer.ts
+var signer_default = Interface.create("genKeyPair", "getPublicKey", "sign", "verify");
+
+//#endregion
+export { signer_default as default };

package/esm/signer/ed25519.d.ts

@@ -1,53 +1,56 @@
-import { BytesType, EncodingType, KeyPairType } from '@ocap/util';
-import BaseSigner from '../protocols/signer';
+import _default$1 from "../protocols/signer.js";
+import { BytesType, EncodingType, KeyPairType } from "@ocap/util";
+
+//#region src/signer/ed25519.d.ts
+
 /**
  * Signer implementation for ed25519, based on `tweetnacl`
  *
  * @class Ed25519Signer
  */
-declare class Ed25519Signer extends BaseSigner {
-    constructor();
-    /**
-     * @public
-     * @typedefKeyPairType
-     * @prop {string} publicKey - publicKey in hex format
-     * @prop {string} secretKey - secretKey in hex format
-     * @memberof Ed25519Signer
-     */
-    /**
-     * Generate random secret/public key pair
-     *
-     * @param {Buffer|Uint8Array} [userSeed=undefined]
-     * @param {string} [encoding='hex']
-     * @returns {KeyPairType}
-     * @memberof Ed25519Signer
-     */
-    genKeyPair(encoding?: EncodingType, userSeed?: BytesType): KeyPairType;
-    /**
-     * Get publicKey from secretKey
-     *
-     * @param {hex|buffer|base58|Uint8Array} sk - can be either a hex encoded string or a buffer
-     * @returns {string} hex encoded publicKey
-     */
-    getPublicKey(sk: BytesType, encoding?: EncodingType): BytesType;
-    /**
-     * Sign a message and get the signature hex
-     *
-     * @param {hex|base58|buffer|Uint8Array} message
-     * @param {hex|base58|buffer|Uint8Array} sk
-     * @returns {string} hex encoded signature
-     */
-    sign(message: BytesType, sk: BytesType, encoding?: EncodingType): BytesType;
-    /**
-     * Verify if a signature is valid
-     *
-     * @param {string|buffer} message
-     * @param {string|buffer} signature
-     * @param {string|buffer} pk
-     * @returns {bool}
-     */
-    verify(message: BytesType, signature: BytesType, pk: BytesType): boolean;
+declare class Ed25519Signer extends _default$1 {
+  constructor();
+  /**
+   * @public
+   * @typedefKeyPairType
+   * @prop {string} publicKey - publicKey in hex format
+   * @prop {string} secretKey - secretKey in hex format
+   * @memberof Ed25519Signer
+   */
+  /**
+   * Generate random secret/public key pair
+   *
+   * @param {Buffer|Uint8Array} [userSeed=undefined]
+   * @param {string} [encoding='hex']
+   * @returns {KeyPairType}
+   * @memberof Ed25519Signer
+   */
+  genKeyPair(encoding?: EncodingType, userSeed?: BytesType): KeyPairType;
+  /**
+   * Get publicKey from secretKey
+   *
+   * @param {hex|buffer|base58|Uint8Array} sk - can be either a hex encoded string or a buffer
+   * @returns {string} hex encoded publicKey
+   */
+  getPublicKey(sk: BytesType, encoding?: EncodingType): BytesType;
+  /**
+   * Sign a message and get the signature hex
+   *
+   * @param {hex|base58|buffer|Uint8Array} message
+   * @param {hex|base58|buffer|Uint8Array} sk
+   * @returns {string} hex encoded signature
+   */
+  sign(message: BytesType, sk: BytesType, encoding?: EncodingType): BytesType;
+  /**
+   * Verify if a signature is valid
+   *
+   * @param {string|buffer} message
+   * @param {string|buffer} signature
+   * @param {string|buffer} pk
+   * @returns {bool}
+   */
+  verify(message: BytesType, signature: BytesType, pk: BytesType): boolean;
 }
 declare const _default: Ed25519Signer;
-export default _default;
-export { Ed25519Signer };
+//#endregion
+export { Ed25519Signer, _default as default };