@ocap/message 1.28.9 → 1.29.0

package/README.md

@@ -1,6 +1,5 @@
 ![forge-message](https://www.arcblock.io/.netlify/functions/badge/?text=forge-message)
 
-[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 [![docs](https://img.shields.io/badge/powered%20by-arcblock-green.svg)](https://docs.arcblock.io)
 [![Gitter](https://badges.gitter.im/ArcBlock/community.svg)](https://gitter.im/ArcBlock/community?utm_source=badge\&utm_medium=badge\&utm_campaign=pr-badge)
 

package/esm/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __commonJSMin, __require };

package/esm/index.d.mts

@@ -0,0 +1,3 @@
+import { addProvider, fromTypeUrl, getMessageType, toTypeUrl } from "./provider.mjs";
+import { AnyData, attachExampleFn, attachFormatFn, createMessage, decodeAny, decodeBigInt, decodeTimestamp, encodeAny, encodeBigInt, encodeTimestamp, fakeMessage, formatMessage } from "./message.mjs";
+export { type AnyData, addProvider, attachExampleFn, attachFormatFn, createMessage, decodeAny, decodeBigInt, decodeTimestamp, encodeAny, encodeBigInt, encodeTimestamp, fakeMessage, formatMessage, fromTypeUrl, getMessageType, toTypeUrl };

package/esm/index.mjs

@@ -0,0 +1,10 @@
+import "./patch.mjs";
+import { addProvider, fromTypeUrl, getMessageType, toTypeUrl } from "./provider.mjs";
+import { attachExampleFn, attachFormatFn, createMessage, decodeAny, decodeBigInt, decodeTimestamp, encodeAny, encodeBigInt, encodeTimestamp, fakeMessage, formatMessage } from "./message.mjs";
+import forge from "@ocap/proto";
+
+//#region src/index.ts
+addProvider(forge);
+
+//#endregion
+export { addProvider, attachExampleFn, attachFormatFn, createMessage, decodeAny, decodeBigInt, decodeTimestamp, encodeAny, encodeBigInt, encodeTimestamp, fakeMessage, formatMessage, fromTypeUrl, getMessageType, toTypeUrl };

package/esm/message.d.mts

@@ -0,0 +1,144 @@
+import { addProvider, fromTypeUrl, getMessageType, toTypeUrl } from "./provider.mjs";
+
+//#region src/message.d.ts
+
+/**
+ * @fileOverview Contains basic helper methods to encode/format/mock a protobuf message
+ * @module @ocap/message
+ * @requires @ocap/util
+ * @requires @ocap/proto
+ * @example
+ * bun add @ocap/message
+ *
+ * const { createMessage, fakeMessage, formatMessage } = require('@ocap/message');
+ */
+declare const Any: any;
+declare const Timestamp: any;
+interface AnyData {
+  type?: string;
+  typeUrl?: string;
+  value?: unknown;
+}
+interface TimestampData {
+  seconds?: number;
+  nanos?: number;
+}
+interface BigIntData {
+  value?: Uint8Array;
+  minus?: boolean;
+}
+interface ProtobufMessage {
+  toObject(): Record<string, unknown>;
+  serializeBinary(): Uint8Array;
+  [key: string]: unknown;
+}
+/**
+ * Generated a fake message for a type, the message can be RPC request/response
+ *
+ * @public
+ * @static
+ * @param type - Message type string, should be defined in forge-abi or forge-core-protocol
+ * @returns object
+ */
+declare function fakeMessage(type?: string): unknown;
+/**
+ * Format an message from RPC to UI friendly
+ *
+ * @public
+ * @static
+ * @param type - input type
+ * @param data - input data
+ * @returns object [almost same structure as input]
+ */
+declare function formatMessage(type: string, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Create an protobuf encoded Typed message with specified data, ready to send to rpc server
+ *
+ * @public
+ * @static
+ * @param type - message type defined in forge-proto
+ * @param params - message content
+ * @returns Message instance
+ */
+declare function createMessage(type: string, params?: Record<string, unknown>): ProtobufMessage | undefined;
+/**
+ * Decode an google.protobuf.Any%{ typeUrl, value } => { type, value }
+ *
+ * @public
+ * @static
+ * @param data - encoded data object
+ * @returns Object { type, value }
+ */
+declare function decodeAny(data: AnyData | null): AnyData;
+/**
+ * Encode { type, value } => google.protobuf.Any%{ typeUrl, value }
+ * Does nothing on already encoded message
+ *
+ * @public
+ * @static
+ * @param data
+ * @returns google.protobuf.Any
+ */
+declare function encodeAny(data: AnyData | undefined): typeof Any | undefined;
+/**
+ * Convert an { seconds, nanos } | date-string to google.protobuf.Timestamp object
+ *
+ * @public
+ * @static
+ * @param value
+ * @returns instanceof google.protobuf.Timestamp
+ */
+declare function encodeTimestamp(value: string | TimestampData | undefined): typeof Timestamp | undefined;
+/**
+ * Decode google.protobuf.Timestamp message to ISO Date String
+ *
+ * FIXME: node strictly equal because we rounded the `nanos` field
+ *
+ * @public
+ * @static
+ * @param data
+ * @returns String timestamp
+ */
+declare function decodeTimestamp(data: TimestampData): string;
+interface BigIntProtobufMessage extends ProtobufMessage {
+  setValue(v: Uint8Array): void;
+  setMinus(v: boolean): void;
+}
+/**
+ * Encode BigUint and BigSint types defined in forge-sdk, double encoding is avoided
+ *
+ * @public
+ * @static
+ * @param value - value to encode
+ * @param type - type names defined in forge-proto
+ * @returns Message
+ */
+declare function encodeBigInt(value: unknown, type: string): BigIntProtobufMessage;
+/**
+ * Convert BigUint and BigSint to string representation of numbers
+ *
+ * @public
+ * @static
+ * @link https://stackoverflow.com/questions/23948278/how-to-convert-byte-array-into-a-signed-big-integer-in-javascript
+ * @param data - usually from encodeBigInt
+ * @returns human readable number
+ */
+declare function decodeBigInt(data: BigIntData): string;
+/**
+ * Attach an $format method to rpc response
+ *
+ * @private
+ * @param data
+ * @param type
+ */
+declare function attachFormatFn(type: string, data: Record<string, unknown>, key?: string): void;
+/**
+ * Attach an example method to
+ *
+ * @private
+ * @param data
+ * @param type
+ */
+declare function attachExampleFn(type: string, host: Record<string, unknown>, key: string): void;
+//#endregion
+export { AnyData, addProvider, attachExampleFn, attachFormatFn, createMessage, decodeAny, decodeBigInt, decodeTimestamp, encodeAny, encodeBigInt, encodeTimestamp, fakeMessage, formatMessage, fromTypeUrl, getMessageType, toTypeUrl };

package/esm/message.mjs

@@ -0,0 +1,484 @@
+import { __require } from "./_virtual/rolldown_runtime.mjs";
+import { addProvider, enums, fromTypeUrl, getMessageType, messages, toTypeUrl } from "./provider.mjs";
+import createDebug from "debug";
+import camelCase from "lodash/camelCase.js";
+import { bytesToHex, isUint8Array, toBN, toUint8Array } from "@ocap/util";
+
+//#region src/message.ts
+/**
+* @fileOverview Contains basic helper methods to encode/format/mock a protobuf message
+* @module @ocap/message
+* @requires @ocap/util
+* @requires @ocap/proto
+* @example
+* bun add @ocap/message
+*
+* const { createMessage, fakeMessage, formatMessage } = require('@ocap/message');
+*/
+const jspb = __require("google-protobuf");
+const { Any } = __require("google-protobuf/google/protobuf/any_pb");
+const { Timestamp } = __require("google-protobuf/google/protobuf/timestamp_pb");
+const debug = createDebug("@ocap/message");
+const getEnumTypes = () => Object.keys(enums);
+const scalarTypes = [
+	"bool",
+	"bytes",
+	"string",
+	"double",
+	"float",
+	"sint32",
+	"uint32",
+	"sfixed32",
+	"sint64",
+	"uint64",
+	"sfixed64"
+];
+const fakeValues = {
+	bool: true,
+	sint32: 1,
+	uint32: 2,
+	sfixed32: 3,
+	sint64: 4,
+	uint64: 5,
+	sfixed64: 6,
+	BigUint: () => "1234",
+	BigSint: () => "4567",
+	float: "12.2",
+	double: "12.3",
+	string: "arcblock",
+	bytes: new Uint8Array(),
+	enums: (type) => type ? Object.values(enums[type])[0] : void 0
+};
+/**
+* Generated a fake message for a type, the message can be RPC request/response
+*
+* @public
+* @static
+* @param type - Message type string, should be defined in forge-abi or forge-core-protocol
+* @returns object
+*/
+function fakeMessage(type) {
+	if (!type) return;
+	if (fakeValues[type]) return fakeValues[type];
+	const { fields, oneofs } = getMessageType(type);
+	if (!fields) return;
+	let selectedFields = fields;
+	if (oneofs?.value && Array.isArray(oneofs.value.oneof)) {
+		const selectedField = oneofs.value.oneof[0];
+		selectedFields = { [selectedField]: fields[selectedField] };
+	}
+	const result = {};
+	Object.keys(selectedFields).forEach((key) => {
+		const { type: subType, keyType, rule } = selectedFields[key];
+		if (rule === "repeated") {
+			result[key] = [1, 2].map(() => fakeMessage(subType));
+			return;
+		}
+		if (keyType) {
+			result[key] = { [fakeValues[keyType]]: fakeMessage(subType) };
+			return;
+		}
+		if (getEnumTypes().includes(subType)) {
+			result[key] = fakeValues.enums(subType);
+			return;
+		}
+		if ([
+			"hash",
+			"appHash",
+			"txHash",
+			"address",
+			"from",
+			"to",
+			"proposer"
+		].includes(key)) {
+			result[key] = "F2D072CBD4954A20F26280730795D91AC1039996CEB6E24A31E9CE548DCB5E55";
+			return;
+		}
+		if (fakeValues[subType]) result[key] = fakeValues[subType];
+		if (subType === "google.protobuf.Timestamp") {
+			result[key] = (/* @__PURE__ */ new Date()).toISOString();
+			return;
+		}
+		if (subType === "google.protobuf.Any") {
+			result[key] = {
+				type: "string",
+				value: "ABCD 1234"
+			};
+			return;
+		}
+		result[key] = fakeMessage(subType);
+	});
+	return result;
+}
+/**
+* Format an message from RPC to UI friendly
+*
+* @public
+* @static
+* @param type - input type
+* @param data - input data
+* @returns object [almost same structure as input]
+*/
+function formatMessage(type, data) {
+	if (!type) return data;
+	if (["json", "vc"].includes(type)) return data;
+	if (typeof data !== "object") return data;
+	if (scalarTypes.includes(type)) return data;
+	const result = {};
+	const { fields } = getMessageType(type);
+	if (!fields) {
+		console.log({
+			type,
+			data
+		});
+		throw new Error(`Cannot get fields for type ${type}`);
+	}
+	Object.keys(fields).forEach((key) => {
+		const { type: subType, keyType, rule } = fields[key];
+		let value = data[key];
+		if (rule === "repeated") value = data[camelCase(`${key}_list`)] || data[key];
+		if (keyType) value = data[camelCase(`${key}_map`)] || data[key];
+		if (value === void 0) return;
+		if (rule === "repeated") {
+			result[key] = value.map((x) => formatMessage(subType, x));
+			return;
+		}
+		if (keyType) {
+			debug("formatMessage.map", {
+				type,
+				subType,
+				keyType,
+				value
+			});
+			result[key] = (value || []).reduce((acc, [k, v]) => {
+				acc[k] = formatMessage(subType, v);
+				return acc;
+			}, {});
+			return;
+		}
+		if (getEnumTypes().includes(subType)) {
+			result[key] = messages[subType][value];
+			return;
+		}
+		if (["BigUint", "BigSint"].includes(subType)) {
+			result[key] = decodeBigInt(value);
+			return;
+		}
+		if (isUint8Array(value)) {
+			if (["appHash", "blockHash"].includes(key)) result[key] = Buffer.from(value).toString("hex");
+			if ([
+				"signature",
+				"pk",
+				"sk"
+			].includes(key)) result[key] = Buffer.from(value).toString("base64");
+			return;
+		}
+		if (subType === "google.protobuf.Timestamp") {
+			result[key] = decodeTimestamp(value);
+			return;
+		}
+		if (subType === "google.protobuf.Any") {
+			if (value) {
+				const decoded = decodeAny(value);
+				result[key] = {
+					type: decoded.type || value.typeUrl,
+					value: formatMessage(decoded.type || value.typeUrl || "", decoded.value)
+				};
+			}
+			return;
+		}
+		if (value && typeof value === "object") {
+			result[key] = formatMessage(subType, value);
+			return;
+		}
+		result[key] = value;
+	});
+	return result;
+}
+/**
+* Create an protobuf encoded Typed message with specified data, ready to send to rpc server
+*
+* @public
+* @static
+* @param type - message type defined in forge-proto
+* @param params - message content
+* @returns Message instance
+*/
+function createMessage(type, params) {
+	if (!type && !params) {
+		console.log({
+			type,
+			params
+		});
+		return;
+	}
+	const { fn: Message, fields } = getMessageType(type);
+	if (!Message || !fields) {
+		console.error({
+			type,
+			params,
+			fields,
+			Message
+		});
+		throw new Error(`Unsupported messageType: ${type}`);
+	}
+	const message = new Message();
+	if (!params) return message;
+	Object.keys(fields).forEach((key) => {
+		const { type: subType, keyType, rule, id } = fields[key];
+		const value = params[key] || params[camelCase(`${key}_list`)];
+		if (value === void 0) return;
+		if (keyType) {
+			const keys = Object.keys(value);
+			if (keys.length) {
+				const fn$1 = camelCase(`get_${key}_map`);
+				const map = message[fn$1]();
+				debug("createMessage.map", {
+					type,
+					subType,
+					keyType,
+					id,
+					fn: fn$1,
+					keys
+				});
+				keys.forEach((k) => {
+					map.set(k, createMessage(subType, value[k]));
+				});
+				jspb.Message.setField(message, id, map);
+			}
+			return;
+		}
+		const fn = camelCase(rule === "repeated" ? `add_${key}` : `set_${key}`);
+		if (typeof message[fn] !== "function") throw new Error(`Unexpected field names ${JSON.stringify({
+			type,
+			key,
+			subType,
+			fn,
+			rule
+		})}`);
+		const values = rule === "repeated" ? value : [value];
+		try {
+			values.forEach((v) => {
+				if (getEnumTypes().includes(subType)) {
+					message[fn](v);
+					return;
+				}
+				if (["BigUint", "BigSint"].includes(subType)) {
+					message[fn](encodeBigInt(v, subType));
+					return;
+				}
+				if (subType === "google.protobuf.Timestamp") {
+					debug(`createMessage.${subType}`, { v });
+					message[fn](encodeTimestamp(v));
+					return;
+				}
+				if (subType === "google.protobuf.Any") {
+					message[fn](encodeAny(v));
+					return;
+				}
+				if (subType === "bytes") {
+					message[fn](toUint8Array(v));
+					return;
+				}
+				const { fn: SubMessage, fields: subFields } = getMessageType(subType);
+				if (SubMessage && subFields) {
+					debug(`createMessage.${subType}`, {
+						type,
+						subType,
+						key
+					});
+					const subMessage = createMessage(subType, v);
+					message[fn](subMessage);
+					return;
+				}
+				message[fn](v);
+			});
+		} catch (err) {
+			debug("createMessage.processField.error", {
+				type,
+				key,
+				subType,
+				fn,
+				rule,
+				values,
+				err
+			});
+			throw err;
+		}
+	});
+	return message;
+}
+/**
+* Decode an google.protobuf.Any%{ typeUrl, value } => { type, value }
+*
+* @public
+* @static
+* @param data - encoded data object
+* @returns Object { type, value }
+*/
+function decodeAny(data) {
+	if (!data) return {
+		type: "Unknown",
+		value: ""
+	};
+	if (data.type && data.value) return data;
+	const { typeUrl, value } = data;
+	if (typeUrl && ["json", "vc"].includes(typeUrl)) return {
+		type: typeUrl,
+		value: JSON.parse(Buffer.from(value, "base64").toString())
+	};
+	const type = fromTypeUrl(typeUrl);
+	const { fn: Message } = getMessageType(type);
+	if (!Message) return data;
+	const buffer = Buffer.isBuffer(value) ? value : Buffer.from(value, "base64");
+	return {
+		type,
+		value: Message.deserializeBinary(new Uint8Array(buffer)).toObject()
+	};
+}
+/**
+* Encode { type, value } => google.protobuf.Any%{ typeUrl, value }
+* Does nothing on already encoded message
+*
+* @public
+* @static
+* @param data
+* @returns google.protobuf.Any
+*/
+function encodeAny(data) {
+	if (!data) return;
+	const anyMessage = new Any();
+	try {
+		if (data.typeUrl && data.value && !data.type) {
+			anyMessage.setTypeUrl(data.typeUrl);
+			if (data.typeUrl === "fg:x:address") anyMessage.setValue(data.value);
+			else if (["json", "vc"].includes(data.typeUrl)) anyMessage.setValue(new Uint8Array(Buffer.from(JSON.stringify(data.value))));
+			else anyMessage.setValue(new Uint8Array(Buffer.from(data.value, "base64")));
+		} else {
+			const { value: anyValue, type: anyType } = data;
+			const typeUrl = toTypeUrl(anyType);
+			anyMessage.setTypeUrl(typeUrl);
+			if (["json", "vc"].includes(typeUrl)) anyMessage.setValue(new Uint8Array(Buffer.from(JSON.stringify(anyValue))));
+			else {
+				const anyValueBinary = createMessage(anyType, anyValue);
+				anyMessage.setValue(anyValueBinary.serializeBinary());
+			}
+		}
+	} catch (err) {
+		console.error("error encode any type", data);
+		throw err;
+	}
+	return anyMessage;
+}
+/**
+* Convert an { seconds, nanos } | date-string to google.protobuf.Timestamp object
+*
+* @public
+* @static
+* @param value
+* @returns instanceof google.protobuf.Timestamp
+*/
+function encodeTimestamp(value) {
+	if (!value) return;
+	const timestamp = new Timestamp();
+	if (typeof value === "string") {
+		const millionSeconds = Date.parse(value);
+		if (Number.isNaN(millionSeconds) === false) {
+			timestamp.setSeconds(Math.floor(millionSeconds / 1e3));
+			timestamp.setNanos(Math.floor(millionSeconds % 1e3 * 1e6));
+		}
+	} else {
+		const { seconds, nanos = 0 } = value;
+		timestamp.setSeconds(seconds);
+		timestamp.setNanos(nanos);
+	}
+	return timestamp;
+}
+/**
+* Decode google.protobuf.Timestamp message to ISO Date String
+*
+* FIXME: node strictly equal because we rounded the `nanos` field
+*
+* @public
+* @static
+* @param data
+* @returns String timestamp
+*/
+function decodeTimestamp(data) {
+	if (data?.seconds) {
+		const date = /* @__PURE__ */ new Date();
+		date.setTime(data.seconds * 1e3 + Math.ceil((data.nanos || 0) / 1e6));
+		return date.toISOString();
+	}
+	return "";
+}
+/**
+* Encode BigUint and BigSint types defined in forge-sdk, double encoding is avoided
+*
+* @public
+* @static
+* @param value - value to encode
+* @param type - type names defined in forge-proto
+* @returns Message
+*/
+function encodeBigInt(value, type) {
+	const { fn: BigIntMessageClass } = getMessageType(type);
+	if (!BigIntMessageClass) throw new Error(`Unknown BigInt type: ${type}`);
+	const message = new BigIntMessageClass();
+	if (value && typeof value === "object" && "value" in value && isUint8Array(value.value)) {
+		message.setValue(value.value);
+		if (type === "BigSint") message.setMinus(value.minus);
+		return message;
+	}
+	const number = toBN(value);
+	const zero = toBN(0);
+	message.setValue(new Uint8Array(number.toArray()));
+	if (type === "BigSint") message.setMinus(number.lt(zero));
+	return message;
+}
+/**
+* Convert BigUint and BigSint to string representation of numbers
+*
+* @public
+* @static
+* @link https://stackoverflow.com/questions/23948278/how-to-convert-byte-array-into-a-signed-big-integer-in-javascript
+* @param data - usually from encodeBigInt
+* @returns human readable number
+*/
+function decodeBigInt(data) {
+	const bn = toBN(bytesToHex(data.value));
+	return `${data.minus ? "-" : ""}${bn.toString(10)}`;
+}
+/**
+* Attach an $format method to rpc response
+*
+* @private
+* @param data
+* @param type
+*/
+function attachFormatFn(type, data, key = "$format") {
+	Object.defineProperty(data, key, {
+		writable: false,
+		enumerable: false,
+		configurable: false,
+		value: () => formatMessage(type, data)
+	});
+}
+/**
+* Attach an example method to
+*
+* @private
+* @param data
+* @param type
+*/
+function attachExampleFn(type, host, key) {
+	Object.defineProperty(host, key, {
+		writable: false,
+		enumerable: false,
+		configurable: false,
+		value: () => fakeMessage(type)
+	});
+}
+
+//#endregion
+export { addProvider, attachExampleFn, attachFormatFn, createMessage, decodeAny, decodeBigInt, decodeTimestamp, encodeAny, encodeBigInt, encodeTimestamp, fakeMessage, formatMessage, fromTypeUrl, getMessageType, toTypeUrl };