feat: add a SubmissionEvent that carries a nip30303 event as its payload

Every nip30303 kind so far describes a thing: an artifact, a dialect, a
chapter, a translated chunk. None of them describes the act of putting
one in front of a group, and until now nothing needed to -- a group
event's sender was the author of the event inside it, so the two
questions had one answer by construction.

That construction is also the limit. It means a group can only ever hold
work written by its own members under their own keys. A translation
lifted from a public archive, a chapter transcribed by an outside
contributor, an artifact somebody published years ago: none of it can go
in without a member re-authoring it and taking the byline.

Kind 30312 is the envelope that separates them. Its content is the
payload event's JSON, whole -- same id, same pubKey, same signature,
nothing rewritten to look like the submitter's work. The submitter signs
for the envelope; the author still signs for the event. Two tags name
what is inside so a client can decide whether it can apply a submission
without parsing the content first:

  payloadKind   the payload's kind
  payloadId     the payload's id, with the author slot carrying the
                payload's author -- who, unusually for an id tag in
                this package, is often not the event's sender

Kinds 30300-30311 are taken (30305 and 30307 by contributor lists), so
30312 is the next free one.

A submission is not an endorsement and grants nothing. Who may submit is
the group's business; this only makes the question expressible.

The test covers the property the whole thing rests on: an event written
by an outsider goes into an envelope, comes out of a JSON round trip
with its id, author and signature intact, and does not acquire the
submitter as its author. It also pins payload() returning null rather
than something empty when the content will not parse -- which needed
android.util.Log stubbing, since quartz logs on that path and unmocked
Log methods throw, failing the test on the log line rather than on what
it came to check.

Nothing sends or reads one yet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

composeApp/src/commonTest/kotlin/press/mantra/compose/nostr/nip30303/SubmissionEventTest.kt

@@ -0,0 +1,126 @@
+package press.mantra.compose.nostr.nip30303
+
+import com.vitorpamplona.quartz.nip01Core.core.Event
+import com.vitorpamplona.quartz.nip01Core.crypto.EventHasher
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotEquals
+import kotlin.test.assertNull
+
+/**
+ * What a submission has to survive: the trip through a group.
+ *
+ * The envelope is only worth having if the event inside it comes out the other
+ * side unchanged -- same id, same author, same signature. The moment any of
+ * those is rewritten in transit, a group can no longer hold work by anyone but
+ * its own members, which is the whole reason submissions exist.
+ */
+class SubmissionEventTest {
+    private val submitter = "a".repeat(64)
+    private val outsider = "b".repeat(64)
+
+    /** A dialect written by somebody who is not in the group. */
+    private fun outsiderDialect(): Event {
+        val template = DialectEvent.build(
+            name = "Sesotho",
+            country = "Lesotho",
+            language = "st",
+            createdAt = 1_700_000_000L,
+        )
+        return Event(
+            id = EventHasher.hashId(
+                pubKey = outsider,
+                createdAt = template.createdAt,
+                kind = template.kind,
+                tags = template.tags,
+                content = template.content,
+            ),
+            pubKey = outsider,
+            createdAt = template.createdAt,
+            kind = template.kind,
+            tags = template.tags,
+            content = template.content,
+            sig = "c".repeat(128),
+        )
+    }
+
+    /** Send a submission template and read it back the way inbound does. */
+    private fun roundTrip(payload: Event): SubmissionEvent {
+        val template = SubmissionEvent.build(payload = payload, createdAt = 1_700_000_100L)
+        val onTheWire = Event.fromJson(
+            Event(
+                id = EventHasher.hashId(
+                    pubKey = submitter,
+                    createdAt = template.createdAt,
+                    kind = template.kind,
+                    tags = template.tags,
+                    content = template.content,
+                ),
+                pubKey = submitter,
+                createdAt = template.createdAt,
+                kind = template.kind,
+                tags = template.tags,
+                content = template.content,
+                sig = "",
+            ).toJson()
+        )
+
+        return SubmissionEvent(
+            id = onTheWire.id,
+            pubKey = onTheWire.pubKey,
+            createdAt = onTheWire.createdAt,
+            tags = onTheWire.tags,
+            content = onTheWire.content,
+            sig = onTheWire.sig,
+        )
+    }
+
+    @Test
+    fun `the payload comes back as the event that went in`() {
+        val dialect = outsiderDialect()
+
+        val payload = roundTrip(dialect).payload()
+
+        assertEquals(dialect.id, payload?.id)
+        assertEquals(dialect.pubKey, payload?.pubKey)
+        assertEquals(dialect.kind, payload?.kind)
+        assertEquals(dialect.content, payload?.content)
+        assertEquals(dialect.sig, payload?.sig)
+    }
+
+    @Test
+    fun `submitting does not make the submitter the author`() {
+        val dialect = outsiderDialect()
+
+        val submission = roundTrip(dialect)
+
+        assertEquals(submitter, submission.pubKey)
+        assertEquals(outsider, submission.payload()?.pubKey)
+        assertNotEquals(submission.pubKey, submission.payload()?.pubKey)
+    }
+
+    @Test
+    fun `the envelope names what it carries without being opened`() {
+        val dialect = outsiderDialect()
+
+        val submission = roundTrip(dialect)
+
+        assertEquals(DialectEvent.KIND, submission.payloadKind())
+        assertEquals(dialect.id, submission.payloadId())
+        assertEquals(outsider, submission.payloadAuthor())
+    }
+
+    @Test
+    fun `a payload the group cannot read is null rather than empty`() {
+        val submission = SubmissionEvent(
+            id = "d".repeat(64),
+            pubKey = submitter,
+            createdAt = 1_700_000_100L,
+            tags = arrayOf(),
+            content = "not an event",
+            sig = "",
+        )
+
+        assertNull(submission.payload())
+    }
+}