@ocap/wallet 1.27.15 → 1.28.0

package/esm/index.d.ts

@@ -1,52 +1,54 @@
-import { EncodingType, BytesType } from '@ocap/util';
-import { DidType, DIDType, DIDTypeStr, DIDTypeArg } from '@arcblock/did';
+import { BytesType, EncodingType } from "@ocap/util";
+import { DIDType, DIDTypeArg, DIDTypeStr, DidType } from "@arcblock/did";
+
+//#region src/index.d.ts
 type KeyPairType<T extends BytesType = string> = {
-    sk?: T;
-    pk?: T;
-    address?: string;
+  sk?: T;
+  pk?: T;
+  address?: string;
 };
-export type SerializedWallet = {
-    type: DIDTypeStr;
-    pk: string;
-    sk: string;
-    address: string;
+type SerializedWallet = {
+  type: DIDTypeStr;
+  pk: string;
+  sk: string;
+  address: string;
 };
-export interface WalletObject<T extends BytesType = string> {
-    type: DIDType;
-    secretKey: T;
-    publicKey: T;
-    address: string;
-    hash(data: BytesType, round?: number, encoding?: 'hex'): string;
-    hash(data: BytesType, round?: number, encoding?: 'base16'): string;
-    hash(data: BytesType, round?: number, encoding?: 'base58'): string;
-    hash(data: BytesType, round?: number, encoding?: 'base64'): string;
-    hash(data: BytesType, round?: number, encoding?: 'buffer'): Buffer;
-    hash(data: BytesType, round?: number, encoding?: 'Uint8Array'): Uint8Array;
-    hash(data: BytesType, round?: number, encoding?: EncodingType): BytesType;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'hex'): Promise<string>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base16'): Promise<string>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base58'): Promise<string>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base64'): Promise<string>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'buffer'): Promise<Buffer>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Promise<Uint8Array>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: EncodingType): Promise<BytesType>;
-    verify(data: BytesType, signature: BytesType, hashBeforeVerify?: boolean, extra?: any): Promise<boolean>;
-    ethHash(data: string): string;
-    ethSign(data: string, hashBeforeSign?: boolean): Promise<string>;
-    ethVerify(data: string, signature: string, hashBeforeVerify?: boolean): Promise<boolean>;
-    signETH(data: string, hashBeforeSign?: boolean): Promise<string>;
-    signJWT(payload?: any, doSign?: boolean, version?: string): Promise<string>;
-    toJSON(): SerializedWallet;
-    /**
-     * @deprecated ES6: use `wallet.address` instead
-     */
-    toAddress(): string;
+interface WalletObject<T extends BytesType = string> {
+  type: DIDType;
+  secretKey: T;
+  publicKey: T;
+  address: string;
+  hash(data: BytesType, round?: number, encoding?: 'hex'): string;
+  hash(data: BytesType, round?: number, encoding?: 'base16'): string;
+  hash(data: BytesType, round?: number, encoding?: 'base58'): string;
+  hash(data: BytesType, round?: number, encoding?: 'base64'): string;
+  hash(data: BytesType, round?: number, encoding?: 'buffer'): Buffer;
+  hash(data: BytesType, round?: number, encoding?: 'Uint8Array'): Uint8Array;
+  hash(data: BytesType, round?: number, encoding?: EncodingType): BytesType;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'hex'): Promise<string>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base16'): Promise<string>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base58'): Promise<string>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base64'): Promise<string>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'buffer'): Promise<Buffer>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Promise<Uint8Array>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: EncodingType): Promise<BytesType>;
+  verify(data: BytesType, signature: BytesType, hashBeforeVerify?: boolean, extra?: any): Promise<boolean>;
+  ethHash(data: string): string;
+  ethSign(data: string, hashBeforeSign?: boolean): Promise<string>;
+  ethVerify(data: string, signature: string, hashBeforeVerify?: boolean): Promise<boolean>;
+  signETH(data: string, hashBeforeSign?: boolean): Promise<string>;
+  signJWT(payload?: any, doSign?: boolean, version?: string): Promise<string>;
+  toJSON(): SerializedWallet;
+  /**
+   * @deprecated ES6: use `wallet.address` instead
+   */
+  toAddress(): string;
 }
-export declare const WalletType: typeof DidType;
+declare const WalletType: typeof DidType;
 /**
  * Generate an wallet instance that can be used to sign a message or verify a signature
  */
-export declare function Wallet<T extends BytesType = string>(keyPair: KeyPairType<T>, t?: DIDTypeArg): WalletObject<T>;
+declare function Wallet<T extends BytesType = string>(keyPair: KeyPairType<T>, t?: DIDTypeArg): WalletObject<T>;
 /**
  * Generate a wallet from secretKey
  *
@@ -65,27 +67,28 @@ export declare function Wallet<T extends BytesType = string>(keyPair: KeyPairTyp
  * assert.equal(signature, sig, "signature should match");
  * assert.ok(wallet.verify(message, signature), "signature should be verified");
  */
-export declare function fromSecretKey<T extends BytesType = string>(sk: T, _type?: DIDTypeArg): WalletObject<T>;
+declare function fromSecretKey<T extends BytesType = string>(sk: T, _type?: DIDTypeArg): WalletObject<T>;
 /**
  * Generate a wallet from publicKey
  */
-export declare function fromPublicKey<T extends BytesType = string>(pk: T, _type?: DIDTypeArg): WalletObject<T>;
+declare function fromPublicKey<T extends BytesType = string>(pk: T, _type?: DIDTypeArg): WalletObject<T>;
 /**
  * Generate a wallet from address (did)
  *
  * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
  */
-export declare function fromAddress<T extends BytesType = string>(address: string): WalletObject<T>;
+declare function fromAddress<T extends BytesType = string>(address: string): WalletObject<T>;
 /**
  * Generate a wallet by generating a random secretKey
  */
-export declare function fromRandom<T extends BytesType = string>(_type?: DIDTypeArg): WalletObject<T>;
+declare function fromRandom<T extends BytesType = string>(_type?: DIDTypeArg): WalletObject<T>;
 /**
  * Generating a wallet from a serialized json presentation of another wallet
  */
-export declare function fromJSON<T extends BytesType = string>(json: SerializedWallet): WalletObject<T>;
+declare function fromJSON<T extends BytesType = string>(json: SerializedWallet): WalletObject<T>;
 /**
  * Check if an object is valid wallet object
  */
-export declare function isValid(wallet: WalletObject, canSign?: boolean): boolean;
-export {};
+declare function isValid(wallet: WalletObject, canSign?: boolean): boolean;
+//#endregion
+export { SerializedWallet, Wallet, WalletObject, WalletType, fromAddress, fromJSON, fromPublicKey, fromRandom, fromSecretKey, isValid };

package/esm/index.js

@@ -1,172 +1,143 @@
-import { toHex } from '@ocap/util';
-import { getSigner, getHasher } from '@ocap/mcrypto';
-import { toAddress, fromPublicKey as DIDFromPublicKey, toTypeInfo, DidType, } from '@arcblock/did';
-import * as JWT from '@arcblock/jwt';
-export const WalletType = DidType;
+import { toHex } from "@ocap/util";
+import { getHasher, getSigner } from "@ocap/mcrypto";
+import { DidType, fromPublicKey as fromPublicKey$1, toAddress, toTypeInfo } from "@arcblock/did";
+import * as JWT from "@arcblock/jwt";
+
+//#region src/index.ts
+const WalletType = DidType;
 /**
- * Generate an wallet instance that can be used to sign a message or verify a signature
- */
-export function Wallet(keyPair, t = 'default') {
-    const type = DidType(t);
-    const signer = getSigner(type.pk);
-    const hasher = getHasher(type.hash);
-    return {
-        type,
-        secretKey: keyPair.sk,
-        publicKey: keyPair.pk,
-        address: keyPair.pk ? DIDFromPublicKey(keyPair.pk, type) : keyPair.address,
-        // @ts-ignore
-        hash(data, round = 1, encoding = 'hex') {
-            return hasher(data, round, encoding);
-        },
-        // @ts-ignore
-        // eslint-disable-next-line require-await
-        async sign(data, hashBeforeSign = true, encoding = 'hex') {
-            if (!keyPair.sk) {
-                throw new Error('Cannot sign data without a secretKey');
-            }
-            if (hashBeforeSign) {
-                const hash = hasher(data, 1);
-                return signer.sign(hash, keyPair.sk, encoding);
-            }
-            return signer.sign(data, keyPair.sk, encoding);
-        },
-        // eslint-disable-next-line require-await
-        async verify(data, signature, hashBeforeVerify = true, extra) {
-            if (!keyPair.pk) {
-                throw new Error('Cannot verify data without a publicKey');
-            }
-            const hash = hashBeforeVerify ? hasher(data, 1) : data;
-            return signer.verify(hash, signature, keyPair.pk, extra);
-        },
-        ethHash(data) {
-            if (typeof signer.ethHash !== 'function') {
-                throw new Error('ethHash is not supported by signer');
-            }
-            return signer.ethHash(data);
-        },
-        // eslint-disable-next-line require-await
-        async signETH(data, hashBeforeSign = true) {
-            if (!keyPair.sk) {
-                throw new Error('Cannot sign data without a secretKey');
-            }
-            if (typeof signer.ethHash !== 'function') {
-                throw new Error('ethSign is not supported by signer');
-            }
-            if (hashBeforeSign) {
-                return signer.ethSign(signer.ethHash(data), toHex(keyPair.sk));
-            }
-            return signer.ethSign(data, toHex(keyPair.sk));
-        },
-        ethSign(data, hashBeforeSign = true) {
-            return this.signETH(data, hashBeforeSign);
-        },
-        // eslint-disable-next-line require-await
-        async ethVerify(data, signature, hashBeforeVerify = true) {
-            if (typeof signer.ethHash !== 'function') {
-                throw new Error('ethVerify is not supported by signer');
-            }
-            const hash = hashBeforeVerify ? signer.ethHash(data) : data;
-            return signer.ethRecover(hash, signature) === this.address;
-        },
-        // eslint-disable-next-line require-await
-        async signJWT(payload = {}, doSign = true, version = '1.0.0') {
-            if (!keyPair.sk) {
-                throw new Error('Cannot sign JWT without a secretKey');
-            }
-            return JWT.sign(this.address, keyPair.sk, payload, doSign, version);
-        },
-        // deprecated
-        toAddress() {
-            return keyPair.pk ? DIDFromPublicKey(keyPair.pk, type) : keyPair.address;
-        },
-        toJSON() {
-            return {
-                type: DidType.toJSON(type),
-                sk: toHex(keyPair.sk),
-                pk: toHex(keyPair.pk),
-                address: this.address,
-            };
-        },
-    };
+* Generate an wallet instance that can be used to sign a message or verify a signature
+*/
+function Wallet(keyPair, t = "default") {
+	const type = DidType(t);
+	const signer = getSigner(type.pk);
+	const hasher = getHasher(type.hash);
+	return {
+		type,
+		secretKey: keyPair.sk,
+		publicKey: keyPair.pk,
+		address: keyPair.pk ? fromPublicKey$1(keyPair.pk, type) : keyPair.address,
+		hash(data, round = 1, encoding = "hex") {
+			return hasher(data, round, encoding);
+		},
+		async sign(data, hashBeforeSign = true, encoding = "hex") {
+			if (!keyPair.sk) throw new Error("Cannot sign data without a secretKey");
+			if (hashBeforeSign) {
+				const hash = hasher(data, 1);
+				return signer.sign(hash, keyPair.sk, encoding);
+			}
+			return signer.sign(data, keyPair.sk, encoding);
+		},
+		async verify(data, signature, hashBeforeVerify = true, extra) {
+			if (!keyPair.pk) throw new Error("Cannot verify data without a publicKey");
+			const hash = hashBeforeVerify ? hasher(data, 1) : data;
+			return signer.verify(hash, signature, keyPair.pk, extra);
+		},
+		ethHash(data) {
+			if (typeof signer.ethHash !== "function") throw new Error("ethHash is not supported by signer");
+			return signer.ethHash(data);
+		},
+		async signETH(data, hashBeforeSign = true) {
+			if (!keyPair.sk) throw new Error("Cannot sign data without a secretKey");
+			if (typeof signer.ethHash !== "function") throw new Error("ethSign is not supported by signer");
+			if (hashBeforeSign) return signer.ethSign(signer.ethHash(data), toHex(keyPair.sk));
+			return signer.ethSign(data, toHex(keyPair.sk));
+		},
+		ethSign(data, hashBeforeSign = true) {
+			return this.signETH(data, hashBeforeSign);
+		},
+		async ethVerify(data, signature, hashBeforeVerify = true) {
+			if (typeof signer.ethHash !== "function") throw new Error("ethVerify is not supported by signer");
+			const hash = hashBeforeVerify ? signer.ethHash(data) : data;
+			return signer.ethRecover(hash, signature) === this.address;
+		},
+		async signJWT(payload = {}, doSign = true, version = "1.0.0") {
+			if (!keyPair.sk) throw new Error("Cannot sign JWT without a secretKey");
+			return JWT.sign(this.address, keyPair.sk, payload, doSign, version);
+		},
+		toAddress() {
+			return keyPair.pk ? fromPublicKey$1(keyPair.pk, type) : keyPair.address;
+		},
+		toJSON() {
+			return {
+				type: DidType.toJSON(type),
+				sk: toHex(keyPair.sk),
+				pk: toHex(keyPair.pk),
+				address: this.address
+			};
+		}
+	};
 }
 /**
- * Generate a wallet from secretKey
- *
- * @example
- * const assert = require('assert');
- * const { fromSecretKey } = require('@ocap/wallet');
- *
- * const sk =
- *   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
- * const sig =
- *   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
- *
- * const wallet = fromSecretKey(sk, type);
- * const message = 'data to sign';
- * const signature = wallet.sign(message);
- * assert.equal(signature, sig, "signature should match");
- * assert.ok(wallet.verify(message, signature), "signature should be verified");
- */
-export function fromSecretKey(sk, _type = 'default') {
-    const type = DidType(_type);
-    const keyPair = { sk, pk: getSigner(type.pk).getPublicKey(sk) };
-    return Wallet(keyPair, type);
+* Generate a wallet from secretKey
+*
+* @example
+* const assert = require('assert');
+* const { fromSecretKey } = require('@ocap/wallet');
+*
+* const sk =
+*   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
+* const sig =
+*   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
+*
+* const wallet = fromSecretKey(sk, type);
+* const message = 'data to sign';
+* const signature = wallet.sign(message);
+* assert.equal(signature, sig, "signature should match");
+* assert.ok(wallet.verify(message, signature), "signature should be verified");
+*/
+function fromSecretKey(sk, _type = "default") {
+	const type = DidType(_type);
+	return Wallet({
+		sk,
+		pk: getSigner(type.pk).getPublicKey(sk)
+	}, type);
 }
 /**
- * Generate a wallet from publicKey
- */
-export function fromPublicKey(pk, _type = 'default') {
-    return Wallet({ pk }, DidType(_type));
+* Generate a wallet from publicKey
+*/
+function fromPublicKey(pk, _type = "default") {
+	return Wallet({ pk }, DidType(_type));
 }
 /**
- * Generate a wallet from address (did)
- *
- * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
- */
-export function fromAddress(address) {
-    return Wallet({ address: toAddress(address) }, toTypeInfo(address));
+* Generate a wallet from address (did)
+*
+* Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
+*/
+function fromAddress(address) {
+	return Wallet({ address: toAddress(address) }, toTypeInfo(address));
 }
 /**
- * Generate a wallet by generating a random secretKey
- */
-export function fromRandom(_type = 'default') {
-    const type = DidType(_type);
-    const signer = getSigner(type.pk);
-    const keyPair = signer.genKeyPair();
-    return Wallet({ sk: keyPair.secretKey, pk: keyPair.publicKey }, type);
+* Generate a wallet by generating a random secretKey
+*/
+function fromRandom(_type = "default") {
+	const type = DidType(_type);
+	const keyPair = getSigner(type.pk).genKeyPair();
+	return Wallet({
+		sk: keyPair.secretKey,
+		pk: keyPair.publicKey
+	}, type);
 }
 /**
- * Generating a wallet from a serialized json presentation of another wallet
- */
-export function fromJSON(json) {
-    const type = DidType.fromJSON(json.type);
-    // @ts-ignore
-    return Wallet(json, type);
+* Generating a wallet from a serialized json presentation of another wallet
+*/
+function fromJSON(json) {
+	return Wallet(json, DidType.fromJSON(json.type));
 }
 /**
- * Check if an object is valid wallet object
- */
-export function isValid(wallet, canSign = true) {
-    if (!wallet || typeof wallet !== 'object') {
-        return false;
-    }
-    if (typeof wallet.verify !== 'function') {
-        return false;
-    }
-    if (typeof wallet.toAddress !== 'function') {
-        return false;
-    }
-    if (typeof wallet.toJSON !== 'function') {
-        return false;
-    }
-    if (!wallet.type || !wallet.publicKey) {
-        return false;
-    }
-    if (canSign) {
-        if (typeof wallet.sign !== 'function') {
-            return false;
-        }
-    }
-    return true;
+* Check if an object is valid wallet object
+*/
+function isValid(wallet, canSign = true) {
+	if (!wallet || typeof wallet !== "object") return false;
+	if (typeof wallet.verify !== "function") return false;
+	if (typeof wallet.toAddress !== "function") return false;
+	if (typeof wallet.toJSON !== "function") return false;
+	if (!wallet.type || !wallet.publicKey) return false;
+	if (canSign) {
+		if (typeof wallet.sign !== "function") return false;
+	}
+	return true;
 }
+
+//#endregion
+export { Wallet, WalletType, fromAddress, fromJSON, fromPublicKey, fromRandom, fromSecretKey, isValid };

package/lib/_virtual/rolldown_runtime.js

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/lib/index.d.ts

@@ -1,52 +1,54 @@
-import { EncodingType, BytesType } from '@ocap/util';
-import { DidType, DIDType, DIDTypeStr, DIDTypeArg } from '@arcblock/did';
+import { BytesType, EncodingType } from "@ocap/util";
+import { DIDType, DIDTypeArg, DIDTypeStr, DidType } from "@arcblock/did";
+
+//#region src/index.d.ts
 type KeyPairType<T extends BytesType = string> = {
-    sk?: T;
-    pk?: T;
-    address?: string;
+  sk?: T;
+  pk?: T;
+  address?: string;
 };
-export type SerializedWallet = {
-    type: DIDTypeStr;
-    pk: string;
-    sk: string;
-    address: string;
+type SerializedWallet = {
+  type: DIDTypeStr;
+  pk: string;
+  sk: string;
+  address: string;
 };
-export interface WalletObject<T extends BytesType = string> {
-    type: DIDType;
-    secretKey: T;
-    publicKey: T;
-    address: string;
-    hash(data: BytesType, round?: number, encoding?: 'hex'): string;
-    hash(data: BytesType, round?: number, encoding?: 'base16'): string;
-    hash(data: BytesType, round?: number, encoding?: 'base58'): string;
-    hash(data: BytesType, round?: number, encoding?: 'base64'): string;
-    hash(data: BytesType, round?: number, encoding?: 'buffer'): Buffer;
-    hash(data: BytesType, round?: number, encoding?: 'Uint8Array'): Uint8Array;
-    hash(data: BytesType, round?: number, encoding?: EncodingType): BytesType;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'hex'): Promise<string>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base16'): Promise<string>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base58'): Promise<string>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base64'): Promise<string>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'buffer'): Promise<Buffer>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Promise<Uint8Array>;
-    sign(data: BytesType, hashBeforeSign?: boolean, encoding?: EncodingType): Promise<BytesType>;
-    verify(data: BytesType, signature: BytesType, hashBeforeVerify?: boolean, extra?: any): Promise<boolean>;
-    ethHash(data: string): string;
-    ethSign(data: string, hashBeforeSign?: boolean): Promise<string>;
-    ethVerify(data: string, signature: string, hashBeforeVerify?: boolean): Promise<boolean>;
-    signETH(data: string, hashBeforeSign?: boolean): Promise<string>;
-    signJWT(payload?: any, doSign?: boolean, version?: string): Promise<string>;
-    toJSON(): SerializedWallet;
-    /**
-     * @deprecated ES6: use `wallet.address` instead
-     */
-    toAddress(): string;
+interface WalletObject<T extends BytesType = string> {
+  type: DIDType;
+  secretKey: T;
+  publicKey: T;
+  address: string;
+  hash(data: BytesType, round?: number, encoding?: 'hex'): string;
+  hash(data: BytesType, round?: number, encoding?: 'base16'): string;
+  hash(data: BytesType, round?: number, encoding?: 'base58'): string;
+  hash(data: BytesType, round?: number, encoding?: 'base64'): string;
+  hash(data: BytesType, round?: number, encoding?: 'buffer'): Buffer;
+  hash(data: BytesType, round?: number, encoding?: 'Uint8Array'): Uint8Array;
+  hash(data: BytesType, round?: number, encoding?: EncodingType): BytesType;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'hex'): Promise<string>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base16'): Promise<string>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base58'): Promise<string>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base64'): Promise<string>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'buffer'): Promise<Buffer>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Promise<Uint8Array>;
+  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: EncodingType): Promise<BytesType>;
+  verify(data: BytesType, signature: BytesType, hashBeforeVerify?: boolean, extra?: any): Promise<boolean>;
+  ethHash(data: string): string;
+  ethSign(data: string, hashBeforeSign?: boolean): Promise<string>;
+  ethVerify(data: string, signature: string, hashBeforeVerify?: boolean): Promise<boolean>;
+  signETH(data: string, hashBeforeSign?: boolean): Promise<string>;
+  signJWT(payload?: any, doSign?: boolean, version?: string): Promise<string>;
+  toJSON(): SerializedWallet;
+  /**
+   * @deprecated ES6: use `wallet.address` instead
+   */
+  toAddress(): string;
 }
-export declare const WalletType: typeof DidType;
+declare const WalletType: typeof DidType;
 /**
  * Generate an wallet instance that can be used to sign a message or verify a signature
  */
-export declare function Wallet<T extends BytesType = string>(keyPair: KeyPairType<T>, t?: DIDTypeArg): WalletObject<T>;
+declare function Wallet<T extends BytesType = string>(keyPair: KeyPairType<T>, t?: DIDTypeArg): WalletObject<T>;
 /**
  * Generate a wallet from secretKey
  *
@@ -65,27 +67,28 @@ export declare function Wallet<T extends BytesType = string>(keyPair: KeyPairTyp
  * assert.equal(signature, sig, "signature should match");
  * assert.ok(wallet.verify(message, signature), "signature should be verified");
  */
-export declare function fromSecretKey<T extends BytesType = string>(sk: T, _type?: DIDTypeArg): WalletObject<T>;
+declare function fromSecretKey<T extends BytesType = string>(sk: T, _type?: DIDTypeArg): WalletObject<T>;
 /**
  * Generate a wallet from publicKey
  */
-export declare function fromPublicKey<T extends BytesType = string>(pk: T, _type?: DIDTypeArg): WalletObject<T>;
+declare function fromPublicKey<T extends BytesType = string>(pk: T, _type?: DIDTypeArg): WalletObject<T>;
 /**
  * Generate a wallet from address (did)
  *
  * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
  */
-export declare function fromAddress<T extends BytesType = string>(address: string): WalletObject<T>;
+declare function fromAddress<T extends BytesType = string>(address: string): WalletObject<T>;
 /**
  * Generate a wallet by generating a random secretKey
  */
-export declare function fromRandom<T extends BytesType = string>(_type?: DIDTypeArg): WalletObject<T>;
+declare function fromRandom<T extends BytesType = string>(_type?: DIDTypeArg): WalletObject<T>;
 /**
  * Generating a wallet from a serialized json presentation of another wallet
  */
-export declare function fromJSON<T extends BytesType = string>(json: SerializedWallet): WalletObject<T>;
+declare function fromJSON<T extends BytesType = string>(json: SerializedWallet): WalletObject<T>;
 /**
  * Check if an object is valid wallet object
  */
-export declare function isValid(wallet: WalletObject, canSign?: boolean): boolean;
-export {};
+declare function isValid(wallet: WalletObject, canSign?: boolean): boolean;
+//#endregion
+export { SerializedWallet, Wallet, WalletObject, WalletType, fromAddress, fromJSON, fromPublicKey, fromRandom, fromSecretKey, isValid };

package/lib/index.js

@@ -1,205 +1,152 @@
-"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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WalletType = void 0;
-exports.Wallet = Wallet;
-exports.fromSecretKey = fromSecretKey;
-exports.fromPublicKey = fromPublicKey;
-exports.fromAddress = fromAddress;
-exports.fromRandom = fromRandom;
-exports.fromJSON = fromJSON;
-exports.isValid = isValid;
-const util_1 = require("@ocap/util");
-const mcrypto_1 = require("@ocap/mcrypto");
-const did_1 = require("@arcblock/did");
-const JWT = __importStar(require("@arcblock/jwt"));
-exports.WalletType = did_1.DidType;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let _ocap_util = require("@ocap/util");
+let _ocap_mcrypto = require("@ocap/mcrypto");
+let _arcblock_did = require("@arcblock/did");
+let _arcblock_jwt = require("@arcblock/jwt");
+_arcblock_jwt = require_rolldown_runtime.__toESM(_arcblock_jwt);
+
+//#region src/index.ts
+const WalletType = _arcblock_did.DidType;
 /**
- * Generate an wallet instance that can be used to sign a message or verify a signature
- */
-function Wallet(keyPair, t = 'default') {
-    const type = (0, did_1.DidType)(t);
-    const signer = (0, mcrypto_1.getSigner)(type.pk);
-    const hasher = (0, mcrypto_1.getHasher)(type.hash);
-    return {
-        type,
-        secretKey: keyPair.sk,
-        publicKey: keyPair.pk,
-        address: keyPair.pk ? (0, did_1.fromPublicKey)(keyPair.pk, type) : keyPair.address,
-        // @ts-ignore
-        hash(data, round = 1, encoding = 'hex') {
-            return hasher(data, round, encoding);
-        },
-        // @ts-ignore
-        // eslint-disable-next-line require-await
-        async sign(data, hashBeforeSign = true, encoding = 'hex') {
-            if (!keyPair.sk) {
-                throw new Error('Cannot sign data without a secretKey');
-            }
-            if (hashBeforeSign) {
-                const hash = hasher(data, 1);
-                return signer.sign(hash, keyPair.sk, encoding);
-            }
-            return signer.sign(data, keyPair.sk, encoding);
-        },
-        // eslint-disable-next-line require-await
-        async verify(data, signature, hashBeforeVerify = true, extra) {
-            if (!keyPair.pk) {
-                throw new Error('Cannot verify data without a publicKey');
-            }
-            const hash = hashBeforeVerify ? hasher(data, 1) : data;
-            return signer.verify(hash, signature, keyPair.pk, extra);
-        },
-        ethHash(data) {
-            if (typeof signer.ethHash !== 'function') {
-                throw new Error('ethHash is not supported by signer');
-            }
-            return signer.ethHash(data);
-        },
-        // eslint-disable-next-line require-await
-        async signETH(data, hashBeforeSign = true) {
-            if (!keyPair.sk) {
-                throw new Error('Cannot sign data without a secretKey');
-            }
-            if (typeof signer.ethHash !== 'function') {
-                throw new Error('ethSign is not supported by signer');
-            }
-            if (hashBeforeSign) {
-                return signer.ethSign(signer.ethHash(data), (0, util_1.toHex)(keyPair.sk));
-            }
-            return signer.ethSign(data, (0, util_1.toHex)(keyPair.sk));
-        },
-        ethSign(data, hashBeforeSign = true) {
-            return this.signETH(data, hashBeforeSign);
-        },
-        // eslint-disable-next-line require-await
-        async ethVerify(data, signature, hashBeforeVerify = true) {
-            if (typeof signer.ethHash !== 'function') {
-                throw new Error('ethVerify is not supported by signer');
-            }
-            const hash = hashBeforeVerify ? signer.ethHash(data) : data;
-            return signer.ethRecover(hash, signature) === this.address;
-        },
-        // eslint-disable-next-line require-await
-        async signJWT(payload = {}, doSign = true, version = '1.0.0') {
-            if (!keyPair.sk) {
-                throw new Error('Cannot sign JWT without a secretKey');
-            }
-            return JWT.sign(this.address, keyPair.sk, payload, doSign, version);
-        },
-        // deprecated
-        toAddress() {
-            return keyPair.pk ? (0, did_1.fromPublicKey)(keyPair.pk, type) : keyPair.address;
-        },
-        toJSON() {
-            return {
-                type: did_1.DidType.toJSON(type),
-                sk: (0, util_1.toHex)(keyPair.sk),
-                pk: (0, util_1.toHex)(keyPair.pk),
-                address: this.address,
-            };
-        },
-    };
+* Generate an wallet instance that can be used to sign a message or verify a signature
+*/
+function Wallet(keyPair, t = "default") {
+	const type = (0, _arcblock_did.DidType)(t);
+	const signer = (0, _ocap_mcrypto.getSigner)(type.pk);
+	const hasher = (0, _ocap_mcrypto.getHasher)(type.hash);
+	return {
+		type,
+		secretKey: keyPair.sk,
+		publicKey: keyPair.pk,
+		address: keyPair.pk ? (0, _arcblock_did.fromPublicKey)(keyPair.pk, type) : keyPair.address,
+		hash(data, round = 1, encoding = "hex") {
+			return hasher(data, round, encoding);
+		},
+		async sign(data, hashBeforeSign = true, encoding = "hex") {
+			if (!keyPair.sk) throw new Error("Cannot sign data without a secretKey");
+			if (hashBeforeSign) {
+				const hash = hasher(data, 1);
+				return signer.sign(hash, keyPair.sk, encoding);
+			}
+			return signer.sign(data, keyPair.sk, encoding);
+		},
+		async verify(data, signature, hashBeforeVerify = true, extra) {
+			if (!keyPair.pk) throw new Error("Cannot verify data without a publicKey");
+			const hash = hashBeforeVerify ? hasher(data, 1) : data;
+			return signer.verify(hash, signature, keyPair.pk, extra);
+		},
+		ethHash(data) {
+			if (typeof signer.ethHash !== "function") throw new Error("ethHash is not supported by signer");
+			return signer.ethHash(data);
+		},
+		async signETH(data, hashBeforeSign = true) {
+			if (!keyPair.sk) throw new Error("Cannot sign data without a secretKey");
+			if (typeof signer.ethHash !== "function") throw new Error("ethSign is not supported by signer");
+			if (hashBeforeSign) return signer.ethSign(signer.ethHash(data), (0, _ocap_util.toHex)(keyPair.sk));
+			return signer.ethSign(data, (0, _ocap_util.toHex)(keyPair.sk));
+		},
+		ethSign(data, hashBeforeSign = true) {
+			return this.signETH(data, hashBeforeSign);
+		},
+		async ethVerify(data, signature, hashBeforeVerify = true) {
+			if (typeof signer.ethHash !== "function") throw new Error("ethVerify is not supported by signer");
+			const hash = hashBeforeVerify ? signer.ethHash(data) : data;
+			return signer.ethRecover(hash, signature) === this.address;
+		},
+		async signJWT(payload = {}, doSign = true, version = "1.0.0") {
+			if (!keyPair.sk) throw new Error("Cannot sign JWT without a secretKey");
+			return _arcblock_jwt.sign(this.address, keyPair.sk, payload, doSign, version);
+		},
+		toAddress() {
+			return keyPair.pk ? (0, _arcblock_did.fromPublicKey)(keyPair.pk, type) : keyPair.address;
+		},
+		toJSON() {
+			return {
+				type: _arcblock_did.DidType.toJSON(type),
+				sk: (0, _ocap_util.toHex)(keyPair.sk),
+				pk: (0, _ocap_util.toHex)(keyPair.pk),
+				address: this.address
+			};
+		}
+	};
 }
 /**
- * Generate a wallet from secretKey
- *
- * @example
- * const assert = require('assert');
- * const { fromSecretKey } = require('@ocap/wallet');
- *
- * const sk =
- *   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
- * const sig =
- *   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
- *
- * const wallet = fromSecretKey(sk, type);
- * const message = 'data to sign';
- * const signature = wallet.sign(message);
- * assert.equal(signature, sig, "signature should match");
- * assert.ok(wallet.verify(message, signature), "signature should be verified");
- */
-function fromSecretKey(sk, _type = 'default') {
-    const type = (0, did_1.DidType)(_type);
-    const keyPair = { sk, pk: (0, mcrypto_1.getSigner)(type.pk).getPublicKey(sk) };
-    return Wallet(keyPair, type);
+* Generate a wallet from secretKey
+*
+* @example
+* const assert = require('assert');
+* const { fromSecretKey } = require('@ocap/wallet');
+*
+* const sk =
+*   '0xD67C071B6F51D2B61180B9B1AA9BE0DD0704619F0E30453AB4A592B036EDE644E4852B7091317E3622068E62A5127D1FB0D4AE2FC50213295E10652D2F0ABFC7';
+* const sig =
+*   '0x08a102851c38c072e42756c1cc70938b5499c8e9358dfe5f383823f56cdb282ffda60fcd581a02c6c673069e5afc0bf09abbe3639b61b84d64fd58ef9f083003';
+*
+* const wallet = fromSecretKey(sk, type);
+* const message = 'data to sign';
+* const signature = wallet.sign(message);
+* assert.equal(signature, sig, "signature should match");
+* assert.ok(wallet.verify(message, signature), "signature should be verified");
+*/
+function fromSecretKey(sk, _type = "default") {
+	const type = (0, _arcblock_did.DidType)(_type);
+	return Wallet({
+		sk,
+		pk: (0, _ocap_mcrypto.getSigner)(type.pk).getPublicKey(sk)
+	}, type);
 }
 /**
- * Generate a wallet from publicKey
- */
-function fromPublicKey(pk, _type = 'default') {
-    return Wallet({ pk }, (0, did_1.DidType)(_type));
+* Generate a wallet from publicKey
+*/
+function fromPublicKey(pk, _type = "default") {
+	return Wallet({ pk }, (0, _arcblock_did.DidType)(_type));
 }
 /**
- * Generate a wallet from address (did)
- *
- * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
- */
+* Generate a wallet from address (did)
+*
+* Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
+*/
 function fromAddress(address) {
-    return Wallet({ address: (0, did_1.toAddress)(address) }, (0, did_1.toTypeInfo)(address));
+	return Wallet({ address: (0, _arcblock_did.toAddress)(address) }, (0, _arcblock_did.toTypeInfo)(address));
 }
 /**
- * Generate a wallet by generating a random secretKey
- */
-function fromRandom(_type = 'default') {
-    const type = (0, did_1.DidType)(_type);
-    const signer = (0, mcrypto_1.getSigner)(type.pk);
-    const keyPair = signer.genKeyPair();
-    return Wallet({ sk: keyPair.secretKey, pk: keyPair.publicKey }, type);
+* Generate a wallet by generating a random secretKey
+*/
+function fromRandom(_type = "default") {
+	const type = (0, _arcblock_did.DidType)(_type);
+	const keyPair = (0, _ocap_mcrypto.getSigner)(type.pk).genKeyPair();
+	return Wallet({
+		sk: keyPair.secretKey,
+		pk: keyPair.publicKey
+	}, type);
 }
 /**
- * Generating a wallet from a serialized json presentation of another wallet
- */
+* Generating a wallet from a serialized json presentation of another wallet
+*/
 function fromJSON(json) {
-    const type = did_1.DidType.fromJSON(json.type);
-    // @ts-ignore
-    return Wallet(json, type);
+	return Wallet(json, _arcblock_did.DidType.fromJSON(json.type));
 }
 /**
- * Check if an object is valid wallet object
- */
+* Check if an object is valid wallet object
+*/
 function isValid(wallet, canSign = true) {
-    if (!wallet || typeof wallet !== 'object') {
-        return false;
-    }
-    if (typeof wallet.verify !== 'function') {
-        return false;
-    }
-    if (typeof wallet.toAddress !== 'function') {
-        return false;
-    }
-    if (typeof wallet.toJSON !== 'function') {
-        return false;
-    }
-    if (!wallet.type || !wallet.publicKey) {
-        return false;
-    }
-    if (canSign) {
-        if (typeof wallet.sign !== 'function') {
-            return false;
-        }
-    }
-    return true;
+	if (!wallet || typeof wallet !== "object") return false;
+	if (typeof wallet.verify !== "function") return false;
+	if (typeof wallet.toAddress !== "function") return false;
+	if (typeof wallet.toJSON !== "function") return false;
+	if (!wallet.type || !wallet.publicKey) return false;
+	if (canSign) {
+		if (typeof wallet.sign !== "function") return false;
+	}
+	return true;
 }
+
+//#endregion
+exports.Wallet = Wallet;
+exports.WalletType = WalletType;
+exports.fromAddress = fromAddress;
+exports.fromJSON = fromJSON;
+exports.fromPublicKey = fromPublicKey;
+exports.fromRandom = fromRandom;
+exports.fromSecretKey = fromSecretKey;
+exports.isValid = isValid;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ocap/wallet",
-  "version": "1.27.15",
+  "version": "1.28.0",
   "description": "Utility function to create and use an forge compatible crypto wallet",
   "keywords": [
     "crypto",
@@ -20,8 +20,22 @@
   ],
   "homepage": "https://www.arcblock.io/docs/blockchain-utils",
   "license": "Apache-2.0",
+  "sideEffects": false,
   "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
+  "module": "./esm/index.js",
+  "types": "./esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./esm/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      }
+    }
+  },
   "files": [
     "lib",
     "esm"
@@ -33,6 +47,7 @@
     "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
+    "tsdown": "^0.18.4",
     "typescript": "^5.6.2"
   },
   "repository": {
@@ -43,21 +58,17 @@
     "url": "https://github.com/ArcBlock/blockchain/issues"
   },
   "dependencies": {
-    "@arcblock/did": "1.27.15",
-    "@arcblock/jwt": "1.27.15",
-    "@ocap/mcrypto": "1.27.15",
-    "@ocap/util": "1.27.15"
+    "@arcblock/did": "1.28.0",
+    "@arcblock/jwt": "1.28.0",
+    "@ocap/mcrypto": "1.28.0",
+    "@ocap/util": "1.28.0"
   },
   "scripts": {
     "lint": "eslint tests src",
     "lint:fix": "eslint --fix tests src",
     "test": "jest --forceExit --detectOpenHandles",
     "coverage": "npm run test -- --coverage",
-    "clean": "rm -fr lib esm",
-    "prebuild": "npm run clean",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:esm": "tsc -p tsconfig.esm.json",
-    "build": "npm run build:cjs && npm run build:esm",
-    "build:watch": "npm run build -- -w"
+    "build": "tsdown",
+    "build:watch": "tsdown --watch"
   }
 }