pakstr 0.0.4 → 0.2.0

package/android-template/app/build.gradle.kts

@@ -32,6 +32,7 @@ android {
     }
     buildFeatures {
         compose = true
+        buildConfig = true
     }
 }
 
@@ -56,4 +57,6 @@ dependencies {
 
     implementation(libs.material)
     implementation(libs.androidx.core.splashscreen)
+
+    implementation("org.bouncycastle:bcprov-jdk18on:1.78.1")
 }

package/android-template/app/src/androidTest/java/com/pakstr/app/ExampleInstrumentedTest.kt

@@ -17,8 +17,13 @@ import org.junit.Assert.*
 class ExampleInstrumentedTest {
     @Test
     fun useAppContext() {
-        // Context of the app under test.
-        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("com.makakrug.nostrappshell", appContext.packageName)
+        val appContext =
+            InstrumentationRegistry.getInstrumentation()
+                .targetContext
+
+        assertEquals(
+            "com.pakstr.app",
+            appContext.packageName
+        )
     }
 }

package/android-template/app/src/androidTest/java/com/pakstr/app/signer/NostrEventBuilderTest.kt

@@ -0,0 +1,67 @@
+package com.pakstr.app.signer
+
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+
+class NostrEventBuilderTest {
+
+
+    @Test
+    fun event_id_is_generated() {
+
+
+        val event =
+            JSONObject()
+                .apply {
+
+                    put(
+                        "pubkey",
+                        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                    )
+
+                    put(
+                        "created_at",
+                        1234567890
+                    )
+
+                    put(
+                        "kind",
+                        1
+                    )
+
+                    put(
+                        "tags",
+                        JSONArray()
+                    )
+
+                    put(
+                        "content",
+                        "hello"
+                    )
+
+                }
+
+
+        val result =
+            NostrEventBuilder
+                .addId(event)
+
+
+
+        val id =
+            result.getString(
+                "id"
+            )
+
+
+        assertEquals(
+            64,
+            id.length
+        )
+
+    }
+
+}

package/android-template/app/src/androidTest/java/com/pakstr/app/signer/NostrSignatureVerifierTest.kt

@@ -0,0 +1,43 @@
+package com.pakstr.app.signer
+
+import com.pakstr.app.crypto.NostrSignatureVerifier
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+
+class NostrSignatureVerifierTest {
+
+
+    @Test
+    fun signature_verification_returns_true() {
+
+
+        val valid =
+            NostrSignatureVerifier.verify(
+                eventId = TEST_ID,
+                pubkey = TEST_PUBKEY,
+                signature = TEST_SIGNATURE
+            )
+
+
+        assertTrue(valid)
+
+    }
+
+
+    companion object {
+
+        private const val TEST_ID =
+            "1a3abb615ca8c2bd2f0fe5764df3cc734f3ff5774300e81bb1fad5d8bc948a21"
+
+
+        private const val TEST_PUBKEY =
+            "cb227f60cb2a6d982ecbfc51b9199d340afc00b1ef81b67d8e3778e097e70d2c"
+
+
+        private const val TEST_SIGNATURE =
+            "b64fdbd205c38056b8d366e409e7bf5796cad60789733b377c76c07cd74fe9394bbbfaada66ccd7fa8c3ad008139b9c224b01d7ed95e29d449b2d6b750be0e6f"
+
+    }
+
+}

package/android-template/app/src/main/AndroidManifest.xml

@@ -1,8 +1,20 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
-    <uses-permission android:name="android.permission.INTERNET"/>
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+
+    <queries>
+        <package android:name="com.greenart7c3.nostrsigner" />
+        <intent>
+            <action android:name="com.greenart7c3.nostrsigner.GET_PUBLIC_KEY" />
+        </intent>
+        <intent>
+            <action android:name="com.greenart7c3.nostrsigner.SIGN_EVENT" />
+        </intent>
+
+    </queries>
 
     <application
         android:name=".ApplicationClass"
@@ -11,9 +23,9 @@
         android:fullBackupContent="@xml/backup_rules"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
+        android:networkSecurityConfig="@xml/network_security_config"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:networkSecurityConfig="@xml/network_security_config"
         android:usesCleartextTraffic="true">
 
         <activity

package/android-template/app/src/main/assets/nip07.js

@@ -9,7 +9,10 @@
 
             const id = crypto.randomUUID();
 
-            pending.set(id, { resolve, reject });
+            pending.set(id, {
+                resolve,
+                reject
+            });
 
             window.AndroidBridge.call(
                 method,
@@ -20,16 +23,94 @@
     }
 
     window.__nostrResolve = (id, result) => {
+
         const p = pending.get(id);
         if (!p) return;
 
         pending.delete(id);
+
+        try {
+            const parsed = JSON.parse(result);
+
+            if (parsed.error) {
+                p.reject(parsed);
+                return;
+            }
+
+        } catch (_) {
+            // Normal string response
+        }
+
         p.resolve(result);
     };
 
     window.nostr = {
-        getPublicKey: () => callNative("getPublicKey"),
-        signEvent: (e) => callNative("signEvent", e)
+
+        getPublicKey: async () => {
+            return await callNative("getPublicKey");
+        },
+
+        signEvent: async (event) => {
+
+            const result = await callNative(
+                "signEvent",
+                event
+            );
+
+            return JSON.parse(result);
+        },
+
+        nip04: {
+
+            encrypt: async (pubkey, plaintext) => {
+
+                return await callNative(
+                    "nip04_encrypt",
+                    {
+                        pubkey,
+                        plaintext
+                    }
+                );
+            },
+
+            decrypt: async (pubkey, ciphertext) => {
+
+                return await callNative(
+                    "nip04_decrypt",
+                    {
+                        pubkey,
+                        ciphertext
+                    }
+                );
+            }
+
+        },
+
+        nip44: {
+
+            encrypt: async (pubkey, plaintext) => {
+
+                return await callNative(
+                    "nip44_encrypt",
+                    {
+                        pubkey,
+                        plaintext
+                    }
+                );
+            },
+
+            decrypt: async (pubkey, ciphertext) => {
+
+                return await callNative(
+                    "nip44_decrypt",
+                    {
+                        pubkey,
+                        ciphertext
+                    }
+                );
+            }
+
+        }
     };
 
-})();
+})();

package/android-template/app/src/main/assets/www/index.html

@@ -0,0 +1,215 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Pakstr NIP-07 Test</title>
+
+    <style>
+        body {
+            font-family: sans-serif;
+            padding: 20px;
+        }
+
+        button {
+            padding: 12px;
+            margin: 8px;
+            font-size: 16px;
+        }
+
+        pre {
+            background: #eee;
+            padding: 10px;
+            white-space: pre-wrap;
+            word-break: break-word;
+        }
+    </style>
+</head>
+
+<body>
+
+<h2>🚀 Pakstr NIP-07 Test</h2>
+
+
+<button onclick="getPublicKey()">
+    Get Public Key
+</button>
+
+
+<button onclick="signEvent()">
+    Sign Event
+</button>
+
+<pre id="output">
+Waiting...
+</pre>
+
+
+<script>
+
+
+    function log(data) {
+
+        document.getElementById("output").innerText =
+            typeof data === "string"
+                ? data
+                : JSON.stringify(data, null, 2);
+
+        console.log(data);
+
+    }
+
+
+    // Check provider after Pakstr injection
+    setTimeout(() => {
+
+        console.log(
+            "Nostr provider:",
+            window.nostr
+        );
+
+    }, 2000);
+
+
+
+    async function getPublicKey() {
+
+        try {
+
+            log("Requesting public key...");
+
+
+            if (!window.nostr) {
+
+                throw new Error(
+                    "Nostr provider not available"
+                );
+
+            }
+
+
+            const pubkey =
+                await window.nostr.getPublicKey();
+
+
+            log({
+
+                success: true,
+
+                pubkey,
+
+                length:
+                    pubkey.length,
+
+                format:
+                    pubkey.startsWith("npub")
+                        ? "npub"
+                        : "hex"
+
+            });
+
+
+        } catch (e) {
+
+            log({
+
+                error:
+                    e.message
+
+            });
+
+        }
+
+    }
+
+
+
+
+    async function signEvent() {
+
+        try {
+
+            log("Signing event...");
+
+
+            if (!window.nostr) {
+
+                throw new Error(
+                    "Nostr provider not available"
+                );
+
+            }
+
+
+            const pubkey =
+                await window.nostr.getPublicKey();
+
+
+            const event = {
+
+                pubkey,
+
+                kind: 1,
+
+                content:
+                    "Hello from Pakstr NIP-07",
+
+                tags: [],
+
+                created_at:
+                    Math.floor(
+                        Date.now() / 1000
+                    )
+
+            };
+
+
+            console.log(
+                "Unsigned event",
+                event
+            );
+
+
+            const signedEvent =
+                await window.nostr.signEvent(
+                    event
+                );
+
+
+            console.log(
+                "Signed event",
+                signedEvent
+            );
+
+
+            log({
+
+                success: true,
+
+                signedEvent
+
+            });
+
+
+        } catch (e) {
+
+            console.error(e);
+
+
+            log({
+
+                error:
+                    e.message,
+
+                stack:
+                    e.stack
+
+            });
+
+        }
+}
+
+
+</script>
+
+</body>
+</html>

package/android-template/app/src/main/java/com/pakstr/app/ApplicationClass.kt

@@ -1,11 +1,13 @@
 package com.pakstr.app
 
 import android.app.Application
+import com.pakstr.app.crypto.CryptoInitializer
 import com.pakstr.app.utils.AppPreferences
 
 class ApplicationClass : Application() {
     override fun onCreate() {
         super.onCreate()
         AppPreferences.init(this)
+        CryptoInitializer.init()
     }
 }

package/android-template/app/src/main/java/com/pakstr/app/LocalServer.kt

@@ -10,7 +10,9 @@ class LocalServer(private val context: Context, port: Int) : NanoHTTPD(port) {
 
     override fun serve(session: IHTTPSession?): Response {
         // Fallback to root if URI is null
-        val uri = session?.uri ?: "/"
+        val uri =
+            (session?.uri ?: "/")
+                .replace("..", "")
 
         // Map the root URL to index.html, otherwise target the requested file in the assets folder
         val filePath = when {
@@ -38,14 +40,37 @@ class LocalServer(private val context: Context, port: Int) : NanoHTTPD(port) {
     /**
      * Automatically detects the correct MIME type based on the file extension.
      */
-    private fun getMimeType(file: String): String {
-        // Extract extension from file path (e.g., "style.css" -> "css")
-        val extension = MimeTypeMap.getFileExtensionFromUrl(file)
-            ?.lowercase(Locale.ROOT)
-            ?: ""
-
-        // Use Android's built-in map to resolve the exact MIME type (handles PNG, JPG, JSON, WOFF2, etc.) [1]
-        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension)
-            ?: "application/octet-stream" // Standard fallback for unknown binary files
+    private fun getMimeType(
+        file: String
+    ): String {
+
+        val extension =
+            MimeTypeMap
+                .getFileExtensionFromUrl(file)
+                ?.lowercase(Locale.ROOT)
+                ?: ""
+
+        return when (extension) {
+            "js" ->
+                "application/javascript"
+
+            "json" ->
+                "application/json"
+
+            "css" ->
+                "text/css"
+
+            "html" ->
+                "text/html"
+
+            "svg" ->
+                "image/svg+xml"
+
+            else ->
+                MimeTypeMap
+                    .getSingleton()
+                    .getMimeTypeFromExtension(extension)
+                    ?: "application/octet-stream"
+        }
     }
 }