@ocap/mcrypto 1.27.15 → 1.28.0

package/lib/signer/ed25519.js

@@ -1,88 +1,87 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ed25519Signer = void 0;
-/* eslint-disable @typescript-eslint/no-useless-constructor */
-const tweetnacl_1 = __importDefault(require("tweetnacl"));
-const randombytes_1 = __importDefault(require("randombytes"));
-const util_1 = require("@ocap/util");
-const signer_1 = __importDefault(require("../protocols/signer"));
-const encode_1 = require("../encode");
-const ed25519 = tweetnacl_1.default.sign;
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_encode = require('../encode.js');
+const require_protocols_signer = require('../protocols/signer.js');
+let _ocap_util = require("@ocap/util");
+let randombytes = require("randombytes");
+randombytes = require_rolldown_runtime.__toESM(randombytes);
+let tweetnacl = require("tweetnacl");
+tweetnacl = require_rolldown_runtime.__toESM(tweetnacl);
+
+//#region src/signer/ed25519.ts
+const ed25519 = tweetnacl.default.sign;
 /**
- * Signer implementation for ed25519, based on `tweetnacl`
- *
- * @class Ed25519Signer
- */
-class Ed25519Signer extends signer_1.default {
-    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 ? (0, util_1.toUint8Array)(userSeed) : new Uint8Array((0, randombytes_1.default)(32));
-        if (seed.byteLength !== 32) {
-            throw new Error('Invalid seed to generate key pair');
-        }
-        const keyPair = ed25519.keyPair.fromSeed(seed);
-        keyPair.publicKey = (0, encode_1.encode)(keyPair.publicKey, encoding);
-        keyPair.secretKey = (0, encode_1.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 = (0, util_1.toUint8Array)(sk);
-        const pk = ed25519.keyPair.fromSecretKey(skBytes).publicKey;
-        return (0, encode_1.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 = (0, util_1.toUint8Array)(sk);
-        const messageBytes = (0, util_1.toUint8Array)(message);
-        const signature = ed25519.detached(messageBytes, skBytes);
-        return (0, encode_1.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 = (0, util_1.toUint8Array)(pk);
-        const messageBytes = (0, util_1.toUint8Array)(message);
-        const signatureBytes = (0, util_1.toUint8Array)(signature);
-        return ed25519.detached.verify(messageBytes, signatureBytes, pkBytes);
-    }
-}
+* Signer implementation for ed25519, based on `tweetnacl`
+*
+* @class Ed25519Signer
+*/
+var Ed25519Signer = class extends require_protocols_signer.default {
+	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 ? (0, _ocap_util.toUint8Array)(userSeed) : new Uint8Array((0, randombytes.default)(32));
+		if (seed.byteLength !== 32) throw new Error("Invalid seed to generate key pair");
+		const keyPair = ed25519.keyPair.fromSeed(seed);
+		keyPair.publicKey = require_encode.encode(keyPair.publicKey, encoding);
+		keyPair.secretKey = require_encode.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 = (0, _ocap_util.toUint8Array)(sk);
+		const pk = ed25519.keyPair.fromSecretKey(skBytes).publicKey;
+		return require_encode.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 = (0, _ocap_util.toUint8Array)(sk);
+		const messageBytes = (0, _ocap_util.toUint8Array)(message);
+		return require_encode.encode(ed25519.detached(messageBytes, skBytes), 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 = (0, _ocap_util.toUint8Array)(pk);
+		const messageBytes = (0, _ocap_util.toUint8Array)(message);
+		const signatureBytes = (0, _ocap_util.toUint8Array)(signature);
+		return ed25519.detached.verify(messageBytes, signatureBytes, pkBytes);
+	}
+};
+var ed25519_default = new Ed25519Signer();
+
+//#endregion
 exports.Ed25519Signer = Ed25519Signer;
-exports.default = new Ed25519Signer();
+exports.default = ed25519_default;

package/lib/signer/ethereum.d.ts

@@ -1,16 +1,19 @@
-import { Secp256k1Signer } from './secp256k1';
+import { Secp256k1Signer } from "./secp256k1.js";
+
+//#region src/signer/ethereum.d.ts
+
 /**
  * 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;
+  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 };
+//#endregion
+export { EthereumSigner, _default as default };

package/lib/signer/ethereum.js

@@ -1,41 +1,40 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EthereumSigner = void 0;
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-// @ts-ignore
-const account_1 = __importDefault(require("eth-lib/lib/account"));
-// @ts-ignore
-const hash_1 = __importDefault(require("eth-lib/lib/hash"));
-const util_1 = require("@ocap/util");
-const secp256k1_1 = require("./secp256k1");
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_signer_secp256k1 = require('./secp256k1.js');
+let _ocap_util = require("@ocap/util");
+let eth_lib_lib_account = require("eth-lib/lib/account");
+eth_lib_lib_account = require_rolldown_runtime.__toESM(eth_lib_lib_account);
+let eth_lib_lib_hash = require("eth-lib/lib/hash");
+eth_lib_lib_hash = require_rolldown_runtime.__toESM(eth_lib_lib_hash);
+
+//#region src/signer/ethereum.ts
 /**
- * Signer implementation for secp256k1, based on `elliptic`, and ethereum compatible
- *
- * @class EthereumSigner
- */
-class EthereumSigner extends secp256k1_1.Secp256k1Signer {
-    constructor() {
-        super();
-        this.pkHasFormatPrefix = false;
-    }
-    ethHash(data) {
-        const messageHex = (0, util_1.isHexStrict)(data) ? data : (0, util_1.utf8ToHex)(data);
-        const messageBytes = (0, util_1.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_1.default.keccak256s(ethMessage);
-    }
-    ethSign(data, privateKey) {
-        return account_1.default.sign(data, privateKey);
-    }
-    ethRecover(data, signature) {
-        return account_1.default.recover(data, signature);
-    }
-}
+* Signer implementation for secp256k1, based on `elliptic`, and ethereum compatible
+*
+* @class EthereumSigner
+*/
+var EthereumSigner = class extends require_signer_secp256k1.Secp256k1Signer {
+	constructor() {
+		super();
+		this.pkHasFormatPrefix = false;
+	}
+	ethHash(data) {
+		const messageBytes = (0, _ocap_util.hexToBytes)((0, _ocap_util.isHexStrict)(data) ? data : (0, _ocap_util.utf8ToHex)(data));
+		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 eth_lib_lib_hash.default.keccak256s(ethMessage);
+	}
+	ethSign(data, privateKey) {
+		return eth_lib_lib_account.default.sign(data, privateKey);
+	}
+	ethRecover(data, signature) {
+		return eth_lib_lib_account.default.recover(data, signature);
+	}
+};
+var ethereum_default = new EthereumSigner();
+
+//#endregion
 exports.EthereumSigner = EthereumSigner;
-exports.default = new EthereumSigner();
+exports.default = ethereum_default;

package/lib/signer/passkey.d.ts

@@ -1,5 +1,8 @@
-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/passkey.d.ts
+
 /**
  * Signer implementation for passkey, based on `@simplewebauthn/server`
  * Since passkey supports only verification, we do not need to implement the sign method
@@ -7,21 +10,21 @@ import BaseSigner from '../protocols/signer';
  *
  * @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 class PasskeySigner extends _default$1 {
+  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 };
+//#endregion
+export { PasskeySigner, _default as default };

package/lib/signer/passkey.js

@@ -1,65 +1,53 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PasskeySigner = void 0;
-/* eslint-disable @typescript-eslint/no-useless-constructor */
-const util_1 = require("@ocap/util");
-const helpers_1 = require("@simplewebauthn/server/helpers");
-const signer_1 = __importDefault(require("../protocols/signer"));
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_protocols_signer = require('../protocols/signer.js');
+let _ocap_util = require("@ocap/util");
+let _simplewebauthn_server_helpers = require("@simplewebauthn/server/helpers");
+
+//#region src/signer/passkey.ts
 /**
- * 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 signer_1.default {
-    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 = (0, util_1.toBuffer)((0, util_1.fromBase64)(parsed.authenticatorData));
-        const clientDataHash = await (0, helpers_1.toHash)(helpers_1.isoBase64URL.toBuffer(parsed.clientDataJSON));
-        const clientData = (0, helpers_1.decodeClientDataJSON)(parsed.clientDataJSON);
-        if (clientData.challenge !== (0, util_1.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 (0, helpers_1.verifySignature)({
-            signature: helpers_1.isoBase64URL.toBuffer(typeof signature === 'string' ? signature : (0, util_1.toBase64)(signature)),
-            data: helpers_1.isoUint8Array.concat([authDataBuffer, clientDataHash]),
-            credentialPublicKey: pk,
-        });
-    }
-}
+* 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
+*/
+var PasskeySigner = class extends require_protocols_signer.default {
+	constructor() {
+		super();
+	}
+	genKeyPair(encoding = "hex", userSeed) {
+		throw new Error("Not supported");
+	}
+	getPublicKey(sk, encoding = "hex") {
+		throw new Error("Not supported");
+	}
+	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 = (0, _ocap_util.toBuffer)((0, _ocap_util.fromBase64)(parsed.authenticatorData));
+		const clientDataHash = await (0, _simplewebauthn_server_helpers.toHash)(_simplewebauthn_server_helpers.isoBase64URL.toBuffer(parsed.clientDataJSON));
+		if ((0, _simplewebauthn_server_helpers.decodeClientDataJSON)(parsed.clientDataJSON).challenge !== (0, _ocap_util.toBase64)(challenge)) throw new Error("challenge mismatch for passkey signature");
+		return (0, _simplewebauthn_server_helpers.verifySignature)({
+			signature: _simplewebauthn_server_helpers.isoBase64URL.toBuffer(typeof signature === "string" ? signature : (0, _ocap_util.toBase64)(signature)),
+			data: _simplewebauthn_server_helpers.isoUint8Array.concat([authDataBuffer, clientDataHash]),
+			credentialPublicKey: pk
+		});
+	}
+};
+var passkey_default = new PasskeySigner();
+
+//#endregion
 exports.PasskeySigner = PasskeySigner;
-exports.default = new PasskeySigner();
+exports.default = passkey_default;

package/lib/signer/secp256k1.d.ts

@@ -1,39 +1,42 @@
-import { BytesType, KeyPairType, EncodingType } from '@ocap/util';
-import Signer from '../protocols/signer';
+import _default$1 from "../protocols/signer.js";
+import { BytesType, EncodingType, KeyPairType } from "@ocap/util";
+
+//#region src/signer/secp256k1.d.ts
+
 /**
  * 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 class Secp256k1Signer extends _default$1 {
+  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 };
+//#endregion
+export { Secp256k1Signer, _default as default };