@ocap/mcrypto 1.18.166 → 1.19.1

package/esm/index.js

@@ -0,0 +1,219 @@
+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';
+/**
+ * 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 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 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_ANY: 63,
+    },
+    /**
+     * Address encoding algorithm, defaults to `base58btc`
+     *
+     * @readonly
+     * @enum {number}
+     * @name types.RoleType
+     * @memberof types
+     * @static
+     */
+    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 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];
+}
+export 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();

package/esm/protocols/crypter.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/esm/protocols/crypter.js

@@ -0,0 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @ts-ignore
+import Interface from 'interface';
+export default Interface.create('encrypt', 'decrypt');

package/esm/protocols/hasher.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/esm/protocols/hasher.js

@@ -0,0 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @ts-ignore
+import Interface from 'interface';
+export default Interface.create('sha224', 'sha256', 'sha384', 'sha512');

package/esm/protocols/signer.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/esm/protocols/signer.js

@@ -0,0 +1,4 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @ts-ignore
+import Interface from 'interface';
+export default Interface.create('genKeyPair', 'getPublicKey', 'sign', 'verify');

package/esm/signer/ed25519.d.ts

@@ -0,0 +1,53 @@
+import { BytesType, EncodingType, KeyPairType } from '@ocap/util';
+import BaseSigner from '../protocols/signer';
+/**
+ * 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 const _default: Ed25519Signer;
+export default _default;
+export { Ed25519Signer };

package/esm/signer/ed25519.js

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/no-useless-constructor */
+import tweetnacl from 'tweetnacl';
+import randomBytes from 'randombytes';
+import { toUint8Array } from '@ocap/util';
+import BaseSigner from '../protocols/signer';
+import { encode } from '../encode';
+const ed25519 = tweetnacl.sign;
+/**
+ * Signer implementation for ed25519, based on `tweetnacl`
+ *
+ * @class Ed25519Signer
+ */
+class Ed25519Signer extends BaseSigner {
+    constructor() {
+        super();
+    }
+    /**
+     * @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 = 'hex', userSeed) {
+        const seed = userSeed ? toUint8Array(userSeed) : new Uint8Array(randomBytes(32));
+        if (seed.byteLength !== 32) {
+            throw new Error('Invalid seed to generate key pair');
+        }
+        const keyPair = ed25519.keyPair.fromSeed(seed);
+        keyPair.publicKey = encode(keyPair.publicKey, encoding);
+        keyPair.secretKey = encode(keyPair.secretKey, encoding);
+        return keyPair;
+    }
+    /**
+     * 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, encoding = 'hex') {
+        const skBytes = toUint8Array(sk);
+        const pk = ed25519.keyPair.fromSecretKey(skBytes).publicKey;
+        return encode(pk, encoding);
+    }
+    /**
+     * 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, sk, encoding = 'hex') {
+        const skBytes = toUint8Array(sk);
+        const messageBytes = toUint8Array(message);
+        const signature = ed25519.detached(messageBytes, skBytes);
+        return encode(signature, encoding);
+    }
+    /**
+     * Verify if a signature is valid
+     *
+     * @param {string|buffer} message
+     * @param {string|buffer} signature
+     * @param {string|buffer} pk
+     * @returns {bool}
+     */
+    verify(message, signature, pk) {
+        const pkBytes = toUint8Array(pk);
+        const messageBytes = toUint8Array(message);
+        const signatureBytes = toUint8Array(signature);
+        return ed25519.detached.verify(messageBytes, signatureBytes, pkBytes);
+    }
+}
+export default new Ed25519Signer();
+export { Ed25519Signer };

package/esm/signer/ethereum.d.ts

@@ -0,0 +1,16 @@
+import { Secp256k1Signer } from './secp256k1';
+/**
+ * Signer implementation for secp256k1, based on `elliptic`, and ethereum compatible
+ *
+ * @class EthereumSigner
+ */
+declare class EthereumSigner extends Secp256k1Signer {
+    pkHasFormatPrefix: boolean;
+    constructor();
+    ethHash(data: string): string;
+    ethSign(data: string, privateKey: string): string;
+    ethRecover(data: string, signature: string): string;
+}
+declare const _default: EthereumSigner;
+export default _default;
+export { EthereumSigner };

package/esm/signer/ethereum.js

@@ -0,0 +1,35 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @ts-ignore
+import Account from 'eth-lib/lib/account';
+// @ts-ignore
+import Hash from 'eth-lib/lib/hash';
+import { isHexStrict, utf8ToHex, hexToBytes } from '@ocap/util';
+import { Secp256k1Signer } from './secp256k1';
+/**
+ * Signer implementation for secp256k1, based on `elliptic`, and ethereum compatible
+ *
+ * @class EthereumSigner
+ */
+class EthereumSigner extends Secp256k1Signer {
+    constructor() {
+        super();
+        this.pkHasFormatPrefix = false;
+    }
+    ethHash(data) {
+        const messageHex = isHexStrict(data) ? data : utf8ToHex(data);
+        const messageBytes = hexToBytes(messageHex);
+        const messageBuffer = Buffer.from(messageBytes);
+        const preamble = `\x19Ethereum Signed Message:\n${messageBytes.length}`;
+        const preambleBuffer = Buffer.from(preamble);
+        const ethMessage = Buffer.concat([preambleBuffer, messageBuffer]);
+        return Hash.keccak256s(ethMessage);
+    }
+    ethSign(data, privateKey) {
+        return Account.sign(data, privateKey);
+    }
+    ethRecover(data, signature) {
+        return Account.recover(data, signature);
+    }
+}
+export default new EthereumSigner();
+export { EthereumSigner };

package/esm/signer/passkey.d.ts

@@ -0,0 +1,27 @@
+import { BytesType, EncodingType, KeyPairType } from '@ocap/util';
+import BaseSigner from '../protocols/signer';
+/**
+ * Signer implementation for passkey, based on `@simplewebauthn/server`
+ * Since passkey supports only verification, we do not need to implement the sign method
+ * And passkeys can used multiple algorithms, we do not need to implement the algorithm selection
+ *
+ * @class PasskeySigner
+ */
+declare class PasskeySigner extends BaseSigner {
+    constructor();
+    genKeyPair(encoding?: EncodingType, userSeed?: BytesType): KeyPairType;
+    getPublicKey(sk: BytesType, encoding?: EncodingType): BytesType;
+    sign(message: BytesType, sk: BytesType, encoding?: EncodingType): BytesType;
+    /**
+     * Verify if a signature is valid
+     *
+     * @param {string|buffer} challenge - the challenge sent to passkey, should be txHash when signing a transaction
+     * @param {string|buffer} signature - signature from passkey
+     * @param {string|buffer} pk - credentialPublicKey from passkey, must be parsed with `parseAuthenticatorData`
+     * @returns {bool}
+     */
+    verify(challenge: BytesType, signature: BytesType, pk: BytesType, extra: string): Promise<boolean>;
+}
+declare const _default: PasskeySigner;
+export default _default;
+export { PasskeySigner };

package/esm/signer/passkey.js

@@ -0,0 +1,59 @@
+/* eslint-disable @typescript-eslint/no-useless-constructor */
+import { toBuffer, fromBase64, toBase64 } from '@ocap/util';
+import { decodeClientDataJSON, isoBase64URL, isoUint8Array, toHash, verifySignature, } from '@simplewebauthn/server/helpers';
+import BaseSigner from '../protocols/signer';
+/**
+ * Signer implementation for passkey, based on `@simplewebauthn/server`
+ * Since passkey supports only verification, we do not need to implement the sign method
+ * And passkeys can used multiple algorithms, we do not need to implement the algorithm selection
+ *
+ * @class PasskeySigner
+ */
+class PasskeySigner extends BaseSigner {
+    constructor() {
+        super();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    genKeyPair(encoding = 'hex', userSeed) {
+        throw new Error('Not supported');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getPublicKey(sk, encoding = 'hex') {
+        throw new Error('Not supported');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    sign(message, sk, encoding = 'hex') {
+        throw new Error('Not supported');
+    }
+    /**
+     * Verify if a signature is valid
+     *
+     * @param {string|buffer} challenge - the challenge sent to passkey, should be txHash when signing a transaction
+     * @param {string|buffer} signature - signature from passkey
+     * @param {string|buffer} pk - credentialPublicKey from passkey, must be parsed with `parseAuthenticatorData`
+     * @returns {bool}
+     */
+    async verify(challenge, signature, pk, extra) {
+        const parsed = JSON.parse(extra);
+        if (!parsed.authenticatorData || !parsed.clientDataJSON) {
+            throw new Error('extra.authenticatorData or extra.clientDataJSON is required for passkey signature verification');
+        }
+        const authDataBuffer = toBuffer(fromBase64(parsed.authenticatorData));
+        const clientDataHash = await toHash(isoBase64URL.toBuffer(parsed.clientDataJSON));
+        const clientData = decodeClientDataJSON(parsed.clientDataJSON);
+        if (clientData.challenge !== toBase64(challenge)) {
+            throw new Error('challenge mismatch for passkey signature');
+        }
+        // FIXME: @wangshijun add more check here
+        // if (clientData.type !== 'ocap.tx.sign') {
+        //   throw new Error('Invalid client data type');
+        // }
+        return verifySignature({
+            signature: isoBase64URL.toBuffer(typeof signature === 'string' ? signature : toBase64(signature)),
+            data: isoUint8Array.concat([authDataBuffer, clientDataHash]),
+            credentialPublicKey: pk,
+        });
+    }
+}
+export default new PasskeySigner();
+export { PasskeySigner };

package/esm/signer/secp256k1.d.ts

@@ -0,0 +1,39 @@
+import { BytesType, KeyPairType, EncodingType } from '@ocap/util';
+import Signer from '../protocols/signer';
+/**
+ * Signer implementation for secp256k1, based on `elliptic`
+ *
+ * @class Secp256k1Signer
+ */
+declare class Secp256k1Signer extends Signer {
+    pkCompressed: boolean;
+    pkHasFormatPrefix: boolean;
+    constructor();
+    isValidSK(sk: Uint8Array): boolean;
+    /**
+     * @public
+     * @typedefKeyPairType
+     * @prop {string} publicKey - publicKey in hex format
+     * @prop {string} secretKey - secretKey in hex format
+     * @memberof Secp256k1Signer
+     */
+    /**
+     * Generate random secret/public key pair
+     */
+    genKeyPair(encoding?: EncodingType): KeyPairType;
+    /**
+     * Get publicKey from secretKey
+     */
+    getPublicKey(sk: BytesType, encoding?: EncodingType): BytesType;
+    /**
+     * Sign a message and get the signature hex
+     */
+    sign(message: BytesType, sk: BytesType, encoding?: EncodingType): BytesType;
+    /**
+     * Verify if a signature is valid
+     */
+    verify(message: BytesType, signature: BytesType, pk: BytesType): boolean;
+}
+declare const _default: Secp256k1Signer;
+export default _default;
+export { Secp256k1Signer };

package/esm/signer/secp256k1.js

@@ -0,0 +1,95 @@
+import elliptic from 'elliptic';
+import { BN, stripHexPrefix, toHex, toBuffer, toUint8Array } from '@ocap/util';
+import randomBytes from 'randombytes';
+import Signer from '../protocols/signer';
+import { encode } from '../encode';
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-useless-constructor */
+const EC = elliptic.ec;
+const secp256k1 = new EC('secp256k1');
+/**
+ * Signer implementation for secp256k1, based on `elliptic`
+ *
+ * @class Secp256k1Signer
+ */
+class Secp256k1Signer extends Signer {
+    constructor() {
+        super();
+        this.pkHasFormatPrefix = true;
+        this.pkCompressed = false;
+    }
+    isValidSK(sk) {
+        if (sk.byteLength !== 32) {
+            return false;
+        }
+        const bn = new BN(sk);
+        return bn.cmp(secp256k1.curve.n) < 0 && !bn.isZero();
+    }
+    /**
+     * @public
+     * @typedefKeyPairType
+     * @prop {string} publicKey - publicKey in hex format
+     * @prop {string} secretKey - secretKey in hex format
+     * @memberof Secp256k1Signer
+     */
+    /**
+     * Generate random secret/public key pair
+     */
+    genKeyPair(encoding = 'hex') {
+        let sk = null;
+        do {
+            sk = new Uint8Array(randomBytes(32));
+        } while (!this.isValidSK(sk));
+        const pk = this.getPublicKey(toHex(sk));
+        return { secretKey: encode(sk, encoding), publicKey: encode(pk, encoding) };
+    }
+    /**
+     * Get publicKey from secretKey
+     */
+    getPublicKey(sk, encoding = 'hex') {
+        if (!this.isValidSK(toUint8Array(sk))) {
+            throw new Error('Invalid secret key');
+        }
+        let pk = secp256k1.keyFromPrivate(toBuffer(sk)).getPublic(this.pkCompressed, 'hex');
+        if (this.pkHasFormatPrefix === false) {
+            pk = pk.slice(2);
+        }
+        return encode(`0x${pk}`, encoding);
+    }
+    /**
+     * Sign a message and get the signature hex
+     */
+    sign(message, sk, encoding = 'hex') {
+        let msg = message;
+        try {
+            msg = toUint8Array(message);
+        }
+        catch (err) {
+            // Do nothing;
+        }
+        const signature = secp256k1
+            .keyFromPrivate(toBuffer(sk))
+            .sign(stripHexPrefix(msg), { canonical: true })
+            .toDER('hex');
+        return encode(`0x${signature}`, encoding);
+    }
+    /**
+     * Verify if a signature is valid
+     */
+    verify(message, signature, pk) {
+        let msg = message;
+        try {
+            msg = toUint8Array(message);
+        }
+        catch (err) {
+            // Do nothing;
+        }
+        let pkBuffer = toBuffer(pk);
+        if (this.pkHasFormatPrefix === false && pkBuffer[0] !== 0x04 && pkBuffer.byteLength === 64) {
+            pkBuffer = Buffer.concat([Buffer.from([0x04]), pkBuffer]);
+        }
+        return secp256k1.keyFromPublic(pkBuffer).verify(stripHexPrefix(msg), stripHexPrefix(toHex(signature)));
+    }
+}
+export default new Secp256k1Signer();
+export { Secp256k1Signer };

package/lib/crypter/rsa-browserify.js

@@ -10,7 +10,7 @@ const ab2str = (buffer) => String.fromCharCode.apply(null, new Uint8Array(buffer
 const RSA_ALGORITHM = 'RSA-OAEP';
 // RSA-OAEP
 class RSABrowserCrypter {
-    async genKeyPair(length = 2048) {
+    genKeyPair(length = 2048) {
         return crypto.generateKey({
             name: RSA_ALGORITHM,
             modulusLength: length,

package/lib/crypter/rsa.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import crypto from 'crypto';
 import { BytesType, EncodingType } from '@ocap/util';
 import Crypter from '../protocols/crypter';

package/lib/encode.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { BytesType, EncodingType } from '@ocap/util';
 export declare function encode(data: BytesType, encoding?: 'hex'): string;
 export declare function encode(data: BytesType, encoding?: 'base16'): string;