pakstr 0.20.0 → 0.21.1

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

@@ -0,0 +1,74 @@
+package com.pakstr.app.crypto
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal object NostrEventSerializer {
+    fun serialize(event: JSONObject): String {
+        val output = StringBuilder()
+        output.append("[0,")
+        appendString(output, event.getString("pubkey"))
+        output.append(',')
+        output.append(event.getLong("created_at"))
+        output.append(',')
+        output.append(event.getInt("kind"))
+        output.append(',')
+        appendTags(output, event.getJSONArray("tags"))
+        output.append(',')
+        appendString(output, event.getString("content"))
+        output.append(']')
+        return output.toString()
+    }
+
+    private fun appendTags(
+        output: StringBuilder,
+        tags: JSONArray
+    ) {
+        output.append('[')
+        for (tagIndex in 0 until tags.length()) {
+            if (tagIndex > 0) output.append(',')
+            val tag = tags.getJSONArray(tagIndex)
+            output.append('[')
+            for (valueIndex in 0 until tag.length()) {
+                if (valueIndex > 0) output.append(',')
+                appendString(
+                    output,
+                    tag.getString(valueIndex)
+                )
+            }
+            output.append(']')
+        }
+        output.append(']')
+    }
+
+    private fun appendString(
+        output: StringBuilder,
+        value: String
+    ) {
+        output.append('"')
+        value.forEach { character ->
+            when (character) {
+                '"' -> output.append("\\\"")
+                '\\' -> output.append("\\\\")
+                '\b' -> output.append("\\b")
+                '' -> output.append("\\f")
+                '\n' -> output.append("\\n")
+                '\r' -> output.append("\\r")
+                '\t' -> output.append("\\t")
+                else -> {
+                    if (character.code < 0x20) {
+                        output.append("\\u")
+                        output.append(
+                            character.code
+                                .toString(16)
+                                .padStart(4, '0')
+                        )
+                    } else {
+                        output.append(character)
+                    }
+                }
+            }
+        }
+        output.append('"')
+    }
+}

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

@@ -60,4 +60,104 @@ object Secp256k1 {
             .field
             .characteristic
 
+    internal fun privateScalar(
+        privateKey: ByteArray
+    ): BigInteger {
+        require(privateKey.size == 32) {
+            "Private key must be 32 bytes"
+        }
+
+        val scalar = BigInteger(1, privateKey)
+        require(
+            scalar.signum() > 0 && scalar < N
+        ) {
+            "Invalid private key"
+        }
+
+        return scalar
+    }
+
+    internal fun publicPoint(
+        privateKey: ByteArray
+    ): ECPoint {
+        return G
+            .multiply(privateScalar(privateKey))
+            .normalize()
+    }
+
+    internal fun xOnlyPublicKey(
+        privateKey: ByteArray
+    ): ByteArray {
+        return fixedSizeBytes(
+            publicPoint(privateKey)
+                .affineXCoord
+                .toBigInteger()
+        )
+    }
+
+    internal fun liftX(
+        xBytes: ByteArray
+    ): ECPoint {
+        require(xBytes.size == 32) {
+            "Public key must be 32 bytes"
+        }
+
+        val x = BigInteger(1, xBytes)
+        require(x < P) {
+            "Invalid x coordinate"
+        }
+
+        val curve = CURVE.curve
+        val alpha =
+            x.modPow(BigInteger.valueOf(3), P)
+                .add(curve.b.toBigInteger())
+                .mod(P)
+        var y =
+            alpha.modPow(
+                P.add(BigInteger.ONE)
+                    .divide(BigInteger.valueOf(4)),
+                P
+            )
+
+        require(y.multiply(y).mod(P) == alpha) {
+            "Invalid public key"
+        }
+
+        if (y.testBit(0)) {
+            y = P.subtract(y)
+        }
+
+        val point = curve.createPoint(x, y)
+        require(!point.isInfinity && point.isValid) {
+            "Invalid public key"
+        }
+
+        return point
+    }
+
+    internal fun fixedSizeBytes(
+        value: BigInteger
+    ): ByteArray {
+        require(value.signum() >= 0) {
+            "Value must not be negative"
+        }
+
+        val encoded = value.toByteArray()
+        val offset =
+            if (encoded.size > 32 && encoded[0] == 0.toByte()) 1
+            else 0
+        val length = encoded.size - offset
+
+        require(length <= 32) {
+            "Value does not fit in 32 bytes"
+        }
+
+        return ByteArray(32).also { output ->
+            encoded.copyInto(
+                output,
+                destinationOffset = 32 - length,
+                startIndex = offset
+            )
+        }
+    }
 }

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

@@ -1,42 +1,67 @@
 package com.pakstr.app.signer
 
 import android.content.Context
+import com.pakstr.app.signer.bunker.Nip46Client
+import com.pakstr.app.signer.bunker.UnavailableNip46Client
 import com.pakstr.app.signer.interfaces.NostrSigner
 
-class BunkerSigner(context: Context) : NostrSigner {
+class BunkerSigner(
+    @Suppress("UNUSED_PARAMETER") context: Context,
+    private val client: Nip46Client = UnavailableNip46Client
+) : NostrSigner {
     override suspend fun getPublicKey(): String {
-        TODO("Not yet implemented")
+        return client.getPublicKey()
     }
 
     override suspend fun signEvent(eventJson: String): String {
-        TODO("Not yet implemented")
+        return client.signEvent(eventJson)
     }
 
     override suspend fun nip04Encrypt(
         pubkey: String,
         plaintext: String
     ): String {
-        TODO("Not yet implemented")
+        return client.nip04Encrypt(
+            pubkey,
+            plaintext
+        )
     }
 
     override suspend fun nip04Decrypt(
         pubkey: String,
         ciphertext: String
     ): String {
-        TODO("Not yet implemented")
+        return client.nip04Decrypt(
+            pubkey,
+            ciphertext
+        )
     }
 
     override suspend fun nip44Encrypt(
         pubkey: String,
         plaintext: String
     ): String {
-        TODO("Not yet implemented")
+        return client.nip44Encrypt(
+            pubkey,
+            plaintext
+        )
     }
 
     override suspend fun nip44Decrypt(
         pubkey: String,
         ciphertext: String
     ): String {
-        TODO("Not yet implemented")
+        return client.nip44Decrypt(
+            pubkey,
+            ciphertext
+        )
+    }
+
+    fun disconnect() {
+        client.disconnect()
+    }
+
+    fun close() {
+        client.close()
     }
 }

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

@@ -337,6 +337,11 @@ class NostrBridge(
                             result
                         )
 
+                    } catch (e: SignerUnavailableException) {
+                        resolve(
+                            callbackId,
+                            signerErrorResponse(e)
+                        )
                     } catch (e: Exception) {
                         AppDebugLogger.error(
 
@@ -351,10 +356,7 @@ class NostrBridge(
                         )
                         resolve(
                             callbackId,
-                            errorResponse(
-                                "SIGNER_ERROR",
-                                e.message ?: ""
-                            )
+                            signerErrorResponse(e)
                         )
                     }
                 }
@@ -390,6 +392,11 @@ class NostrBridge(
                             result
                         )
 
+                    } catch (e: SignerUnavailableException) {
+                        resolve(
+                            callbackId,
+                            signerErrorResponse(e)
+                        )
                     } catch (e: Exception) {
                         AppDebugLogger.error(
 
@@ -404,10 +411,7 @@ class NostrBridge(
                         )
                         resolve(
                             callbackId,
-                            errorResponse(
-                                "SIGNER_ERROR",
-                                e.message ?: ""
-                            )
+                            signerErrorResponse(e)
                         )
                     }
                 }
@@ -503,4 +507,27 @@ class NostrBridge(
             }
             .toString()
     }
-}
+
+    companion object {
+        internal fun signerErrorResponse(error: Exception): String {
+            return JSONObject()
+                .put(
+                    "error",
+                    if (error is SignerUnavailableException) {
+                        "SIGNER_UNAVAILABLE"
+                    } else {
+                        "SIGNER_ERROR"
+                    }
+                )
+                .put(
+                    "message",
+                    error.message ?: if (error is SignerUnavailableException) {
+                        "Signer unavailable"
+                    } else {
+                        "Unknown signer error"
+                    }
+                )
+                .toString()
+        }
+    }
+}