@ocap/mcrypto 1.18.166 → 1.19.1

package/README.md

@@ -2,7 +2,7 @@
 
 [![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 [![docs](https://img.shields.io/badge/powered%20by-arcblock-green.svg)](https://docs.arcblock.io)
-[![Gitter](https://badges.gitter.im/ArcBlock/community.svg)](https://gitter.im/ArcBlock/community?utm_source=badge\&utm_medium=badge\&utm_campaign=pr-badge)
+[![Gitter](https://badges.gitter.im/ArcBlock/community.svg)](https://gitter.im/ArcBlock/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
 > Forge [mcrypto](https://github.com/ArcBlock/mcrypto) implementation for javascript, just a wrapper around existing javascript crypto libraries.
 
@@ -43,15 +43,15 @@ For full documentation, checkout [https://asset-chain.netlify.com](https://asset
 
 ### Hasher
 
-*   keccakf1600: js-sha3
-*   sha2: hash.js
-*   sha3: js-sha3
+- keccakf1600: js-sha3
+- sha2: hash.js
+- sha3: js-sha3
 
 ### Signer
 
-*   [`ed25519`](https://github.com/ArcBlock/blockchain/commit/ed25519): tweetnacl
-*   secp256k1: elliptic
+- [`ed25519`](https://github.com/ArcBlock/blockchain/commit/ed25519): tweetnacl
+- secp256k1: elliptic
 
 ### Crypter
 
-*   aes-cbc-256: crypto-js
+- aes-cbc-256: crypto-js

package/esm/crypter/aes-legacy.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/esm/crypter/aes-legacy.js

@@ -0,0 +1,26 @@
+import * as AES from 'crypto-js/aes';
+import encLatin1 from 'crypto-js/enc-latin1';
+import encUtf8 from 'crypto-js/enc-utf8';
+import encUtf16 from 'crypto-js/enc-utf16';
+import encBase64 from 'crypto-js/enc-base64';
+import encHex from 'crypto-js/enc-hex';
+import Crypter from '../protocols/crypter';
+const encoders = {
+    latin1: encLatin1,
+    utf8: encUtf8,
+    hex: encHex,
+    utf16: encUtf16,
+    base64: encBase64,
+};
+// AES-CBC-256
+class AesCrypter extends Crypter {
+    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]);
+    }
+}
+export default new AesCrypter();
+export { AesCrypter };

package/esm/crypter/aes.d.ts

@@ -0,0 +1,9 @@
+import { BytesType, EncodingType } from '@ocap/util';
+import Crypter from '../protocols/crypter';
+declare class AesCrypter extends Crypter {
+    encrypt(message: BytesType, secret: BytesType, encoding?: EncodingType): BytesType;
+    decrypt(message: BytesType, secret: BytesType, encoding?: EncodingType): BytesType;
+}
+declare const _default: AesCrypter;
+export default _default;
+export { AesCrypter };

package/esm/crypter/aes.js

@@ -0,0 +1,25 @@
+// For browsers, may need: https://www.npmjs.com/package/crypto-browserify
+import crypto from 'crypto';
+import { toBuffer } from '@ocap/util';
+import Crypter from '../protocols/crypter';
+import SHA3 from '../hasher/sha3';
+import { encode } from '../encode';
+// AES-ECB-256
+class AesCrypter extends Crypter {
+    encrypt(message, secret, encoding = 'hex') {
+        const key = SHA3.hash256(secret, 1, 'buffer');
+        const cipher = crypto.createCipheriv('aes-256-ecb', key, '');
+        cipher.setAutoPadding(true);
+        const output = cipher.update(toBuffer(message));
+        return encode(Buffer.concat([output, cipher.final()]), encoding);
+    }
+    decrypt(message, secret, encoding = 'hex') {
+        const key = SHA3.hash256(secret, 1, 'buffer');
+        const decipher = crypto.createDecipheriv('aes-256-ecb', key, '');
+        decipher.setAutoPadding(true);
+        const output = decipher.update(toBuffer(message));
+        return encode(Buffer.concat([output, decipher.final()]), encoding);
+    }
+}
+export default new AesCrypter();
+export { AesCrypter };

package/esm/crypter/rsa-browserify.d.ts

@@ -0,0 +1,9 @@
+declare class RSABrowserCrypter {
+    genKeyPair(length?: number): Promise<CryptoKeyPair>;
+    formatPublicKey(key: CryptoKey): Promise<string>;
+    encrypt(message: string, key: CryptoKey): Promise<string>;
+    decrypt(message: string, key: CryptoKey): Promise<string>;
+}
+declare const _default: RSABrowserCrypter;
+export default _default;
+export { RSABrowserCrypter };

package/esm/crypter/rsa-browserify.js

@@ -0,0 +1,33 @@
+// https://stackoverflow.com/questions/70056340/how-can-i-generate-an-rsa-pair-that-works-both-in-node-js-and-browser
+// https://stackoverflow.com/questions/62948516/using-native-javascript-subtlecrypto-to-encrypt-using-rsa
+import { fromBase58, toBase58 } from '@ocap/util';
+const crypto = window.crypto.subtle;
+// @ts-ignore
+const ab2str = (buffer) => String.fromCharCode.apply(null, new Uint8Array(buffer));
+const RSA_ALGORITHM = 'RSA-OAEP';
+// RSA-OAEP
+class RSABrowserCrypter {
+    genKeyPair(length = 2048) {
+        return crypto.generateKey({
+            name: RSA_ALGORITHM,
+            modulusLength: length,
+            publicExponent: new Uint8Array([1, 0, 1]),
+            hash: 'SHA-256',
+        }, true, ['encrypt', 'decrypt']);
+    }
+    async formatPublicKey(key) {
+        const exported = await crypto.exportKey('spki', key);
+        const base64 = window.btoa(ab2str(exported));
+        return `-----BEGIN PUBLIC KEY-----\n${base64}\n-----END PUBLIC KEY-----`;
+    }
+    async encrypt(message, key) {
+        const encrypted = await crypto.encrypt({ name: RSA_ALGORITHM }, key, new TextEncoder().encode(message));
+        return toBase58(new Uint8Array(encrypted));
+    }
+    async decrypt(message, key) {
+        const decrypted = await crypto.decrypt({ name: RSA_ALGORITHM }, key, fromBase58(message));
+        return Buffer.from(new Uint8Array(decrypted)).toString('utf8');
+    }
+}
+export default new RSABrowserCrypter();
+export { RSABrowserCrypter };

package/esm/crypter/rsa.d.ts

@@ -0,0 +1,11 @@
+import crypto from 'crypto';
+import { BytesType, EncodingType } from '@ocap/util';
+import Crypter from '../protocols/crypter';
+declare class RSACrypter extends Crypter {
+    genKeyPair(length?: number): crypto.KeyPairSyncResult<string, string>;
+    encrypt(message: BytesType, key: string, encoding?: EncodingType): BytesType;
+    decrypt(message: BytesType, key: string, encoding?: EncodingType): BytesType;
+}
+declare const _default: RSACrypter;
+export default _default;
+export { RSACrypter };

package/esm/crypter/rsa.js

@@ -0,0 +1,28 @@
+import crypto from 'crypto';
+import { toBuffer } from '@ocap/util';
+import Crypter from '../protocols/crypter';
+import { encode } from '../encode';
+// RSA-OAEP
+class RSACrypter extends Crypter {
+    genKeyPair(length = 2048) {
+        return crypto.generateKeyPairSync('rsa', {
+            modulusLength: length,
+            publicKeyEncoding: {
+                type: 'spki',
+                format: 'pem',
+            },
+            privateKeyEncoding: {
+                type: 'pkcs8',
+                format: 'pem',
+            },
+        });
+    }
+    encrypt(message, key, encoding = 'hex') {
+        return encode(crypto.publicEncrypt(key, toBuffer(message)), encoding);
+    }
+    decrypt(message, key, encoding = 'hex') {
+        return encode(crypto.privateDecrypt(key, toBuffer(message)), encoding);
+    }
+}
+export default new RSACrypter();
+export { RSACrypter };

package/esm/encode.d.ts

@@ -0,0 +1,8 @@
+import { BytesType, EncodingType } from '@ocap/util';
+export declare function encode(data: BytesType, encoding?: 'hex'): string;
+export declare function encode(data: BytesType, encoding?: 'base16'): string;
+export declare function encode(data: BytesType, encoding?: 'base58'): string;
+export declare function encode(data: BytesType, encoding?: 'base64'): string;
+export declare function encode(data: BytesType, encoding?: 'buffer'): Buffer;
+export declare function encode(data: BytesType, encoding?: 'Uint8Array'): Uint8Array;
+export declare function encode(data: BytesType, encoding?: EncodingType): BytesType;

package/esm/encode.js

@@ -0,0 +1,19 @@
+import { toHex, toUint8Array, toBase58, toBase64, toBuffer } from '@ocap/util';
+export 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;
+}

package/esm/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/esm/hasher/keccak.js

@@ -0,0 +1,37 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import sha3 from 'js-sha3';
+import { toUint8Array } from '@ocap/util';
+import { encode } from '../encode';
+/**
+ * Keccak support with different hash length
+ *
+ * @class KeccakHasher
+ */
+class KeccakHasher {
+    constructor() {
+        [224, 256, 384, 512].forEach((x) => {
+            const name = `hash${x}`;
+            // @ts-ignore
+            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);
+            };
+        });
+    }
+}
+export default new KeccakHasher();
+export { KeccakHasher };

package/esm/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/esm/hasher/sha2.js

@@ -0,0 +1,43 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { toUint8Array } from '@ocap/util';
+import { sha224, sha256, sha384, sha512 } from 'hash.js';
+import { encode } from '../encode';
+const hashFns = {
+    sha224,
+    sha256,
+    sha384,
+    sha512,
+};
+/**
+ * Sha2 support with different hash length
+ *
+ * @class
+ */
+class Sha2Hasher {
+    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 = 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);
+            };
+        });
+    }
+}
+export default new Sha2Hasher();
+export { Sha2Hasher };

package/esm/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/esm/hasher/sha3.js

@@ -0,0 +1,37 @@
+import sha3 from 'js-sha3';
+import { toUint8Array } from '@ocap/util';
+import { encode } from '../encode';
+/**
+ * Sha3 support with different hash length
+ *
+ * @class Sha3Hasher
+ */
+class Sha3Hasher {
+    constructor() {
+        [224, 256, 384, 512].forEach((x) => {
+            const name = `hash${x}`;
+            /* eslint-disable @typescript-eslint/ban-ts-comment */
+            // @ts-ignore
+            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);
+            };
+        });
+    }
+}
+export default new Sha3Hasher();
+export { Sha3Hasher };

package/esm/index.d.ts

@@ -0,0 +1,233 @@
+import type { BytesType, EncodingType, KeyPairType } from '@ocap/util';
+import type { LiteralUnion } from 'type-fest';
+export type KeyType = LiteralUnion<'ED25519' | 'SECP256K1' | 'ETHEREUM', string>;
+export type HashType = LiteralUnion<'KECCAK' | 'SHA3' | 'KECCAK_384' | 'SHA3_384' | 'KECCAK_512' | 'SHA3_512' | 'SHA2', string>;
+export type RoleType = LiteralUnion<'ROLE_ACCOUNT' | 'ROLE_NODE' | 'ROLE_DEVICE' | 'ROLE_APPLICATION' | 'ROLE_SMART_CONTRACT' | 'ROLE_BOT' | 'ROLE_ASSET' | 'ROLE_STAKE' | 'ROLE_VALIDATOR' | 'ROLE_GROUP' | 'ROLE_GROUP' | 'ROLE_TX' | 'ROLE_TETHER' | 'ROLE_SWAP' | 'ROLE_DELEGATION' | 'ROLE_VC' | 'ROLE_BLOCKLET' | 'ROLE_STORE' | 'ROLE_TOKEN' | 'ROLE_FACTORY' | 'ROLE_ROLLUP' | 'ROLE_STORAGE' | 'ROLE_PROFILE' | 'ROLE_PASSKEY' | 'ROLE_ANY', string>;
+export type AddressType = LiteralUnion<'BASE16' | 'BASE58', string>;
+export interface HashFnType {
+    (data: BytesType, round: number, encoding?: 'hex'): string;
+    (data: BytesType, round: number, encoding?: 'base16'): string;
+    (data: BytesType, round: number, encoding?: 'base58'): string;
+    (data: BytesType, round: number, encoding?: 'base64'): string;
+    (data: BytesType, round: number, encoding?: 'buffer'): Buffer;
+    (data: BytesType, round: number, encoding?: 'Uint8Array'): Uint8Array;
+    (data: BytesType, round: number, encoding?: EncodingType): BytesType;
+}
+export interface SignerType {
+    genKeyPair(encoding?: EncodingType, seed?: BytesType): KeyPairType;
+    getPublicKey(sk: BytesType, encoding?: 'hex'): string;
+    getPublicKey(sk: BytesType, encoding?: 'base16'): string;
+    getPublicKey(sk: BytesType, encoding?: 'base58'): string;
+    getPublicKey(sk: BytesType, encoding?: 'base64'): string;
+    getPublicKey(sk: BytesType, encoding?: 'buffer'): Buffer;
+    getPublicKey(sk: BytesType, encoding?: 'Uint8Array'): Uint8Array;
+    getPublicKey(sk: BytesType, encoding?: EncodingType): BytesType;
+    sign(data: BytesType, sk: BytesType, encoding?: 'hex'): string;
+    sign(data: BytesType, sk: BytesType, encoding?: 'base16'): string;
+    sign(data: BytesType, sk: BytesType, encoding?: 'base58'): string;
+    sign(data: BytesType, sk: BytesType, encoding?: 'base64'): string;
+    sign(data: BytesType, sk: BytesType, encoding?: 'buffer'): Buffer;
+    sign(data: BytesType, sk: BytesType, encoding?: 'Uint8Array'): Uint8Array;
+    sign(data: BytesType, sk: BytesType, encoding?: EncodingType): BytesType;
+    verify(data: BytesType, pk: BytesType, signature: BytesType, extra?: any): boolean;
+    ethHash?(data: string): string;
+    ethSign?(data: string, sk: string): string;
+    ethVerify?(data: string, pk: string, signature: BytesType): boolean;
+    ethRecover?(hash: string, signature: string): string;
+}
+/**
+ * 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 declare const Signer: {
+    Ed25519: import("./signer/ed25519").Ed25519Signer;
+    Secp256k1: import("./signer/secp256k1").Secp256k1Signer;
+    Ethereum: import("./signer/ethereum").EthereumSigner;
+    Passkey: import("./signer/passkey").PasskeySigner;
+};
+/**
+ * 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 declare const Hasher: {
+    SHA2: import("./hasher/sha2").Sha2Hasher;
+    SHA3: import("./hasher/sha3").Sha3Hasher;
+    Keccak: import("./hasher/keccak").KeccakHasher;
+};
+/**
+ * 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 declare const types: {
+    /**
+     * Key-pair derivation algorithms
+     *
+     * @readonly
+     * @enum {number}
+     * @name types.KeyType
+     * @memberof types
+     * @static
+     */
+    KeyType: {
+        ED25519: number;
+        SECP256K1: number;
+        ETHEREUM: number;
+        PASSKEY: number;
+    };
+    /**
+     * Hashing algorithms
+     *
+     * @readonly
+     * @enum {number}
+     * @name types.HashType
+     * @memberof types
+     * @static
+     */
+    HashType: {
+        KECCAK: number;
+        SHA3: number;
+        KECCAK_384: number;
+        SHA3_384: number;
+        KECCAK_512: number;
+        SHA3_512: number;
+        SHA2: number;
+    };
+    /**
+     * DID wallet role type
+     *
+     * @readonly
+     * @enum {number}
+     * @name types.RoleType
+     * @memberof types
+     * @static
+     */
+    RoleType: {
+        ROLE_ACCOUNT: number;
+        ROLE_NODE: number;
+        ROLE_DEVICE: number;
+        ROLE_APPLICATION: number;
+        ROLE_SMART_CONTRACT: number;
+        ROLE_BOT: number;
+        ROLE_ASSET: number;
+        ROLE_STAKE: number;
+        ROLE_VALIDATOR: number;
+        ROLE_GROUP: number;
+        ROLE_TX: number;
+        ROLE_TETHER: number;
+        ROLE_SWAP: number;
+        ROLE_DELEGATION: number;
+        ROLE_VC: number;
+        ROLE_BLOCKLET: number;
+        ROLE_STORE: number;
+        ROLE_TOKEN: number;
+        ROLE_FACTORY: number;
+        ROLE_ROLLUP: number;
+        ROLE_STORAGE: number;
+        ROLE_PROFILE: number;
+        ROLE_PASSKEY: number;
+        ROLE_ANY: number;
+    };
+    /**
+     * Address encoding algorithm, defaults to `base58btc`
+     *
+     * @readonly
+     * @enum {number}
+     * @name types.RoleType
+     * @memberof types
+     * @static
+     */
+    EncodingType: {
+        BASE16: number;
+        BASE58: number;
+    };
+};
+/**
+ * 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 declare function getSigner(type: number): SignerType;
+/**
+ * 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 declare function getHasher(type: number): HashFnType;
+/**
+ * Get random bytes in specified encoding
+ */
+export declare function getRandomBytes(length: number, encoding?: 'hex'): string;
+export declare function getRandomBytes(length: number, encoding?: 'base16'): string;
+export declare function getRandomBytes(length: number, encoding?: 'base58'): string;
+export declare function getRandomBytes(length: number, encoding?: 'base64'): string;
+export declare function getRandomBytes(length: number, encoding?: 'buffer'): Buffer;
+export declare function getRandomBytes(length: number, encoding?: 'Uint8Array'): Uint8Array;
+export declare function getRandomBytes(length: number, encoding?: EncodingType): BytesType;
+export declare const Signers: Readonly<{
+    [x: number]: import("./signer/ed25519").Ed25519Signer | import("./signer/secp256k1").Secp256k1Signer | import("./signer/passkey").PasskeySigner;
+}>;
+export declare const Hashers: Readonly<{
+    [x: number]: (data: BytesType, round?: number, encoding?: EncodingType) => BytesType;
+}>;
+export declare const toTxHash: (buf: Buffer | Uint8Array) => string;