@candypoets/nipworker 0.96.3 → 0.96.5

package/crates/native-ffi/react-native/android/src/main/cpp/NipworkerByteRuntime.cpp

@@ -8,9 +8,18 @@
 #include <vector>
 
 extern "C" void nipworker_handle_message(void* handle, const uint8_t* ptr, size_t len);
+extern "C" bool nipworker_subscribe_message(void* handle, const uint8_t* ptr, size_t len);
+extern "C" bool nipworker_publish_message(void* handle, const uint8_t* ptr, size_t len);
 extern "C" void nipworker_set_private_key(void* handle, const char* ptr);
 extern "C" void nipworker_wake(void* handle);
 extern "C" void nipworker_deinit(void* handle);
+extern "C" bool nipworker_register_subscription(void* handle, const char* sub_id, size_t buffer_size);
+extern "C" bool nipworker_register_publish_buffer(void* handle, const char* publish_id, size_t buffer_size);
+extern "C" bool nipworker_retain_subscription(void* handle, const char* sub_id);
+extern "C" void nipworker_release_subscription(void* handle, const char* sub_id);
+extern "C" uint8_t* nipworker_subscription_buffer_ptr(void* handle, const char* sub_id);
+extern "C" size_t nipworker_subscription_buffer_len(void* handle, const char* sub_id);
+extern "C" void nipworker_cleanup_subscriptions(void* handle);
 
 namespace {
 using facebook::jsi::Array;
@@ -39,6 +48,23 @@ private:
 	std::vector<uint8_t> bytes_;
 };
 
+class ExternalMutableBuffer final : public MutableBuffer {
+public:
+	ExternalMutableBuffer(uint8_t* ptr, size_t len) : ptr_(ptr), len_(len) {}
+
+	size_t size() const override {
+		return len_;
+	}
+
+	uint8_t* data() override {
+		return ptr_;
+	}
+
+private:
+	uint8_t* ptr_;
+	size_t len_;
+};
+
 std::mutex gQueueMutex;
 std::vector<std::vector<uint8_t>> gQueuedPackets;
 bool gInstalled = false;
@@ -78,6 +104,153 @@ Java_com_candypoets_nipworker_reactnative_NipworkerReactNativeModule_nativeQueue
 	return JNI_TRUE;
 }
 
+extern "C" JNIEXPORT jobject JNICALL
+Java_com_candypoets_nipworker_reactnative_NipworkerReactNativeModule_nativeSubscribeMessage(
+	JNIEnv* env,
+	jclass,
+	jlong handle,
+	jbyteArray bytes,
+	jstring subId
+) {
+	if (handle == 0 || bytes == nullptr || subId == nullptr) return nullptr;
+	jsize len = env->GetArrayLength(bytes);
+	jbyte* ptr = env->GetByteArrayElements(bytes, nullptr);
+	if (ptr == nullptr) return nullptr;
+	auto* engineHandle = reinterpret_cast<void*>(handle);
+	bool ok = nipworker_subscribe_message(
+		engineHandle,
+		reinterpret_cast<const uint8_t*>(ptr),
+		static_cast<size_t>(len)
+	);
+	env->ReleaseByteArrayElements(bytes, ptr, JNI_ABORT);
+	if (!ok) return nullptr;
+
+	const char* subIdChars = env->GetStringUTFChars(subId, nullptr);
+	if (subIdChars == nullptr) return nullptr;
+	uint8_t* bufferPtr = nipworker_subscription_buffer_ptr(engineHandle, subIdChars);
+	size_t bufferLen = nipworker_subscription_buffer_len(engineHandle, subIdChars);
+	env->ReleaseStringUTFChars(subId, subIdChars);
+	if (bufferPtr == nullptr || bufferLen == 0) return nullptr;
+	return env->NewDirectByteBuffer(bufferPtr, static_cast<jlong>(bufferLen));
+}
+
+extern "C" JNIEXPORT jobject JNICALL
+Java_com_candypoets_nipworker_reactnative_NipworkerReactNativeModule_nativePublishMessage(
+	JNIEnv* env,
+	jclass,
+	jlong handle,
+	jbyteArray bytes,
+	jstring publishId
+) {
+	if (handle == 0 || bytes == nullptr || publishId == nullptr) return nullptr;
+	jsize len = env->GetArrayLength(bytes);
+	jbyte* ptr = env->GetByteArrayElements(bytes, nullptr);
+	if (ptr == nullptr) return nullptr;
+	auto* engineHandle = reinterpret_cast<void*>(handle);
+	bool ok = nipworker_publish_message(
+		engineHandle,
+		reinterpret_cast<const uint8_t*>(ptr),
+		static_cast<size_t>(len)
+	);
+	env->ReleaseByteArrayElements(bytes, ptr, JNI_ABORT);
+	if (!ok) return nullptr;
+
+	const char* publishIdChars = env->GetStringUTFChars(publishId, nullptr);
+	if (publishIdChars == nullptr) return nullptr;
+	uint8_t* bufferPtr = nipworker_subscription_buffer_ptr(engineHandle, publishIdChars);
+	size_t bufferLen = nipworker_subscription_buffer_len(engineHandle, publishIdChars);
+	env->ReleaseStringUTFChars(publishId, publishIdChars);
+	if (bufferPtr == nullptr || bufferLen == 0) return nullptr;
+	return env->NewDirectByteBuffer(bufferPtr, static_cast<jlong>(bufferLen));
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_candypoets_nipworker_reactnative_NipworkerReactNativeModule_nativeRegisterSubscription(
+	JNIEnv* env,
+	jclass,
+	jlong handle,
+	jstring subId,
+	jint bufferSize
+) {
+	if (handle == 0 || subId == nullptr || bufferSize <= 0) return JNI_FALSE;
+	const char* subIdChars = env->GetStringUTFChars(subId, nullptr);
+	if (subIdChars == nullptr) return JNI_FALSE;
+	bool ok = nipworker_register_subscription(
+		reinterpret_cast<void*>(handle),
+		subIdChars,
+		static_cast<size_t>(bufferSize)
+	);
+	env->ReleaseStringUTFChars(subId, subIdChars);
+	return ok ? JNI_TRUE : JNI_FALSE;
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_candypoets_nipworker_reactnative_NipworkerReactNativeModule_nativeRegisterPublishBuffer(
+	JNIEnv* env,
+	jclass,
+	jlong handle,
+	jstring publishId,
+	jint bufferSize
+) {
+	if (handle == 0 || publishId == nullptr || bufferSize <= 0) return JNI_FALSE;
+	const char* publishIdChars = env->GetStringUTFChars(publishId, nullptr);
+	if (publishIdChars == nullptr) return JNI_FALSE;
+	bool ok = nipworker_register_publish_buffer(
+		reinterpret_cast<void*>(handle),
+		publishIdChars,
+		static_cast<size_t>(bufferSize)
+	);
+	env->ReleaseStringUTFChars(publishId, publishIdChars);
+	return ok ? JNI_TRUE : JNI_FALSE;
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_candypoets_nipworker_reactnative_NipworkerReactNativeModule_nativeRetainSubscription(
+	JNIEnv* env,
+	jclass,
+	jlong handle,
+	jstring subId
+) {
+	if (handle == 0 || subId == nullptr) return JNI_FALSE;
+	const char* subIdChars = env->GetStringUTFChars(subId, nullptr);
+	if (subIdChars == nullptr) return JNI_FALSE;
+	bool ok = nipworker_retain_subscription(reinterpret_cast<void*>(handle), subIdChars);
+	env->ReleaseStringUTFChars(subId, subIdChars);
+	return ok ? JNI_TRUE : JNI_FALSE;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_candypoets_nipworker_reactnative_NipworkerReactNativeModule_nativeReleaseSubscription(
+	JNIEnv* env,
+	jclass,
+	jlong handle,
+	jstring subId
+) {
+	if (handle == 0 || subId == nullptr) return;
+	const char* subIdChars = env->GetStringUTFChars(subId, nullptr);
+	if (subIdChars == nullptr) return;
+	nipworker_release_subscription(reinterpret_cast<void*>(handle), subIdChars);
+	env->ReleaseStringUTFChars(subId, subIdChars);
+}
+
+extern "C" JNIEXPORT jobject JNICALL
+Java_com_candypoets_nipworker_reactnative_NipworkerReactNativeModule_nativeGetSubscriptionBuffer(
+	JNIEnv* env,
+	jclass,
+	jlong handle,
+	jstring subId
+) {
+	if (handle == 0 || subId == nullptr) return nullptr;
+	const char* subIdChars = env->GetStringUTFChars(subId, nullptr);
+	if (subIdChars == nullptr) return nullptr;
+	auto* engineHandle = reinterpret_cast<void*>(handle);
+	uint8_t* ptr = nipworker_subscription_buffer_ptr(engineHandle, subIdChars);
+	size_t len = nipworker_subscription_buffer_len(engineHandle, subIdChars);
+	env->ReleaseStringUTFChars(subId, subIdChars);
+	if (ptr == nullptr || len == 0) return nullptr;
+	return env->NewDirectByteBuffer(ptr, static_cast<jlong>(len));
+}
+
 extern "C" JNIEXPORT jboolean JNICALL
 Java_com_candypoets_nipworker_reactnative_NipworkerReactNativeModule_nativeIsByteRuntimeInstalled(
 	JNIEnv*,
@@ -158,6 +331,181 @@ Java_com_candypoets_nipworker_reactnative_NipworkerReactNativeModule_nativeInsta
 		)
 	);
 
+	byteRuntime.setProperty(
+		runtime,
+		"registerSubscription",
+		Function::createFromHostFunction(
+			runtime,
+			PropNameID::forAscii(runtime, "registerSubscription"),
+			2,
+			[engineHandle](Runtime& runtime, const Value&, const Value* args, size_t count) -> Value {
+				if (count < 2 || !args[0].isString() || !args[1].isNumber()) return Value(false);
+				std::string subId = args[0].asString(runtime).utf8(runtime);
+				auto bufferSize = static_cast<size_t>(args[1].asNumber());
+				return Value(nipworker_register_subscription(engineHandle, subId.c_str(), bufferSize));
+			}
+		)
+	);
+
+	byteRuntime.setProperty(
+		runtime,
+		"subscribe",
+		Function::createFromHostFunction(
+			runtime,
+			PropNameID::forAscii(runtime, "subscribe"),
+			2,
+			[engineHandle](Runtime& runtime, const Value&, const Value* args, size_t count) -> Value {
+				if (count < 2 || !isArrayBuffer(runtime, args[0]) || !args[1].isString()) {
+					return Value::undefined();
+				}
+				ArrayBuffer message = args[0].asObject(runtime).getArrayBuffer(runtime);
+				std::string subId = args[1].asString(runtime).utf8(runtime);
+				if (!nipworker_subscribe_message(engineHandle, message.data(runtime), message.size(runtime))) {
+					return Value::undefined();
+				}
+				uint8_t* ptr = nipworker_subscription_buffer_ptr(engineHandle, subId.c_str());
+				size_t len = nipworker_subscription_buffer_len(engineHandle, subId.c_str());
+				if (ptr == nullptr || len == 0) return Value::undefined();
+				auto nativeBuffer = std::make_shared<ExternalMutableBuffer>(ptr, len);
+				ArrayBuffer buffer(runtime, std::move(nativeBuffer));
+				return Value(runtime, std::move(buffer));
+			}
+		)
+	);
+
+	byteRuntime.setProperty(
+		runtime,
+		"registerPublishBuffer",
+		Function::createFromHostFunction(
+			runtime,
+			PropNameID::forAscii(runtime, "registerPublishBuffer"),
+			2,
+			[engineHandle](Runtime& runtime, const Value&, const Value* args, size_t count) -> Value {
+				if (count < 2 || !args[0].isString() || !args[1].isNumber()) return Value(false);
+				std::string publishId = args[0].asString(runtime).utf8(runtime);
+				auto bufferSize = static_cast<size_t>(args[1].asNumber());
+				return Value(nipworker_register_publish_buffer(engineHandle, publishId.c_str(), bufferSize));
+			}
+		)
+	);
+
+	byteRuntime.setProperty(
+		runtime,
+		"publish",
+		Function::createFromHostFunction(
+			runtime,
+			PropNameID::forAscii(runtime, "publish"),
+			2,
+			[engineHandle](Runtime& runtime, const Value&, const Value* args, size_t count) -> Value {
+				if (count < 2 || !isArrayBuffer(runtime, args[0]) || !args[1].isString()) {
+					return Value::undefined();
+				}
+				ArrayBuffer message = args[0].asObject(runtime).getArrayBuffer(runtime);
+				std::string publishId = args[1].asString(runtime).utf8(runtime);
+				if (!nipworker_publish_message(engineHandle, message.data(runtime), message.size(runtime))) {
+					return Value::undefined();
+				}
+				uint8_t* ptr = nipworker_subscription_buffer_ptr(engineHandle, publishId.c_str());
+				size_t len = nipworker_subscription_buffer_len(engineHandle, publishId.c_str());
+				if (ptr == nullptr || len == 0) return Value::undefined();
+				auto nativeBuffer = std::make_shared<ExternalMutableBuffer>(ptr, len);
+				ArrayBuffer buffer(runtime, std::move(nativeBuffer));
+				return Value(runtime, std::move(buffer));
+			}
+		)
+	);
+
+	byteRuntime.setProperty(
+		runtime,
+		"retainSubscription",
+		Function::createFromHostFunction(
+			runtime,
+			PropNameID::forAscii(runtime, "retainSubscription"),
+			1,
+			[engineHandle](Runtime& runtime, const Value&, const Value* args, size_t count) -> Value {
+				if (count < 1 || !args[0].isString()) return Value(false);
+				std::string subId = args[0].asString(runtime).utf8(runtime);
+				return Value(nipworker_retain_subscription(engineHandle, subId.c_str()));
+			}
+		)
+	);
+
+	byteRuntime.setProperty(
+		runtime,
+		"retainSubscriptionBuffer",
+		Function::createFromHostFunction(
+			runtime,
+			PropNameID::forAscii(runtime, "retainSubscriptionBuffer"),
+			1,
+			[engineHandle](Runtime& runtime, const Value&, const Value* args, size_t count) -> Value {
+				if (count < 1 || !args[0].isString()) return Value::undefined();
+				std::string subId = args[0].asString(runtime).utf8(runtime);
+				if (!nipworker_retain_subscription(engineHandle, subId.c_str())) {
+					return Value::undefined();
+				}
+				uint8_t* ptr = nipworker_subscription_buffer_ptr(engineHandle, subId.c_str());
+				size_t len = nipworker_subscription_buffer_len(engineHandle, subId.c_str());
+				if (ptr == nullptr || len == 0) {
+					nipworker_release_subscription(engineHandle, subId.c_str());
+					return Value::undefined();
+				}
+				auto nativeBuffer = std::make_shared<ExternalMutableBuffer>(ptr, len);
+				ArrayBuffer buffer(runtime, std::move(nativeBuffer));
+				return Value(runtime, std::move(buffer));
+			}
+		)
+	);
+
+	byteRuntime.setProperty(
+		runtime,
+		"releaseSubscription",
+		Function::createFromHostFunction(
+			runtime,
+			PropNameID::forAscii(runtime, "releaseSubscription"),
+			1,
+			[engineHandle](Runtime& runtime, const Value&, const Value* args, size_t count) -> Value {
+				if (count < 1 || !args[0].isString()) return Value::undefined();
+				std::string subId = args[0].asString(runtime).utf8(runtime);
+				nipworker_release_subscription(engineHandle, subId.c_str());
+				return Value::undefined();
+			}
+		)
+	);
+
+	byteRuntime.setProperty(
+		runtime,
+		"getSubscriptionBuffer",
+		Function::createFromHostFunction(
+			runtime,
+			PropNameID::forAscii(runtime, "getSubscriptionBuffer"),
+			1,
+			[engineHandle](Runtime& runtime, const Value&, const Value* args, size_t count) -> Value {
+				if (count < 1 || !args[0].isString()) return Value::undefined();
+				std::string subId = args[0].asString(runtime).utf8(runtime);
+				uint8_t* ptr = nipworker_subscription_buffer_ptr(engineHandle, subId.c_str());
+				size_t len = nipworker_subscription_buffer_len(engineHandle, subId.c_str());
+				if (ptr == nullptr || len == 0) return Value::undefined();
+				auto nativeBuffer = std::make_shared<ExternalMutableBuffer>(ptr, len);
+				ArrayBuffer buffer(runtime, std::move(nativeBuffer));
+				return Value(runtime, std::move(buffer));
+			}
+		)
+	);
+
+	byteRuntime.setProperty(
+		runtime,
+		"cleanupSubscriptions",
+		Function::createFromHostFunction(
+			runtime,
+			PropNameID::forAscii(runtime, "cleanupSubscriptions"),
+			0,
+			[engineHandle](Runtime&, const Value&, const Value*, size_t) -> Value {
+				nipworker_cleanup_subscriptions(engineHandle);
+				return Value::undefined();
+			}
+		)
+	);
+
 	byteRuntime.setProperty(
 		runtime,
 		"deinit",

package/crates/native-ffi/react-native/android/src/main/java/com/candypoets/nipworker/reactnative/NipworkerHooks.kt

@@ -0,0 +1,292 @@
+package com.candypoets.nipworker.reactnative
+
+import com.google.flatbuffers.FlatBufferBuilder
+import java.io.Closeable
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import nostr.fb.MainContent
+import nostr.fb.MainMessage
+import nostr.fb.MessageType
+import nostr.fb.MuteFilterPipeConfig
+import nostr.fb.ParsePipeConfig
+import nostr.fb.Pipe
+import nostr.fb.PipeConfig
+import nostr.fb.PipelineConfig
+import nostr.fb.Publish
+import nostr.fb.Request
+import nostr.fb.SaveToDbPipeConfig
+import nostr.fb.SerializeEventsPipeConfig
+import nostr.fb.StringVec
+import nostr.fb.Subscribe
+import nostr.fb.SubscriptionConfig
+import nostr.fb.Template
+import nostr.fb.WorkerMessage
+
+data class NipworkerRequest(
+	val ids: List<String> = emptyList(),
+	val authors: List<String> = emptyList(),
+	val kinds: List<Int> = emptyList(),
+	val tags: Map<String, List<String>> = emptyMap(),
+	val since: Int = 0,
+	val until: Int = 0,
+	val limit: Int = 0,
+	val search: String? = null,
+	val relays: List<String> = emptyList(),
+	val closeOnEose: Boolean = false,
+	val cacheFirst: Boolean = true,
+	val noCache: Boolean = false,
+	val maxRelays: Int = 0,
+)
+
+data class NipworkerSubscriptionOptions(
+	val closeOnEose: Boolean = false,
+	val cacheFirst: Boolean = true,
+	val timeoutMs: Long = 0,
+	val maxEvents: Long = 0,
+	val skipCache: Boolean = false,
+	val force: Boolean = false,
+	val bytesPerEvent: Long = 3072,
+	val isSlow: Boolean = false,
+	val pagination: String? = null,
+	val cacheOnly: Boolean = false,
+)
+
+data class NipworkerEventTemplate(
+	val kind: Int,
+	val content: String,
+	val tags: List<List<String>> = emptyList(),
+	val createdAt: Int = 0,
+)
+
+class NipworkerWorkerMessage(private val bytes: ByteArray) {
+	private val buffer: ByteBuffer =
+		ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN)
+
+	val message: WorkerMessage = WorkerMessage.getRootAsWorkerMessage(buffer)
+	val subId: String? get() = message.subId()
+	val url: String? get() = message.url()
+	val type: Long get() = message.type()
+	val contentType: Byte get() = message.contentType()
+
+	fun bytes(): ByteArray = bytes
+}
+
+class NipworkerHookHandle internal constructor(private val cancelAction: () -> Unit) : Closeable {
+	@Volatile
+	private var closed = false
+
+	override fun close() {
+		if (!closed) {
+			closed = true
+			cancelAction()
+		}
+	}
+
+	fun cancel() = close()
+}
+
+fun NipworkerRuntime.useSubscription(
+	subscriptionId: String,
+	requests: List<NipworkerRequest>,
+	options: NipworkerSubscriptionOptions = NipworkerSubscriptionOptions(),
+	onMessages: (List<NipworkerWorkerMessage>) -> Unit,
+): NipworkerHookHandle {
+	val buffer = retainSubscriptionBuffer(subscriptionId)
+		?: subscribe(buildSubscribeMessage(subscriptionId, requests, options), subscriptionId)
+	var lastReadPosition = 4
+
+	fun drain() {
+		val messages = buffer?.readWorkerMessages(lastReadPosition).orEmpty()
+		if (messages.isNotEmpty()) {
+			lastReadPosition += messages.sumOf { it.bytes().size + 4 }
+			onMessages(messages)
+		}
+	}
+
+	val listener = addListener(subscriptionId) {
+		drain()
+	}
+
+	drain()
+
+	return NipworkerHookHandle {
+		listener()
+		releaseSubscription(subscriptionId)
+	}
+}
+
+fun NipworkerRuntime.usePublish(
+	publishId: String,
+	event: NipworkerEventTemplate,
+	defaultRelays: List<String> = emptyList(),
+	optimisticSubIds: List<String> = emptyList(),
+	onStatus: (NipworkerWorkerMessage) -> Unit,
+): NipworkerHookHandle {
+	val buffer = publish(buildPublishMessage(publishId, event, defaultRelays, optimisticSubIds), publishId)
+	var lastReadPosition = 4
+
+	fun drain() {
+		val messages = buffer?.readWorkerMessages(lastReadPosition).orEmpty()
+		if (messages.isNotEmpty()) {
+			lastReadPosition += messages.sumOf { it.bytes().size + 4 }
+			messages
+				.filter { it.type != MessageType.ParsedNostrEvent }
+				.forEach(onStatus)
+		}
+	}
+
+	val listener = addListener(publishId) {
+		drain()
+	}
+
+	drain()
+
+	return NipworkerHookHandle {
+		listener()
+		releaseSubscription(publishId)
+	}
+}
+
+private fun ByteBuffer.readWorkerMessages(fromPosition: Int): List<NipworkerWorkerMessage> {
+	val source = duplicate().order(ByteOrder.LITTLE_ENDIAN)
+	if (source.capacity() < 4) return emptyList()
+	val writePosition = source.getInt(0).coerceAtMost(source.capacity())
+	var position = fromPosition
+	val messages = mutableListOf<NipworkerWorkerMessage>()
+	while (position + 4 <= writePosition) {
+		val messageLength = source.getInt(position)
+		if (messageLength <= 0 || position + 4 + messageLength > writePosition) break
+		val bytes = ByteArray(messageLength)
+		source.position(position + 4)
+		source.get(bytes)
+		messages.add(NipworkerWorkerMessage(bytes))
+		position += 4 + messageLength
+	}
+	return messages
+}
+
+private fun buildSubscribeMessage(
+	subId: String,
+	requests: List<NipworkerRequest>,
+	options: NipworkerSubscriptionOptions,
+): ByteArray {
+	val builder = FlatBufferBuilder(2048)
+	val requestOffsets = requests.map { request -> buildRequest(builder, request, options) }.toIntArray()
+	val requestsOffset = Subscribe.createRequestsVector(builder, requestOffsets)
+	val pipelineOffset = buildDefaultPipeline(builder, subId)
+	val paginationOffset = options.pagination?.let { builder.createString(it) } ?: 0
+	val configOffset = SubscriptionConfig.createSubscriptionConfig(
+		builder,
+		pipelineOffset,
+		options.closeOnEose,
+		options.cacheFirst,
+		options.timeoutMs,
+		options.maxEvents,
+		options.skipCache,
+		options.force,
+		options.bytesPerEvent,
+		options.isSlow,
+		paginationOffset,
+		options.cacheOnly,
+	)
+	val subscribeOffset = Subscribe.createSubscribe(
+		builder,
+		builder.createString(subId),
+		requestsOffset,
+		configOffset,
+	)
+	val root = MainMessage.createMainMessage(builder, MainContent.Subscribe, subscribeOffset)
+	builder.finish(root)
+	return builder.sizedByteArray()
+}
+
+private fun buildRequest(
+	builder: FlatBufferBuilder,
+	request: NipworkerRequest,
+	options: NipworkerSubscriptionOptions,
+): Int {
+	val idsOffset = stringVector(builder, request.ids)
+	val authorsOffset = stringVector(builder, request.authors)
+	val kindsOffset = if (request.kinds.isEmpty()) 0 else Request.createKindsVector(builder, request.kinds.toIntArray())
+	val tagOffsets = request.tags.map { (key, values) ->
+		StringVec.createStringVec(builder, stringVector(builder, listOf(key) + values))
+	}.toIntArray()
+	val tagsOffset = if (tagOffsets.isEmpty()) 0 else Request.createTagsVector(builder, tagOffsets)
+	val searchOffset = request.search?.let { builder.createString(it) } ?: 0
+	val relaysOffset = stringVector(builder, request.relays)
+	return Request.createRequest(
+		builder,
+		idsOffset,
+		authorsOffset,
+		kindsOffset,
+		tagsOffset,
+		request.limit,
+		request.since,
+		request.until,
+		searchOffset,
+		relaysOffset,
+		request.closeOnEose,
+		request.cacheFirst,
+		request.noCache,
+		request.maxRelays,
+		options.cacheOnly,
+	)
+}
+
+private fun buildDefaultPipeline(builder: FlatBufferBuilder, subId: String): Int {
+	val muteStart = MuteFilterPipeConfig.startMuteFilterPipeConfig(builder)
+	val muteConfig = MuteFilterPipeConfig.endMuteFilterPipeConfig(builder)
+	val mutePipe = Pipe.createPipe(builder, PipeConfig.MuteFilterPipeConfig, muteConfig)
+
+	val parseStart = ParsePipeConfig.startParsePipeConfig(builder)
+	val parseConfig = ParsePipeConfig.endParsePipeConfig(builder)
+	val parsePipe = Pipe.createPipe(builder, PipeConfig.ParsePipeConfig, parseConfig)
+
+	val saveStart = SaveToDbPipeConfig.startSaveToDbPipeConfig(builder)
+	val saveConfig = SaveToDbPipeConfig.endSaveToDbPipeConfig(builder)
+	val savePipe = Pipe.createPipe(builder, PipeConfig.SaveToDbPipeConfig, saveConfig)
+
+	val serializeConfig = SerializeEventsPipeConfig.createSerializeEventsPipeConfig(builder, builder.createString(subId))
+	val serializePipe = Pipe.createPipe(builder, PipeConfig.SerializeEventsPipeConfig, serializeConfig)
+
+	return PipelineConfig.createPipelineConfig(
+		builder,
+		PipelineConfig.createPipesVector(builder, intArrayOf(mutePipe, parsePipe, savePipe, serializePipe)),
+	)
+}
+
+private fun buildPublishMessage(
+	publishId: String,
+	event: NipworkerEventTemplate,
+	defaultRelays: List<String>,
+	optimisticSubIds: List<String>,
+): ByteArray {
+	val builder = FlatBufferBuilder(1024)
+	val tags = event.tags.map { tag ->
+		StringVec.createStringVec(builder, stringVector(builder, tag))
+	}.toIntArray()
+	val tagsOffset = Template.createTagsVector(builder, tags)
+	val templateOffset = Template.createTemplate(
+		builder,
+		event.kind,
+		event.createdAt,
+		builder.createString(event.content),
+		tagsOffset,
+	)
+	val publishOffset = Publish.createPublish(
+		builder,
+		builder.createString(publishId),
+		templateOffset,
+		stringVector(builder, defaultRelays),
+		stringVector(builder, optimisticSubIds),
+	)
+	val root = MainMessage.createMainMessage(builder, MainContent.Publish, publishOffset)
+	builder.finish(root)
+	return builder.sizedByteArray()
+}
+
+private fun stringVector(builder: FlatBufferBuilder, values: List<String>): Int {
+	if (values.isEmpty()) return 0
+	val offsets = values.map { builder.createString(it) }.toIntArray()
+	return builder.createVectorOfTables(offsets)
+}