@arcblock/event-hub 1.28.8 → 1.29.0

package/esm/client.d.mts

@@ -0,0 +1,43 @@
+import { EventEmitter } from "node:events";
+import { fromSecretKey } from "@ocap/wallet";
+import axon from "axon";
+
+//#region src/client.d.ts
+interface ClientOptions {
+  port?: number;
+  hostname?: string;
+  autoConnect?: boolean;
+  wallet?: ReturnType<typeof fromSecretKey>;
+  did?: string;
+  sk?: string;
+}
+declare class Socket extends axon.SubEmitterSocket {
+  _authenticated: boolean;
+  _pendingMessages: [string, unknown][];
+  _wallet: ReturnType<typeof fromSecretKey>;
+  send: (event: string, data: unknown) => void;
+  constructor(opts: ClientOptions);
+}
+declare class Client extends EventEmitter {
+  opts: ClientOptions & {
+    wallet: ReturnType<typeof fromSecretKey>;
+    did: string;
+  };
+  _client: Socket;
+  _wallet: ReturnType<typeof fromSecretKey>;
+  constructor(opts?: ClientOptions);
+  connect(): void;
+  close(): void;
+  broadcast(event: string, data: unknown): void;
+  on(name: string, fn: (...args: unknown[]) => void): this;
+  off(name: string, fn?: (...args: unknown[]) => void): this;
+  /**
+   * Get the wallet instance
+   * Business can override wallet.signJWT() for remote signing
+   * @returns {WalletObject}
+   */
+  getWallet(): ReturnType<typeof fromSecretKey>;
+  _bindEvent(): void;
+}
+//#endregion
+export { Client as default };

package/esm/client.mjs

@@ -0,0 +1,134 @@
+import { EVENT_AUTH, EVENT_AUTH_FAIL, EVENT_AUTH_SUCCESS, RESERVED_EVENT_PREFIX } from "./constant.mjs";
+import { EventEmitter } from "node:events";
+import { DidType, isEthereumType, toTypeInfo } from "@arcblock/did";
+import { WalletType, fromSecretKey } from "@ocap/wallet";
+import axon from "axon";
+import queue from "axon/lib/plugins/queue.js";
+import roundrobin from "axon/lib/plugins/round-robin.js";
+
+//#region src/client.ts
+const checkEvent = (event) => {
+	if (event.startsWith(RESERVED_EVENT_PREFIX)) throw new Error(`event cannot start with ${RESERVED_EVENT_PREFIX}`);
+};
+const getWallet = (appSk, type) => {
+	let t = type;
+	let sk = appSk;
+	if (isEthereumType(DidType(type))) {
+		sk = appSk.slice(0, 66);
+		t = WalletType(type);
+	}
+	return fromSecretKey(sk, t);
+};
+const defaultOpts = {
+	port: void 0,
+	hostname: "0.0.0.0",
+	autoConnect: false,
+	wallet: void 0,
+	did: void 0,
+	sk: void 0
+};
+var Socket = class extends axon.SubEmitterSocket {
+	constructor(opts) {
+		super();
+		const wallet = opts.wallet || getWallet(opts.sk, toTypeInfo(opts.did));
+		this._authenticated = false;
+		this._pendingMessages = [];
+		this._wallet = wallet;
+		this.sock.use((sock) => {
+			sock.on("connect", async () => {
+				this._authenticated = false;
+				const token = await wallet.signJWT();
+				sock.send(EVENT_AUTH, {
+					pk: wallet.publicKey,
+					token
+				});
+			});
+			sock.on("close", () => {
+				this._authenticated = false;
+				this._pendingMessages = [];
+			});
+		});
+		this.on(EVENT_AUTH_SUCCESS, () => {
+			this._authenticated = true;
+			const pending = this._pendingMessages.slice();
+			this._pendingMessages = [];
+			pending.forEach(([event, data]) => this.sock.send(event, data));
+		});
+		this.on(EVENT_AUTH_FAIL, ({ msg } = {}) => {
+			this.emit("error", { msg });
+			this._authenticated = false;
+			this._pendingMessages = [];
+			this.sock.socks.forEach((s) => s.close());
+		});
+		this.sock.use(queue());
+		this.sock.use(roundrobin({ fallback: this.sock.enqueue }));
+		const originalSend = this.sock.send.bind(this.sock);
+		this.send = (event, data) => {
+			const hasConnection = this.sock.socks && this.sock.socks.length > 0;
+			if (this._authenticated && hasConnection) originalSend(event, data);
+			else this._pendingMessages.push([event, data]);
+		};
+	}
+};
+var Client = class extends EventEmitter {
+	constructor(opts = {}) {
+		super();
+		if (!opts.port) throw new Error("port should not be empty");
+		if (!opts.wallet) {
+			if (!opts.did) throw new Error("did should not be empty when wallet is not provided");
+			if (!opts.sk) throw new Error("Either wallet or sk should be provided");
+		}
+		const wallet = opts.wallet || getWallet(opts.sk, toTypeInfo(opts.did));
+		const did = opts.wallet ? opts.wallet.address : opts.did;
+		if (wallet.address !== did) throw new Error("did does not match the provided wallet/sk");
+		this.opts = Object.assign({}, defaultOpts, opts, {
+			wallet,
+			did
+		});
+		this._client = new Socket(this.opts);
+		this._wallet = wallet;
+		this._bindEvent();
+		if (this.opts.autoConnect) this.connect();
+	}
+	connect() {
+		const { port, hostname } = this.opts;
+		this._client.connect(port, hostname);
+	}
+	close() {
+		this._client._authenticated = false;
+		this._client._pendingMessages = [];
+		this._client.close();
+	}
+	broadcast(event, data) {
+		checkEvent(event);
+		this._client.send(event, data);
+	}
+	on(name, fn) {
+		checkEvent(name);
+		super.on(name, fn);
+		this._client.on(name, fn);
+		return this;
+	}
+	off(name, fn) {
+		checkEvent(name);
+		this._client.off(name);
+		if (fn) super.off(name, fn);
+		else super.removeAllListeners(name);
+		return this;
+	}
+	/**
+	* Get the wallet instance
+	* Business can override wallet.signJWT() for remote signing
+	* @returns {WalletObject}
+	*/
+	getWallet() {
+		return this._wallet;
+	}
+	_bindEvent() {
+		this._client.on("error", this.emit.bind(this, "error"));
+	}
+};
+var client_default = Client;
+
+//#endregion
+export { client_default as default };

package/esm/constant.d.mts

@@ -0,0 +1,7 @@
+//#region src/constant.d.ts
+declare const RESERVED_EVENT_PREFIX = "EVENT_HUB:";
+declare const EVENT_AUTH = "EVENT_HUB:AUTH";
+declare const EVENT_AUTH_SUCCESS = "EVENT_HUB:AUTH_SUCCESS";
+declare const EVENT_AUTH_FAIL = "EVENT_HUB:AUTH_FAIL";
+//#endregion
+export { EVENT_AUTH, EVENT_AUTH_FAIL, EVENT_AUTH_SUCCESS, RESERVED_EVENT_PREFIX };

package/esm/constant.mjs

@@ -0,0 +1,8 @@
+//#region src/constant.ts
+const RESERVED_EVENT_PREFIX = "EVENT_HUB:";
+const EVENT_AUTH = "EVENT_HUB:AUTH";
+const EVENT_AUTH_SUCCESS = "EVENT_HUB:AUTH_SUCCESS";
+const EVENT_AUTH_FAIL = "EVENT_HUB:AUTH_FAIL";
+
+//#endregion
+export { EVENT_AUTH, EVENT_AUTH_FAIL, EVENT_AUTH_SUCCESS, RESERVED_EVENT_PREFIX };

package/esm/index.d.mts

@@ -0,0 +1,7 @@
+import Client from "./client.mjs";
+import { Client as Client$1 } from "./single.mjs";
+
+//#region src/index.d.ts
+declare let defaultExport: Client | Client$1;
+//#endregion
+export { Client, Client$1 as ClientFallback, defaultExport as default };

package/esm/index.mjs

@@ -0,0 +1,28 @@
+import client_default from "./client.mjs";
+import { Client } from "./single.mjs";
+
+//#region src/index.ts
+const port = Number(process.env.ABT_NODE_EVENT_PORT);
+const hostname = process.env.ABT_NODE_EVENT_HOSTNAME || "127.0.0.1";
+let did;
+let sk;
+if (process.env.BLOCKLET_APP_SK && process.env.BLOCKLET_APP_ID) {
+	sk = process.env.BLOCKLET_APP_SK;
+	did = process.env.BLOCKLET_APP_ID;
+} else if (process.env.ABT_NODE_SK && process.env.ABT_NODE_DID) {
+	sk = process.env.ABT_NODE_SK;
+	did = process.env.ABT_NODE_DID;
+}
+let defaultExport;
+if (port && did && sk) defaultExport = new client_default({
+	port,
+	hostname,
+	did,
+	sk,
+	autoConnect: true
+});
+else defaultExport = new Client();
+var src_default = defaultExport;
+
+//#endregion
+export { client_default as Client, Client as ClientFallback, src_default as default };

package/esm/rpc.d.mts

@@ -0,0 +1,51 @@
+import axon from "axon";
+
+//#region src/rpc.d.ts
+interface InflightEntry {
+  resolve: (value: unknown) => void;
+  reject: (reason: Error) => void;
+  to: ReturnType<typeof setTimeout>;
+  errorPrefix?: string;
+}
+interface RpcOptions {
+  timeoutMs?: number;
+  respEvent?: string;
+  errorPrefix?: string;
+}
+interface SocketLike {
+  writable: boolean;
+  write(buf: Buffer): void;
+}
+declare class Client extends axon.Socket {
+  socks: SocketLike[];
+  port: number;
+  host: string;
+  online: boolean;
+  connectPromise: Promise<this> | null;
+  inflight: Map<string, InflightEntry>;
+  /**
+   * @param {number} port
+   * @param {string} host
+   */
+  constructor(port: number, host?: string);
+  onmessage(): (buf: Buffer) => void;
+  sendEvent(event: string, data: unknown): void;
+  ensureOnline(): Promise<this>;
+  /**
+   * 通用 RPC：发送 event，等待响应（默认只按 reqId 匹配）
+   * @param {string} event           例如 'pm2/start'
+   * @param {object} payload         发送为 { reqId, payload }
+   * @param {object} [opts]
+   * @param {number} [opts.timeoutMs=120000]
+   * @param {string} [opts.respEvent]  // 可选：仅用于调试；匹配靠 reqId，不强依赖此项
+   * @param {string} [opts.errorPrefix] // 统一错误前缀
+   * @returns {Promise<any>}
+   */
+  rpc(event: string, payload?: unknown, {
+    timeoutMs,
+    respEvent,
+    errorPrefix
+  }?: RpcOptions): Promise<unknown>;
+}
+//#endregion
+export { Client as default };

package/esm/rpc.mjs

@@ -0,0 +1,106 @@
+import axon from "axon";
+import { randomUUID } from "node:crypto";
+import Message from "amp-message";
+
+//#region src/rpc.ts
+var Client = class extends axon.Socket {
+	/**
+	* @param {number} port
+	* @param {string} host
+	*/
+	constructor(port, host = "127.0.0.1") {
+		super();
+		this.port = port;
+		this.host = host;
+		this.online = false;
+		this.connectPromise = null;
+		this.inflight = /* @__PURE__ */ new Map();
+		this.on("connect", () => {
+			this.online = true;
+		});
+		this.on("reconnect attempt", () => {
+			this.online = false;
+		});
+		this.on("disconnect", () => {
+			this.online = false;
+		});
+		this.on("error", () => {});
+	}
+	onmessage() {
+		return (buf) => {
+			try {
+				const [event, data] = new Message(buf).args;
+				if (data && typeof data === "object" && data.reqId) {
+					const entry = this.inflight.get(data.reqId);
+					if (entry) {
+						clearTimeout(entry.to);
+						this.inflight.delete(data.reqId);
+						if (data.ok === false) entry.reject(new Error(entry.errorPrefix ? `${entry.errorPrefix}: ${data.error}` : data.error || "request failed"));
+						else entry.resolve(data.data);
+						return;
+					}
+				}
+				this.emit(event, data);
+			} catch (e) {
+				console.error("[axon] decode error", e);
+			}
+		};
+	}
+	sendEvent(event, data) {
+		const buf = this.pack([event, data]);
+		const s = this.socks[0];
+		if (s?.writable) s.write(buf);
+		else throw new Error("axon socket not writable/connected");
+	}
+	async ensureOnline() {
+		if (!this.port || !this.host) throw new Error("PORT and HOST must be set via constructor: new Client(port, host)");
+		if (!this.connectPromise) this.connectPromise = new Promise((resolve, reject) => {
+			this.connect(this.port, this.host, (err) => err ? reject(err) : resolve(this));
+		});
+		await this.connectPromise;
+		if (this.online) return this;
+		await new Promise((r) => this.once("connect", r));
+		return this;
+	}
+	/**
+	* 通用 RPC：发送 event，等待响应（默认只按 reqId 匹配）
+	* @param {string} event           例如 'pm2/start'
+	* @param {object} payload         发送为 { reqId, payload }
+	* @param {object} [opts]
+	* @param {number} [opts.timeoutMs=120000]
+	* @param {string} [opts.respEvent]  // 可选：仅用于调试；匹配靠 reqId，不强依赖此项
+	* @param {string} [opts.errorPrefix] // 统一错误前缀
+	* @returns {Promise<any>}
+	*/
+	async rpc(event, payload = {}, { timeoutMs = 12e4, respEvent, errorPrefix } = {}) {
+		await this.ensureOnline();
+		const reqId = randomUUID();
+		return new Promise((resolve, reject) => {
+			const to = setTimeout(() => {
+				this.inflight.delete(reqId);
+				reject(/* @__PURE__ */ new Error(`${errorPrefix || "request"} timeout`));
+			}, timeoutMs);
+			this.inflight.set(reqId, {
+				resolve,
+				reject,
+				to,
+				errorPrefix
+			});
+			this.sendEvent(event, {
+				reqId,
+				payload
+			});
+			if (respEvent) {
+				const once = (data) => {
+					if (!data || data.reqId !== reqId) return;
+					this.off(respEvent, once);
+				};
+				this.on(respEvent, once);
+			}
+		});
+	}
+};
+var rpc_default = Client;
+
+//#endregion
+export { rpc_default as default };

package/esm/server-abtnode.d.mts

@@ -0,0 +1,6 @@
+import Server from "./server.mjs";
+
+//#region src/server-abtnode.d.ts
+declare const server: Server;
+//#endregion
+export { server as default };

package/esm/server-abtnode.mjs

@@ -0,0 +1,11 @@
+import server_default from "./server.mjs";
+
+//#region src/server-abtnode.ts
+const port = Number(process.env.ABT_NODE_EVENT_PORT);
+const hostname = Number(process.env.ABT_NODE_EVENT_HOSTNAME) || "127.0.0.1";
+const server = new server_default();
+server.bind(port, hostname);
+var server_abtnode_default = server;
+
+//#endregion
+export { server_abtnode_default as default };

package/esm/server.d.mts

@@ -0,0 +1,55 @@
+import axon from "axon";
+
+//#region src/server.d.ts
+interface JwtLike {
+  verify(token: string, pk: string): Promise<boolean>;
+  decode(token: string): {
+    iss: string;
+  };
+}
+interface ServerOptions {
+  jwt?: JwtLike;
+}
+interface SocketWithChannel {
+  channel?: string;
+  writable: boolean;
+  write(buf: Buffer): void;
+  _peername?: {
+    family: string;
+    address: string;
+    port: number;
+  };
+}
+interface RouteHandler {
+  fn: (payload: unknown, ctx: {
+    sock: SocketWithChannel;
+    channel?: string;
+    event: string;
+    server: Server;
+  }) => unknown | Promise<unknown>;
+  authRequired: boolean;
+}
+declare class Server extends axon.Socket {
+  jwt: JwtLike;
+  handlers: Map<string, RouteHandler>;
+  socks: SocketWithChannel[];
+  constructor(opts?: ServerOptions);
+  onmessage(sock: SocketWithChannel): (buf: Buffer) => void;
+  send(event: string, data: unknown, channel: string): this;
+  /**
+   * 注册路由
+   * @param {string} event
+   * @param {(payload:any, ctx:{sock:any, channel?:string, event:string, server:Server})=>any|Promise<any>} handler
+   * @param {{authRequired?: boolean}} [opts] - 默认 true；设为 false 则该事件免鉴权
+   */
+  register(event: string, handler: (payload: unknown, ctx: {
+    sock: SocketWithChannel;
+    channel?: string;
+    event: string;
+    server: Server;
+  }) => unknown | Promise<unknown>, opts?: {
+    authRequired?: boolean;
+  }): this;
+}
+//#endregion
+export { Server as default };

package/esm/server.mjs

@@ -0,0 +1,142 @@
+import { EVENT_AUTH, EVENT_AUTH_FAIL, EVENT_AUTH_SUCCESS } from "./constant.mjs";
+import axon from "axon";
+import Message from "amp-message";
+import * as JWT from "@arcblock/jwt";
+
+//#region src/server.ts
+const getDid = (jwt) => jwt.iss.replace(/^did:abt:/, "");
+function normalizeReq(input) {
+	if (input && typeof input === "object" && ("payload" in input || "reqId" in input)) {
+		const { reqId, payload } = input;
+		return {
+			reqId,
+			payload
+		};
+	}
+	return {
+		reqId: void 0,
+		payload: input
+	};
+}
+function normalizeRes(result) {
+	if (result && typeof result === "object" && ("ok" in result || "data" in result || "error" in result)) return result;
+	return {
+		ok: true,
+		data: result
+	};
+}
+var Server = class extends axon.Socket {
+	constructor(opts = {}) {
+		super();
+		this.jwt = opts?.jwt || JWT;
+		this.handlers = /* @__PURE__ */ new Map();
+		this.on("message", async (event, data, sock) => {
+			const route = this.handlers.get(event);
+			if (route) {
+				const { fn, authRequired } = route;
+				if (authRequired && !sock.channel) {
+					console.error(`unauthenticated socket blocked for event "${event}"`);
+					return;
+				}
+				const { reqId, payload } = normalizeReq(data);
+				try {
+					const res = normalizeRes(await fn(payload, {
+						sock,
+						channel: sock.channel,
+						event,
+						server: this
+					}));
+					const replyEvent = `${event}:res`;
+					if (sock.channel) this.send(replyEvent, {
+						reqId,
+						...res
+					}, sock.channel);
+					else {
+						const buf = this.pack([replyEvent, {
+							reqId,
+							...res
+						}]);
+						if (sock.writable) sock.write(buf);
+					}
+				} catch (err) {
+					const replyEvent = `${event}:res`;
+					const payloadErr = {
+						reqId,
+						ok: false,
+						error: err?.message || String(err)
+					};
+					if (sock.channel) this.send(replyEvent, payloadErr, sock.channel);
+					else {
+						const buf = this.pack([replyEvent, payloadErr]);
+						if (sock.writable) sock.write(buf);
+					}
+				}
+				return;
+			}
+			if (!sock.channel) {
+				console.error("skip message of unauthenticated socket");
+				return;
+			}
+			this.send(event, data, sock.channel);
+		});
+		this.on("connect", (socket) => {
+			console.log("event-hub client connected", socket._peername);
+		});
+		this.on("reconnect attempt", (socket) => {
+			console.log("event-hub client reconnect", socket._peername);
+		});
+		this.on("disconnect", (socket) => {
+			console.log("event-hub client disconnected", socket._peername);
+		});
+		this.on("drop", (args) => {
+			console.log("event-hub server drop message", args);
+		});
+		this.on("error", (err) => {
+			console.log("event-hub server error", err);
+		});
+	}
+	onmessage(sock) {
+		return (buf) => {
+			const [event, data] = new Message(buf).args;
+			if (event === EVENT_AUTH) {
+				const { pk, token } = data;
+				this.jwt.verify(token, pk).then((valid) => {
+					if (!valid) throw new Error("token verify failed");
+					sock.channel = getDid(this.jwt.decode(token));
+					const successBuf = this.pack([EVENT_AUTH_SUCCESS, {}]);
+					sock.write(successBuf);
+				}).catch((err) => {
+					console.error(err);
+					const resBuf = this.pack([EVENT_AUTH_FAIL, { msg: err.message }]);
+					sock.write(resBuf);
+				});
+				return;
+			}
+			this.emit("message", event, data, sock);
+		};
+	}
+	send(event, data, channel) {
+		const { socks } = this;
+		const buf = this.pack([event, data]);
+		for (const sock of socks) if (sock.channel === channel && sock.writable) sock.write(buf);
+		return this;
+	}
+	/**
+	* 注册路由
+	* @param {string} event
+	* @param {(payload:any, ctx:{sock:any, channel?:string, event:string, server:Server})=>any|Promise<any>} handler
+	* @param {{authRequired?: boolean}} [opts] - 默认 true；设为 false 则该事件免鉴权
+	*/
+	register(event, handler, opts = {}) {
+		const authRequired = opts.authRequired !== false;
+		this.handlers.set(event, {
+			fn: handler,
+			authRequired
+		});
+		return this;
+	}
+};
+var server_default = Server;
+
+//#endregion
+export { server_default as default };

package/esm/single.d.mts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "node:events";
+
+//#region src/single.d.ts
+declare class Client extends EventEmitter {
+  broadcast(...args: Parameters<EventEmitter['emit']>): boolean;
+  off(event: string | symbol): this;
+}
+declare const _default: Client;
+//#endregion
+export { Client, _default as default };

package/esm/single.mjs

@@ -0,0 +1,16 @@
+import { EventEmitter } from "node:events";
+
+//#region src/single.ts
+var Client = class extends EventEmitter {
+	broadcast(...args) {
+		return this.emit(...args);
+	}
+	off(event) {
+		this.removeAllListeners(event);
+		return this;
+	}
+};
+var single_default = new Client();
+
+//#endregion
+export { Client, single_default as default };

package/lib/_virtual/rolldown_runtime.cjs

@@ -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;