diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 00000000..a469d63b
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,9 @@
+# EditorConfig is awesome: https://editorconfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*.{kt,kts}]
+indent_size = 4
+indent_style = space
+max_line_length = 120
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/build.gradle.kts b/multiplatform-crypto-libsodium-bindings/build.gradle.kts
index 4fbeb9a4..2b39ae88 100644
--- a/multiplatform-crypto-libsodium-bindings/build.gradle.kts
+++ b/multiplatform-crypto-libsodium-bindings/build.gradle.kts
@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
 import org.jetbrains.kotlin.gradle.targets.native.tasks.KotlinNativeTest
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
-import org.jetbrains.dokka.Platform
 
 plugins {
     kotlin(PluginsDeps.multiplatform)
@@ -672,15 +671,16 @@ tasks {
 
     }
 
-    if (getHostOsName() == "linux" && getHostArchitecture() == "x86-64") {
-        val jvmTest by getting(Test::class) {
-            testLogging {
-                events("PASSED", "FAILED", "SKIPPED")
-                exceptionFormat = TestExceptionFormat.FULL
-                showStandardStreams = true
-                showStackTraces = true
-            }
+    val jvmTest by getting(Test::class) {
+        testLogging {
+            events("PASSED", "FAILED", "SKIPPED")
+            exceptionFormat = TestExceptionFormat.FULL
+            showStandardStreams = true
+            showStackTraces = true
         }
+    }
+
+    if (getHostOsName() == "linux" && getHostArchitecture() == "x86-64") {
 
         val linuxX64Test by getting(KotlinNativeTest::class) {
 
diff --git a/multiplatform-crypto-libsodium-bindings/src/commonMain/kotlin/com.ionspin.kotlin.crypto/ed25519/Ed25519.kt b/multiplatform-crypto-libsodium-bindings/src/commonMain/kotlin/com.ionspin.kotlin.crypto/ed25519/Ed25519.kt
new file mode 100644
index 00000000..27bfca2d
--- /dev/null
+++ b/multiplatform-crypto-libsodium-bindings/src/commonMain/kotlin/com.ionspin.kotlin.crypto/ed25519/Ed25519.kt
@@ -0,0 +1,150 @@
+package com.ionspin.kotlin.crypto.ed25519
+
+import com.ionspin.kotlin.crypto.util.LibsodiumUtil
+
+/**
+ * Created by Johannes Leupold
+ * johannes.leupold@kobil.com
+ * on 12-Aug-2024
+ */
+
+const val crypto_core_ed25519_BYTES = 32
+const val crypto_core_ed25519_UNIFORMBYTES = 32
+const val crypto_core_ed25519_HASHBYTES = 64
+const val crypto_core_ed25519_SCALARBYTES = 32
+const val crypto_core_ed25519_NONREDUCEDSCALARBYTES = 64
+
+const val crypto_scalarmult_ed25519_BYTES = 32U
+const val crypto_scalarmult_ed25519_SCALARBYTES = 32U
+
+expect object Ed25519LowLevel {
+    fun isValidPoint(encoded: UByteArray): Boolean
+    fun addPoints(p: UByteArray, q: UByteArray): UByteArray
+    fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray
+    fun pointFromUniform(uniform: UByteArray): UByteArray
+    fun randomPoint(): UByteArray
+    fun randomScalar(): UByteArray
+    fun invertScalar(scalar: UByteArray): UByteArray
+    fun negateScalar(scalar: UByteArray): UByteArray
+    fun complementScalar(scalar: UByteArray): UByteArray
+    fun addScalars(x: UByteArray, y: UByteArray): UByteArray
+    fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray
+    fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray
+    fun reduceScalar(scalar: UByteArray): UByteArray
+    fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray
+    fun scalarMultiplicationNoClamp(n: UByteArray, p: UByteArray): UByteArray
+    fun scalarMultiplicationBase(n: UByteArray): UByteArray
+    fun scalarMultiplicationBaseNoClamp(n: UByteArray): UByteArray
+}
+
+object Ed25519 {
+    data class Point(val encoded: UByteArray) {
+        companion object {
+            val IDENTITY: Point = Point(UByteArray(crypto_core_ed25519_BYTES))
+            val BASE: Point = multiplyBaseNoClamp(Scalar.ONE)
+
+            fun fromUniform(uniform: UByteArray): Point = Point(Ed25519LowLevel.pointFromUniform(uniform))
+
+            fun random(): Point = Point(Ed25519LowLevel.randomPoint())
+
+            fun multiplyBase(n: Scalar): Point = Point(Ed25519LowLevel.scalarMultiplicationBase(n.encoded))
+
+            fun multiplyBaseNoClamp(n: Scalar): Point =
+                Point(Ed25519LowLevel.scalarMultiplicationBaseNoClamp(n.encoded))
+
+            fun fromHex(hex: String): Point = Point(LibsodiumUtil.fromHex(hex))
+        }
+
+        val isValid: Boolean
+            get() = Ed25519LowLevel.isValidPoint(encoded)
+
+        operator fun plus(q: Point): Point = Point(Ed25519LowLevel.addPoints(this.encoded, q.encoded))
+        operator fun minus(q: Point): Point = Point(Ed25519LowLevel.subtractPoints(this.encoded, q.encoded))
+
+        operator fun times(n: Scalar): Point = Point(Ed25519LowLevel.scalarMultiplication(n.encoded, this.encoded))
+        fun times(n: Scalar, clamp: Boolean): Point =
+            if (clamp) times(n) else Point(Ed25519LowLevel.scalarMultiplicationNoClamp(n.encoded, this.encoded))
+
+        fun toHex(): String = LibsodiumUtil.toHex(encoded)
+
+        override fun equals(other: Any?): Boolean = (other as? Point)?.encoded?.contentEquals(encoded) == true
+        override fun hashCode(): Int = encoded.contentHashCode()
+    }
+
+    data class Scalar(val encoded: UByteArray) {
+        companion object {
+            val ZERO = fromUInt(0U)
+            val ONE = fromUInt(1U)
+            val TWO = fromUInt(2U)
+
+            fun random(): Scalar = Scalar(Ed25519LowLevel.randomScalar())
+
+            fun fromUInt(i: UInt): Scalar = fromULong(i.toULong())
+
+            fun fromULong(l: ULong): Scalar {
+                val encoded = UByteArray(crypto_core_ed25519_SCALARBYTES)
+                var rem = l
+
+                for (i in 0..7) {
+                    encoded[i] = (rem and 0xffU).toUByte()
+                    rem = rem shr 8
+                }
+
+                return Scalar(encoded)
+            }
+
+            fun fromHex(hex: String): Scalar {
+                require(hex.length <= 2 * crypto_core_ed25519_NONREDUCEDSCALARBYTES) {
+                    "Scalars must be at most $crypto_core_ed25519_NONREDUCEDSCALARBYTES bytes long"
+                }
+
+                if (hex.length > 2 * crypto_core_ed25519_SCALARBYTES) {
+                    val encoded = LibsodiumUtil.fromHex(hex.padEnd(2 * crypto_core_ed25519_NONREDUCEDSCALARBYTES, '0'))
+                    // Scalars are encoded in little-endian order, so the end can be padded with zeroes up to the size of a
+                    // non-reduced scalar. After decoding, it is reduced, to obtain a scalar in the canonical range
+                    return Scalar(Ed25519LowLevel.reduceScalar(encoded))
+                } else {
+                    val encoded = LibsodiumUtil.fromHex(hex.padEnd(2 * crypto_core_ed25519_SCALARBYTES, '0'))
+                    // Scalars are encoded in little-endian order, so the end can be padded with zeroes up to the size of a
+                    // scalar.
+                    return Scalar(encoded)
+                }
+            }
+        }
+
+        operator fun plus(y: Scalar): Scalar = Scalar(Ed25519LowLevel.addScalars(this.encoded, y.encoded))
+        operator fun plus(y: UInt): Scalar = this + fromUInt(y)
+        operator fun plus(y: ULong): Scalar = this + fromULong(y)
+
+        operator fun minus(y: Scalar): Scalar = Scalar(Ed25519LowLevel.subtractScalars(this.encoded, y.encoded))
+        operator fun minus(y: UInt): Scalar = this - fromUInt(y)
+        operator fun minus(y: ULong): Scalar = this - fromULong(y)
+
+        operator fun times(y: Scalar): Scalar = Scalar(Ed25519LowLevel.multiplyScalars(this.encoded, y.encoded))
+        operator fun times(y: UInt): Scalar = this * fromUInt(y)
+        operator fun times(y: ULong): Scalar = this * fromULong(y)
+
+        operator fun div(y: Scalar): Scalar = times(y.invert())
+        operator fun div(y: UInt): Scalar = this / fromUInt(y)
+        operator fun div(y: ULong): Scalar = this / fromULong(y)
+
+        operator fun unaryMinus(): Scalar = Scalar(Ed25519LowLevel.negateScalar(this.encoded))
+
+        operator fun times(p: Point): Point = p.times(this)
+        fun times(p: Point, clamp: Boolean): Point =
+            if (clamp) p.times(this) else p.times(this, clamp)
+
+        fun reduce(): Scalar = Scalar(Ed25519LowLevel.reduceScalar(this.encoded))
+        fun invert(): Scalar = Scalar(Ed25519LowLevel.invertScalar(this.encoded))
+        fun complement(): Scalar = Scalar(Ed25519LowLevel.complementScalar(this.encoded))
+
+        fun multiplyWithBase(): Point = Point.multiplyBase(this)
+
+        fun multiplyWithBaseNoClamp(): Point = Point.multiplyBaseNoClamp(this)
+
+        fun toHex(): String = LibsodiumUtil.toHex(encoded)
+
+        override fun equals(other: Any?): Boolean = (other as? Scalar)?.encoded?.contentEquals(encoded) == true
+        override fun hashCode(): Int = encoded.contentHashCode()
+    }
+}
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/src/commonMain/kotlin/com.ionspin.kotlin.crypto/ristretto255/Ristretto255.kt b/multiplatform-crypto-libsodium-bindings/src/commonMain/kotlin/com.ionspin.kotlin.crypto/ristretto255/Ristretto255.kt
new file mode 100644
index 00000000..faa1c9f0
--- /dev/null
+++ b/multiplatform-crypto-libsodium-bindings/src/commonMain/kotlin/com.ionspin.kotlin.crypto/ristretto255/Ristretto255.kt
@@ -0,0 +1,141 @@
+package com.ionspin.kotlin.crypto.ristretto255
+
+import com.ionspin.kotlin.crypto.util.LibsodiumUtil
+
+/**
+ * Created by Johannes Leupold
+ * johannes.leupold@kobil.com
+ * on 12-Aug-2024
+ */
+
+const val crypto_core_ristretto255_BYTES = 32
+const val crypto_core_ristretto255_HASHBYTES = 64
+const val crypto_core_ristretto255_SCALARBYTES = 32
+const val crypto_core_ristretto255_NONREDUCEDSCALARBYTES = 64
+
+const val crypto_scalarmult_ristretto255_BYTES = 32U
+const val crypto_scalarmult_ristretto255_SCALARBYTES = 32U
+
+expect object Ristretto255LowLevel {
+    fun isValidPoint(encoded: UByteArray): Boolean
+    fun addPoints(p: UByteArray, q: UByteArray): UByteArray
+    fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray
+    fun pointFromHash(hash: UByteArray): UByteArray
+    fun randomPoint(): UByteArray
+    fun randomScalar(): UByteArray
+    fun invertScalar(scalar: UByteArray): UByteArray
+    fun negateScalar(scalar: UByteArray): UByteArray
+    fun complementScalar(scalar: UByteArray): UByteArray
+    fun addScalars(x: UByteArray, y: UByteArray): UByteArray
+    fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray
+    fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray
+    fun reduceScalar(scalar: UByteArray): UByteArray
+    fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray
+    fun scalarMultiplicationBase(n: UByteArray): UByteArray
+}
+
+object Ristretto255 {
+    data class Point(val encoded: UByteArray) {
+        companion object {
+            val IDENTITY: Point = Point(UByteArray(crypto_core_ristretto255_BYTES))
+            val BASE: Point = multiplyBase(Scalar.ONE)
+
+            fun fromHash(hash: UByteArray): Point = Point(Ristretto255LowLevel.pointFromHash(hash))
+
+            fun random(): Point = Point(Ristretto255LowLevel.randomPoint())
+
+            fun multiplyBase(n: Scalar): Point = Point(Ristretto255LowLevel.scalarMultiplicationBase(n.encoded))
+
+            fun fromHex(hex: String): Point = Point(LibsodiumUtil.fromHex(hex))
+        }
+
+        val isValid: Boolean
+            get() = Ristretto255LowLevel.isValidPoint(this.encoded)
+
+        operator fun plus(q: Point): Point = Point(Ristretto255LowLevel.addPoints(this.encoded, q.encoded))
+        operator fun minus(q: Point): Point = Point(Ristretto255LowLevel.subtractPoints(this.encoded, q.encoded))
+
+        operator fun times(n: Scalar): Point = Point(Ristretto255LowLevel.scalarMultiplication(n.encoded, this.encoded))
+
+        fun toHex(): String = LibsodiumUtil.toHex(encoded)
+
+        override fun equals(other: Any?): Boolean = (other as? Point)?.encoded?.contentEquals(encoded) == true
+        override fun hashCode(): Int = encoded.contentHashCode()
+    }
+
+    data class Scalar(val encoded: UByteArray) {
+        companion object {
+            val ZERO = fromUInt(0U)
+            val ONE = fromUInt(1U)
+            val TWO = fromUInt(2U)
+
+            fun random(): Scalar = Scalar(Ristretto255LowLevel.randomScalar())
+
+            fun fromUInt(i: UInt): Scalar = fromULong(i.toULong())
+
+            fun fromULong(l: ULong): Scalar {
+                val encoded = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+                var rem = l
+
+                for (i in 0..7) {
+                    encoded[i] = (rem and 0xffU).toUByte()
+                    rem = rem shr 8
+                }
+
+                return Scalar(encoded)
+            }
+
+            fun fromHex(hex: String): Scalar {
+                require(hex.length <= 2 * crypto_core_ristretto255_NONREDUCEDSCALARBYTES) {
+                    "Scalars must be at most $crypto_core_ristretto255_NONREDUCEDSCALARBYTES bytes long"
+                }
+
+                if (hex.length > 2 * crypto_core_ristretto255_SCALARBYTES) {
+                    val encoded =
+                        LibsodiumUtil.fromHex(hex.padEnd(2 * crypto_core_ristretto255_NONREDUCEDSCALARBYTES, '0'))
+                    // Scalars are encoded in little-endian order, so the end can be padded with zeroes up to the size of a
+                    // non-reduced scalar. After decoding, it is reduced, to obtain a scalar in the canonical range
+                    return Scalar(Ristretto255LowLevel.reduceScalar(encoded))
+                } else {
+                    val encoded = LibsodiumUtil.fromHex(hex.padEnd(2 * crypto_core_ristretto255_SCALARBYTES, '0'))
+                    // Scalars are encoded in little-endian order, so the end can be padded with zeroes up to the size of a
+                    // scalar.
+                    return Scalar(encoded)
+                }
+            }
+        }
+
+        operator fun plus(y: Scalar): Scalar = Scalar(Ristretto255LowLevel.addScalars(this.encoded, y.encoded))
+        operator fun plus(y: UInt): Scalar = this + fromUInt(y)
+        operator fun plus(y: ULong): Scalar = this + fromULong(y)
+
+        operator fun minus(y: Scalar): Scalar = Scalar(Ristretto255LowLevel.subtractScalars(this.encoded, y.encoded))
+        operator fun minus(y: UInt): Scalar = this - fromUInt(y)
+        operator fun minus(y: ULong): Scalar = this - fromULong(y)
+
+        operator fun times(y: Scalar): Scalar = Scalar(Ristretto255LowLevel.multiplyScalars(this.encoded, y.encoded))
+        operator fun times(y: UInt): Scalar = this * fromUInt(y)
+        operator fun times(y: ULong): Scalar = this * fromULong(y)
+
+        operator fun div(y: Scalar): Scalar =
+            Scalar(Ristretto255LowLevel.multiplyScalars(this.encoded, y.invert().encoded))
+
+        operator fun div(y: UInt): Scalar = this / fromUInt(y)
+        operator fun div(y: ULong): Scalar = this / fromULong(y)
+
+        operator fun unaryMinus(): Scalar = Scalar(Ristretto255LowLevel.negateScalar(this.encoded))
+
+        operator fun times(p: Point): Point = p.times(this)
+
+        fun reduce(): Scalar = Scalar(Ristretto255LowLevel.reduceScalar(this.encoded))
+        fun invert(): Scalar = Scalar(Ristretto255LowLevel.invertScalar(this.encoded))
+        fun complement(): Scalar = Scalar(Ristretto255LowLevel.complementScalar(this.encoded))
+
+        fun multiplyWithBase(): Point = Point.multiplyBase(this)
+
+        fun toHex(): String = LibsodiumUtil.toHex(encoded)
+
+        override fun equals(other: Any?): Boolean = (other as? Scalar)?.encoded?.contentEquals(encoded) == true
+        override fun hashCode(): Int = encoded.contentHashCode()
+    }
+}
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519Test.kt b/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519Test.kt
new file mode 100644
index 00000000..1eadcd3a
--- /dev/null
+++ b/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519Test.kt
@@ -0,0 +1,243 @@
+package com.ionspin.kotlin.crypto.ed25519
+
+import com.ionspin.kotlin.crypto.LibsodiumInitializer
+import com.ionspin.kotlin.crypto.util.LibsodiumUtil
+import com.ionspin.kotlin.crypto.util.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotEquals
+import kotlin.test.assertTrue
+
+class Ed25519Test {
+    // Test vectors from https://github.com/jedisct1/libsodium/blob/master/test/default/core_ed25519.c
+    val badEncodings = arrayOf(
+        "0000000000000000000000000000000000000000000000000000000000000000",
+        "0100000000000000000000000000000000000000000000000000000000000000",
+        "0200000000000000000000000000000000000000000000000000000000000000",
+        // Non canonical encodings
+        "f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+        "f5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+    )
+
+    // Test vectors generated with sodium.js
+    private val fromUniformTestVectors = arrayOf(
+        "d5d31a04bf9cd6b4f3f014ab57f95d439a0bd741e71f1ecb580143235545255e" to "cb9fff40134270e80e0dcfcdc66aa4ebf02cd27c9d9d26adfdf78d0012ad1b62",
+        "9d2e8fc82097672be7b3eb9b9ac74d0cd22087ce04a202a51e88702dceab88a1" to "6b1f76c95d2a201a25b77e73de875637e250acb8e22c44230b2c21bb5a45bb15",
+        "7863e96b9a73ffb45df22e2692f395d24b5d7acf745c5fa536818fd00e3ba6f6" to "43be765b38f32d815203e1657c261545366f15b24af2a97694b9320b4a36c407",
+        "1dfd309d25f6a2c6e0358cddf8dcf8c0fd018ccc7eb799d71fa829640cb5adb3" to "4c6b7015631f4063d85f3b195c7dfcb699a242b3449dc9b4abce8948df88a28e",
+        "40bc69ec71804975dfcbd90b18ca5d9d0117b2e15cacf61e21960b33742a9d55" to "722b608070036ad2e82927338c5edca18f2d0e6f8ed393321ed3704269af1f29",
+        "06c705d68c6224de01437208d7af2b3d933c1822abbe8f551b584cba073dc645" to "bb713b72bf705cc5a3daf299b787d28d47fdb39dc98a13082657b4137081624f",
+        "e4307d89b2e904063a6a16c9cf09b4225e0b5f4dd2367f08b11bf7787fa626d3" to "f10dea3347ab6792fac62ee6825dad3e4915f15287506db8067ecdbf00f0f30a",
+        "6f61fe548ff2cd7bc64d1d3cf4a707a8efba8247e906042d76e98b730f5d1d4d" to "5c43c14cb548b09ac8180c627bcf76bd7720aca21ef72cc13c5584e34ec23ff6",
+    )
+
+    // Test vectors generated with sodium.js
+    private val basePointSmallMultiplesNoClamp = arrayOf(
+        // This is the basepoint
+        "5866666666666666666666666666666666666666666666666666666666666666",
+        // These are small multiples of the basepoint
+        "c9a3f86aae465f0e56513864510f3997561fa2c9e85ea21dc2292309f3cd6022",
+        "d4b4f5784868c3020403246717ec169ff79e26608ea126a1ab69ee77d1b16712",
+        "2f1132ca61ab38dff00f2fea3228f24c6c71d58085b80e47e19515cb27e8d047",
+        "edc876d6831fd2105d0b4389ca2e283166469289146e2ce06faefe98b22548df",
+        "f47e49f9d07ad2c1606b4d94067c41f9777d4ffda709b71da1d88628fce34d85",
+        "b862409fb5c4c4123df2abf7462b88f041ad36dd6864ce872fd5472be363c5b1",
+        "b4b937fca95b2f1e93e41e62fc3c78818ff38a66096fad6e7973e5c90006d321",
+        "c0f1225584444ec730446e231390781ffdd2f256e9fcbeb2f40dddc2c2233d7f",
+        "2c7be86ab07488ba43e8e03d85a67625cfbf98c8544de4c877241b7aaafc7fe3",
+        "1337036ac32d8f30d4589c3c1c595812ce0fff40e37c6f5a97ab213f318290ad",
+        "f9e42d2edc81d23367967352b47e4856b82578634e6c1de72280ce8b60ce70c0",
+        "801f40eaaee1ef8723279a28b2cf4037b889dad222604678748b53ed0db0db92",
+        "39289c8998fd69835c26b619e89848a7bf02b7cb7ad1ba1581cbc4506f2550ce",
+        "df5c2eadc44c6d94a19a9aa118afe5ac3193d26401f76251f522ff042dfbcb92",
+        "eb2767c137ab7ad8279c078eff116ab0786ead3a2e0f989f72c37f82f2969670",
+    )
+
+    // Test vectors generated with sodium.js
+    // Because of clamping, the lowest three bits of the scalar are cleared to make it a multiple of the cofactor (8)
+    // This makes two scalars yield the same result if they only differ in the lowest three bits. Because of this, for
+    // these test vectors, the scalars used to obtain them are set to s = i * 4 + 1 where i is the index
+    val basePointSmallMultiplesClamped = arrayOf(
+        "693e47972caf527c7883ad1b39822f026f47db2ab0e1919955b8993aa04411d1",
+        "693e47972caf527c7883ad1b39822f026f47db2ab0e1919955b8993aa04411d1",
+        "c9877dfd1ccda6393a15aed8aba06798456798355f2a9da4e182fecd40290157",
+        "c9877dfd1ccda6393a15aed8aba06798456798355f2a9da4e182fecd40290157",
+        "33598cc739b5da481888220cc8d584ba6c385a4c489cb6305446fd78d591bd96",
+        "33598cc739b5da481888220cc8d584ba6c385a4c489cb6305446fd78d591bd96",
+        "b46a44945eaff85c6de56812f8b035f01f6680a6f37f74bc6aa992bd0ef2d32a",
+        "b46a44945eaff85c6de56812f8b035f01f6680a6f37f74bc6aa992bd0ef2d32a",
+        "31b532ff5943a5c73690714ceb6414b99d50b0daee2b2d994ea78adf7ac28f4f",
+        "31b532ff5943a5c73690714ceb6414b99d50b0daee2b2d994ea78adf7ac28f4f",
+        "140fcdae065d38753b1b563c61ab588da04e7b822a5575483d123fb96f30868d",
+        "140fcdae065d38753b1b563c61ab588da04e7b822a5575483d123fb96f30868d",
+        "cb920ec5b5ebcce941d7e84c9ade21d4628c2b020b3c32f7e1b07fbb825c145d",
+        "cb920ec5b5ebcce941d7e84c9ade21d4628c2b020b3c32f7e1b07fbb825c145d",
+        "d479546534fa8a146475623ca938efe42c6d561732088f8c3fd687ffff15210b",
+        "d479546534fa8a146475623ca938efe42c6d561732088f8c3fd687ffff15210b",
+    )
+
+    @Test
+    fun testRandomPoint() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            val p = Ed25519.Point.random()
+            val q = Ed25519.Point.random()
+            val r = Ed25519.Point.random()
+
+            assertNotEquals(p, q)
+            assertNotEquals(q, r)
+            assertNotEquals(r, p)
+
+            assertTrue { p.isValid }
+            assertTrue { q.isValid }
+            assertTrue { r.isValid }
+        }
+    }
+
+    @Test
+    fun testPointHexConversion() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            repeat(10) {
+                val p = Ed25519.Point.random()
+
+                assertEquals(p, Ed25519.Point.fromHex(p.toHex()))
+            }
+        }
+    }
+
+    @Test
+    fun testIsValidPoint() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            for (hexEncoded in badEncodings) {
+                assertFalse { Ed25519.Point.fromHex(hexEncoded).isValid }
+            }
+
+            for (hexEncoded in basePointSmallMultiplesNoClamp) {
+                assertTrue { Ed25519.Point.fromHex(hexEncoded).isValid }
+            }
+
+            for (hexEncoded in basePointSmallMultiplesClamped) {
+                assertTrue { Ed25519.Point.fromHex(hexEncoded).isValid }
+            }
+        }
+    }
+
+    @Test
+    fun testPointArithmeticNoClamp() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            for (i in basePointSmallMultiplesNoClamp.indices) {
+                val p = Ed25519.Point.fromHex(basePointSmallMultiplesNoClamp[i])
+                val b = Ed25519.Point.BASE
+                val n = Ed25519.Scalar.fromUInt(i.toUInt() + 1U)
+
+                assertEquals(p, Ed25519.Point.multiplyBaseNoClamp(n))
+                assertEquals(p, b.times(n, false))
+                assertEquals(p, n.multiplyWithBaseNoClamp())
+
+                for (j in 0..<i) {
+                    val q = Ed25519.Point.fromHex(basePointSmallMultiplesNoClamp[j])
+                    val m = Ed25519.Scalar.fromUInt(i.toUInt() - j.toUInt())
+
+                    assertEquals(p, q + b.times(m, clamp = false))
+                    assertEquals(p, b.times(m, clamp = false) + q)
+                    assertEquals(q, p - b.times(m, clamp = false))
+                }
+
+                for (j in i + 1..<basePointSmallMultiplesNoClamp.size) {
+                    val q = Ed25519.Point.fromHex(basePointSmallMultiplesNoClamp[j])
+                    val m = Ed25519.Scalar.fromUInt(j.toUInt() - i.toUInt())
+
+                    assertEquals(q, p + b.times(m, clamp = false))
+                    assertEquals(q, b.times(m, clamp = false) + p)
+                    assertEquals(p, q - b.times(m, clamp = false))
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testPointArithmeticClamped() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            for (i in basePointSmallMultiplesNoClamp.indices) {
+                println("i: $i")
+                val p = Ed25519.Point.fromHex(basePointSmallMultiplesClamped[i])
+                val b = Ed25519.Point.BASE
+                val n = Ed25519.Scalar.fromUInt(i.toUInt() * 4U + 1U)
+
+                assertEquals(p, Ed25519.Point.multiplyBase(n))
+                assertEquals(p, b.times(n))
+                assertEquals(p, n.multiplyWithBase())
+            }
+        }
+    }
+
+    @Test
+    fun testPointFromUniform() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            for ((input, output) in fromUniformTestVectors) {
+                val outPoint = Ed25519.Point.fromHex(output)
+                val uniform = LibsodiumUtil.fromHex(input)
+
+                assertEquals(outPoint, Ed25519.Point.fromUniform(uniform))
+            }
+        }
+    }
+
+    @Test
+    fun testRandomScalar() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            val x = Ed25519.Scalar.random()
+            val y = Ed25519.Scalar.random()
+            val z = Ed25519.Scalar.random()
+
+            assertNotEquals(x, y)
+            assertNotEquals(y, z)
+            assertNotEquals(z, x)
+        }
+    }
+
+    @Test
+    fun testScalarHexConversion() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            repeat(10) {
+                val p = Ed25519.Scalar.random()
+
+                assertEquals(p, Ed25519.Scalar.fromHex(p.toHex()))
+            }
+        }
+    }
+
+    @Test
+    fun testScalarArithmetic() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            repeat(10) {
+                val x = Ed25519.Scalar.random()
+                val y = Ed25519.Scalar.random()
+
+                val xInv = x.invert()
+                val xComp = x.complement()
+                val xNeg = -x
+
+                assertEquals(Ed25519.Scalar.ZERO, x + xNeg)
+                assertEquals(Ed25519.Scalar.ZERO, xNeg + x)
+                assertEquals(Ed25519.Scalar.ZERO, x - x)
+
+                assertEquals(x, x + Ed25519.Scalar.ZERO)
+                assertEquals(x, Ed25519.Scalar.ZERO + x)
+
+                assertEquals(Ed25519.Scalar.ONE, x + xComp)
+                assertEquals(Ed25519.Scalar.ONE, xComp + x)
+
+                assertEquals(Ed25519.Scalar.ONE, x * xInv)
+                assertEquals(Ed25519.Scalar.ONE, xInv * x)
+                assertEquals(Ed25519.Scalar.ONE, x / x)
+
+                assertEquals(x, x * Ed25519.Scalar.ONE)
+                assertEquals(x, Ed25519.Scalar.ONE * x)
+
+                assertEquals(y - x, y + xNeg)
+                assertEquals(y / x, y * xInv)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255Test.kt b/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255Test.kt
new file mode 100644
index 00000000..d99ff510
--- /dev/null
+++ b/multiplatform-crypto-libsodium-bindings/src/commonTest/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255Test.kt
@@ -0,0 +1,228 @@
+package com.ionspin.kotlin.crypto.ristretto255
+
+import com.ionspin.kotlin.crypto.LibsodiumInitializer
+import com.ionspin.kotlin.crypto.hash.Hash
+import com.ionspin.kotlin.crypto.util.encodeToUByteArray
+import com.ionspin.kotlin.crypto.util.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotEquals
+import kotlin.test.assertTrue
+
+class Ristretto255Test {
+    // Test vectors from https://ristretto.group/test_vectors/ristretto255.html
+    val badEncodings = arrayOf(
+        // These are all bad because they're non-canonical field encodings.
+        "00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+        "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+        "f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+        "edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+        // These are all bad because they're negative field elements.
+        "0100000000000000000000000000000000000000000000000000000000000000",
+        "01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+        "ed57ffd8c914fb201471d1c3d245ce3c746fcbe63a3679d51b6a516ebebe0e20",
+        "c34c4e1826e5d403b78e246e88aa051c36ccf0aafebffe137d148a2bf9104562",
+        "c940e5a4404157cfb1628b108db051a8d439e1a421394ec4ebccb9ec92a8ac78",
+        "47cfc5497c53dc8e61c91d17fd626ffb1c49e2bca94eed052281b510b1117a24",
+        "f1c6165d33367351b0da8f6e4511010c68174a03b6581212c71c0e1d026c3c72",
+        "87260f7a2f12495118360f02c26a470f450dadf34a413d21042b43b9d93e1309",
+        // These are all bad because they give a non-square x^2.
+        "26948d35ca62e643e26a83177332e6b6afeb9d08e4268b650f1f5bbd8d81d371",
+        "4eac077a713c57b4f4397629a4145982c661f48044dd3f96427d40b147d9742f",
+        "de6a7b00deadc788eb6b6c8d20c0ae96c2f2019078fa604fee5b87d6e989ad7b",
+        "bcab477be20861e01e4a0e295284146a510150d9817763caf1a6f4b422d67042",
+        "2a292df7e32cababbd9de088d1d1abec9fc0440f637ed2fba145094dc14bea08",
+        "f4a9e534fc0d216c44b218fa0c42d99635a0127ee2e53c712f70609649fdff22",
+        "8268436f8c4126196cf64b3c7ddbda90746a378625f9813dd9b8457077256731",
+        "2810e5cbc2cc4d4eece54f61c6f69758e289aa7ab440b3cbeaa21995c2f4232b",
+        // These are all bad because they give a negative xy value.
+        "3eb858e78f5a7254d8c9731174a94f76755fd3941c0ac93735c07ba14579630e",
+        "a45fdc55c76448c049a1ab33f17023edfb2be3581e9c7aade8a6125215e04220",
+        "d483fe813c6ba647ebbfd3ec41adca1c6130c2beeee9d9bf065c8d151c5f396e",
+        "8a2e1d30050198c65a54483123960ccc38aef6848e1ec8f5f780e8523769ba32",
+        "32888462f8b486c68ad7dd9610be5192bbeaf3b443951ac1a8118419d9fa097b",
+        "227142501b9d4355ccba290404bde41575b037693cef1f438c47f8fbf35d1165",
+        "5c37cc491da847cfeb9281d407efc41e15144c876e0170b499a96a22ed31e01e",
+        "445425117cb8c90edcbc7c1cc0e74f747f2c1efa5630a967c64f287792a48a4b",
+        // This is s = -1, which causes y = 0.
+        "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f"
+    )
+
+    // Test vectors from https://ristretto.group/test_vectors/ristretto255.html
+    val fromHashTestVectors = arrayOf(
+        "Ristretto is traditionally a short shot of espresso coffee" to "3066f82a1a747d45120d1740f14358531a8f04bbffe6a819f86dfe50f44a0a46",
+        "made with the normal amount of ground coffee but extracted with" to "f26e5b6f7d362d2d2a94c5d0e7602cb4773c95a2e5c31a64f133189fa76ed61b",
+        "about half the amount of water in the same amount of time" to "006ccd2a9e6867e6a2c5cea83d3302cc9de128dd2a9a57dd8ee7b9d7ffe02826",
+        "by using a finer grind." to "f8f0c87cf237953c5890aec3998169005dae3eca1fbb04548c635953c817f92a",
+        "This produces a concentrated shot of coffee per volume." to "ae81e7dedf20a497e10c304a765c1767a42d6e06029758d2d7e8ef7cc4c41179",
+        "Just pulling a normal shot short will produce a weaker shot" to "e2705652ff9f5e44d3e841bf1c251cf7dddb77d140870d1ab2ed64f1a9ce8628",
+        "and is not a Ristretto as some believe." to "80bd07262511cdde4863f8a7434cef696750681cb9510eea557088f76d9e5065",
+    )
+
+    // Test vectors from https://ristretto.group/test_vectors/ristretto255.html
+    val basePointSmallMultiples = arrayOf(
+        // This is the basepoint
+        "e2f2ae0a6abc4e71a884a961c500515f58e30b6aa582dd8db6a65945e08d2d76",
+        // These are small multiples of the basepoint
+        "6a493210f7499cd17fecb510ae0cea23a110e8d5b901f8acadd3095c73a3b919",
+        "94741f5d5d52755ece4f23f044ee27d5d1ea1e2bd196b462166b16152a9d0259",
+        "da80862773358b466ffadfe0b3293ab3d9fd53c5ea6c955358f568322daf6a57",
+        "e882b131016b52c1d3337080187cf768423efccbb517bb495ab812c4160ff44e",
+        "f64746d3c92b13050ed8d80236a7f0007c3b3f962f5ba793d19a601ebb1df403",
+        "44f53520926ec81fbd5a387845beb7df85a96a24ece18738bdcfa6a7822a176d",
+        "903293d8f2287ebe10e2374dc1a53e0bc887e592699f02d077d5263cdd55601c",
+        "02622ace8f7303a31cafc63f8fc48fdc16e1c8c8d234b2f0d6685282a9076031",
+        "20706fd788b2720a1ed2a5dad4952b01f413bcf0e7564de8cdc816689e2db95f",
+        "bce83f8ba5dd2fa572864c24ba1810f9522bc6004afe95877ac73241cafdab42",
+        "e4549ee16b9aa03099ca208c67adafcafa4c3f3e4e5303de6026e3ca8ff84460",
+        "aa52e000df2e16f55fb1032fc33bc42742dad6bd5a8fc0be0167436c5948501f",
+        "46376b80f409b29dc2b5f6f0c52591990896e5716f41477cd30085ab7f10301e",
+        "e0c418f7c8d9c4cdd7395b93ea124f3ad99021bb681dfc3302a9d99a2e53e64e",
+    )
+
+    @Test
+    fun testRandomPoint() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            val p = Ristretto255.Point.random()
+            val q = Ristretto255.Point.random()
+            val r = Ristretto255.Point.random()
+
+            assertNotEquals(p, q)
+            assertNotEquals(q, r)
+            assertNotEquals(r, p)
+
+
+            assertTrue { p.isValid }
+            assertTrue { q.isValid }
+            assertTrue { r.isValid }
+        }
+    }
+
+    @Test
+    fun testPointHexConversion() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            repeat(10) {
+                val p = Ristretto255.Point.random()
+
+                assertEquals(p, Ristretto255.Point.fromHex(p.toHex()))
+            }
+        }
+    }
+
+    @Test
+    fun testIsValidPoint() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            for (hexEncoded in badEncodings) {
+                assertFalse { Ristretto255.Point.fromHex(hexEncoded).isValid }
+            }
+
+            for (hexEncoded in basePointSmallMultiples) {
+                assertTrue { Ristretto255.Point.fromHex(hexEncoded).isValid }
+            }
+        }
+    }
+
+    @Test
+    fun testPointArithmetic() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            for (i in basePointSmallMultiples.indices) {
+                val p = Ristretto255.Point.fromHex(basePointSmallMultiples[i])
+                val b = Ristretto255.Point.BASE
+                val n = Ristretto255.Scalar.fromUInt(i.toUInt() + 1U)
+
+                assertEquals(p, Ristretto255.Point.multiplyBase(n))
+                assertEquals(p, b.times(n))
+                assertEquals(p, n.multiplyWithBase())
+
+                for (j in 0..<i) {
+                    val q = Ristretto255.Point.fromHex(basePointSmallMultiples[j])
+                    val m = Ristretto255.Scalar.fromUInt(i.toUInt() - j.toUInt())
+
+                    assertEquals(p, q + b * m)
+                    assertEquals(p, b * m + q)
+                    assertEquals(q, p - b * m)
+                }
+
+                for (j in i + 1..<basePointSmallMultiples.size) {
+                    val q = Ristretto255.Point.fromHex(basePointSmallMultiples[j])
+                    val m = Ristretto255.Scalar.fromUInt(j.toUInt() - i.toUInt())
+
+                    assertEquals(q, p + b * m)
+                    assertEquals(q, b * m + p)
+                    assertEquals(p, q - b * m)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun testPointFromHash() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            for ((input, output) in fromHashTestVectors) {
+                val outPoint = Ristretto255.Point.fromHex(output)
+                val hash = Hash.sha512(input.encodeToUByteArray())
+
+                assertEquals(outPoint, Ristretto255.Point.fromHash(hash))
+            }
+        }
+    }
+
+    @Test
+    fun testRandomScalar() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            val x = Ristretto255.Scalar.random()
+            val y = Ristretto255.Scalar.random()
+            val z = Ristretto255.Scalar.random()
+
+            assertNotEquals(x, y)
+            assertNotEquals(y, z)
+            assertNotEquals(z, x)
+        }
+    }
+
+    @Test
+    fun testScalarHexConversion() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            repeat(10) {
+                val p = Ristretto255.Scalar.random()
+
+                assertEquals(p, Ristretto255.Scalar.fromHex(p.toHex()))
+            }
+        }
+    }
+
+    @Test
+    fun testScalarArithmetic() = runTest {
+        LibsodiumInitializer.initializeWithCallback {
+            repeat(10) {
+                val x = Ristretto255.Scalar.random()
+                val y = Ristretto255.Scalar.random()
+
+                val xInv = x.invert()
+                val xComp = x.complement()
+                val xNeg = -x
+
+                assertEquals(Ristretto255.Scalar.ZERO, x + xNeg)
+                assertEquals(Ristretto255.Scalar.ZERO, xNeg + x)
+                assertEquals(Ristretto255.Scalar.ZERO, x - x)
+
+                assertEquals(x, x + Ristretto255.Scalar.ZERO)
+                assertEquals(x, Ristretto255.Scalar.ZERO + x)
+
+                assertEquals(Ristretto255.Scalar.ONE, x + xComp)
+                assertEquals(Ristretto255.Scalar.ONE, xComp + x)
+
+                assertEquals(Ristretto255.Scalar.ONE, x * xInv)
+                assertEquals(Ristretto255.Scalar.ONE, xInv * x)
+                assertEquals(Ristretto255.Scalar.ONE, x / x)
+
+                assertEquals(x, x * Ristretto255.Scalar.ONE)
+                assertEquals(x, Ristretto255.Scalar.ONE * x)
+
+                assertEquals(y - x, y + xNeg)
+                assertEquals(y / x, y * xInv)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/com/ionspin/kotlin/crypto/JsSodiumInterface.kt b/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/com/ionspin/kotlin/crypto/JsSodiumInterface.kt
index ed74443c..71e4b313 100644
--- a/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/com/ionspin/kotlin/crypto/JsSodiumInterface.kt
+++ b/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/com/ionspin/kotlin/crypto/JsSodiumInterface.kt
@@ -363,5 +363,112 @@ external object JsSodiumInterface {
     // ---- Scalar multiplication end ----
 
 
+    //
+    // ---- Ristretto255 ----
 
+    @JsName("crypto_core_ristretto255_is_valid_point")
+    fun crypto_core_ristretto255_is_valid_point(p: Uint8Array): Boolean
+
+    @JsName("crypto_core_ristretto255_random")
+    fun crypto_core_ristretto255_random(): Uint8Array
+
+    @JsName("crypto_core_ristretto255_from_hash")
+    fun crypto_core_ristretto255_from_hash(r: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ristretto255_add")
+    fun crypto_core_ristretto255_add(p: Uint8Array, q: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ristretto255_sub")
+    fun crypto_core_ristretto255_sub(p: Uint8Array, q: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ristretto255_scalar_random")
+    fun crypto_core_ristretto255_scalar_random(): Uint8Array
+
+    @JsName("crypto_core_ristretto255_scalar_reduce")
+    fun crypto_core_ristretto255_scalar_reduce(s: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ristretto255_scalar_invert")
+    fun crypto_core_ristretto255_scalar_invert(s: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ristretto255_scalar_negate")
+    fun crypto_core_ristretto255_scalar_negate(s: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ristretto255_scalar_complement")
+    fun crypto_core_ristretto255_scalar_complement(s: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ristretto255_scalar_add")
+    fun crypto_core_ristretto255_scalar_add(x: Uint8Array, y: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ristretto255_scalar_sub")
+    fun crypto_core_ristretto255_scalar_sub(x: Uint8Array, y: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ristretto255_scalar_mul")
+    fun crypto_core_ristretto255_scalar_mul(x: Uint8Array, y: Uint8Array): Uint8Array
+
+    @JsName("crypto_scalarmult_ristretto255")
+    fun crypto_scalarmult_ristretto255(n: Uint8Array, p: Uint8Array): Uint8Array
+
+    @JsName("crypto_scalarmult_ristretto255_base")
+    fun crypto_scalarmult_ristretto255_base(n: Uint8Array): Uint8Array
+
+    //
+    // ---- Ristretto255 end ----
+
+
+    //
+    // ---- Ed25519 ----
+
+    @JsName("crypto_core_ed25519_is_valid_point")
+    fun crypto_core_ed25519_is_valid_point(p: Uint8Array): Boolean
+
+    @JsName("crypto_core_ed25519_random")
+    fun crypto_core_ed25519_random(): Uint8Array
+
+    @JsName("crypto_core_ed25519_from_uniform")
+    fun crypto_core_ed25519_from_uniform(r: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ed25519_add")
+    fun crypto_core_ed25519_add(p: Uint8Array, q: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ed25519_sub")
+    fun crypto_core_ed25519_sub(p: Uint8Array, q: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ed25519_scalar_random")
+    fun crypto_core_ed25519_scalar_random(): Uint8Array
+
+    @JsName("crypto_core_ed25519_scalar_reduce")
+    fun crypto_core_ed25519_scalar_reduce(s: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ed25519_scalar_invert")
+    fun crypto_core_ed25519_scalar_invert(s: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ed25519_scalar_negate")
+    fun crypto_core_ed25519_scalar_negate(s: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ed25519_scalar_complement")
+    fun crypto_core_ed25519_scalar_complement(s: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ed25519_scalar_add")
+    fun crypto_core_ed25519_scalar_add(x: Uint8Array, y: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ed25519_scalar_sub")
+    fun crypto_core_ed25519_scalar_sub(x: Uint8Array, y: Uint8Array): Uint8Array
+
+    @JsName("crypto_core_ed25519_scalar_mul")
+    fun crypto_core_ed25519_scalar_mul(x: Uint8Array, y: Uint8Array): Uint8Array
+
+    @JsName("crypto_scalarmult_ed25519")
+    fun crypto_scalarmult_ed25519(n: Uint8Array, p: Uint8Array): Uint8Array
+
+    @JsName("crypto_scalarmult_ed25519_noclamp")
+    fun crypto_scalarmult_ed25519_noclamp(n: Uint8Array, p: Uint8Array): Uint8Array
+
+    @JsName("crypto_scalarmult_ed25519_base")
+    fun crypto_scalarmult_ed25519_base(n: Uint8Array): Uint8Array
+
+    @JsName("crypto_scalarmult_ed25519_base_noclamp")
+    fun crypto_scalarmult_ed25519_base_noclamp(n: Uint8Array): Uint8Array
+
+    //
+    // ---- Ed25519 end ----
 }
diff --git a/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519LowLevel.kt b/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519LowLevel.kt
new file mode 100644
index 00000000..4e33907b
--- /dev/null
+++ b/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519LowLevel.kt
@@ -0,0 +1,106 @@
+package com.ionspin.kotlin.crypto.ed25519
+
+import com.ionspin.kotlin.crypto.getSodium
+import ext.libsodium.com.ionspin.kotlin.crypto.toUByteArray
+import ext.libsodium.com.ionspin.kotlin.crypto.toUInt8Array
+
+actual object Ed25519LowLevel {
+    actual fun isValidPoint(encoded: UByteArray): Boolean =
+        getSodium().crypto_core_ed25519_is_valid_point(encoded.toUInt8Array())
+
+    actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ed25519_add(p.toUInt8Array(), q.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ed25519_sub(p.toUInt8Array(), q.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun pointFromUniform(uniform: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ed25519_from_uniform(uniform.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun randomPoint(): UByteArray {
+        val result = getSodium().crypto_core_ed25519_random()
+
+        return result.toUByteArray()
+    }
+
+    actual fun randomScalar(): UByteArray {
+        val result = getSodium().crypto_core_ed25519_scalar_random()
+
+        return result.toUByteArray()
+    }
+
+    actual fun invertScalar(scalar: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ed25519_scalar_invert(scalar.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun negateScalar(scalar: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ed25519_scalar_negate(scalar.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun complementScalar(scalar: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ed25519_scalar_complement(scalar.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ed25519_scalar_add(x.toUInt8Array(), y.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ed25519_scalar_sub(x.toUInt8Array(), y.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ed25519_scalar_mul(x.toUInt8Array(), y.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun reduceScalar(scalar: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ed25519_scalar_reduce(scalar.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
+        val result = getSodium().crypto_scalarmult_ed25519(n.toUInt8Array(), p.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun scalarMultiplicationNoClamp(n: UByteArray, p: UByteArray): UByteArray {
+        val result = getSodium().crypto_scalarmult_ed25519_noclamp(n.toUInt8Array(), p.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
+        val result = getSodium().crypto_scalarmult_ed25519_base(n.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun scalarMultiplicationBaseNoClamp(n: UByteArray): UByteArray {
+        val result = getSodium().crypto_scalarmult_ed25519_base_noclamp(n.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+}
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255LowLevel.kt b/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255LowLevel.kt
new file mode 100644
index 00000000..6e40b1c4
--- /dev/null
+++ b/multiplatform-crypto-libsodium-bindings/src/jsMain/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255LowLevel.kt
@@ -0,0 +1,94 @@
+package com.ionspin.kotlin.crypto.ristretto255
+
+import com.ionspin.kotlin.crypto.getSodium
+import ext.libsodium.com.ionspin.kotlin.crypto.toUByteArray
+import ext.libsodium.com.ionspin.kotlin.crypto.toUInt8Array
+
+actual object Ristretto255LowLevel {
+    actual fun isValidPoint(encoded: UByteArray): Boolean =
+        getSodium().crypto_core_ristretto255_is_valid_point(encoded.toUInt8Array())
+
+    actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_add(p.toUInt8Array(), q.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_sub(p.toUInt8Array(), q.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun pointFromHash(hash: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_from_hash(hash.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun randomPoint(): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_random()
+
+        return result.toUByteArray()
+    }
+
+    actual fun randomScalar(): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_scalar_random()
+
+        return result.toUByteArray()
+    }
+
+    actual fun invertScalar(scalar: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_scalar_invert(scalar.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun negateScalar(scalar: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_scalar_negate(scalar.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun complementScalar(scalar: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_scalar_complement(scalar.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_scalar_add(x.toUInt8Array(), y.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_scalar_sub(x.toUInt8Array(), y.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_scalar_mul(x.toUInt8Array(), y.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun reduceScalar(scalar: UByteArray): UByteArray {
+        val result = getSodium().crypto_core_ristretto255_scalar_reduce(scalar.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
+        val result = getSodium().crypto_scalarmult_ristretto255(n.toUInt8Array(), p.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+
+    actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
+        val result = getSodium().crypto_scalarmult_ristretto255_base(n.toUInt8Array())
+
+        return result.toUByteArray()
+    }
+}
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/com/ionspin/kotlin/crypto/JnaLibsodiumInterface.kt b/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/com/ionspin/kotlin/crypto/JnaLibsodiumInterface.kt
index e1a07d97..6903514b 100644
--- a/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/com/ionspin/kotlin/crypto/JnaLibsodiumInterface.kt
+++ b/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/com/ionspin/kotlin/crypto/JnaLibsodiumInterface.kt
@@ -1293,4 +1293,80 @@ interface JnaLibsodiumInterface : Library {
     fun crypto_scalarmult_base(q: ByteArray, b: ByteArray): Int
 //
 //    // ---- Scalar multiplication end ----
+
+//
+//    // ---- Ristretto255 ----
+
+    fun crypto_core_ristretto255_is_valid_point(p: ByteArray): Int
+
+    fun crypto_core_ristretto255_random(p: ByteArray)
+
+    fun crypto_core_ristretto255_from_hash(p: ByteArray, r: ByteArray): Int
+
+    fun crypto_core_ristretto255_add(r: ByteArray, p: ByteArray, q: ByteArray): Int
+
+    fun crypto_core_ristretto255_sub(r: ByteArray, p: ByteArray, q: ByteArray): Int
+
+    fun crypto_core_ristretto255_scalar_random(r: ByteArray)
+
+    fun crypto_core_ristretto255_scalar_reduce(r: ByteArray, s: ByteArray)
+
+    fun crypto_core_ristretto255_scalar_invert(recip: ByteArray, s: ByteArray): Int
+
+    fun crypto_core_ristretto255_scalar_negate(neg: ByteArray, s: ByteArray)
+
+    fun crypto_core_ristretto255_scalar_complement(comp: ByteArray, s: ByteArray)
+
+    fun crypto_core_ristretto255_scalar_add(z: ByteArray, x: ByteArray, y: ByteArray)
+
+    fun crypto_core_ristretto255_scalar_sub(z: ByteArray, x: ByteArray, y: ByteArray)
+
+    fun crypto_core_ristretto255_scalar_mul(z: ByteArray, x: ByteArray, y: ByteArray)
+
+    fun crypto_scalarmult_ristretto255(q: ByteArray, n: ByteArray, p: ByteArray): Int
+
+    fun crypto_scalarmult_ristretto255_base(q: ByteArray, n: ByteArray): Int
+
+//
+//    // ---- Ristretto255 end ----
+
+//
+//    // ---- Ed25519 ----
+
+    fun crypto_core_ed25519_is_valid_point(p: ByteArray): Int
+
+    fun crypto_core_ed25519_random(p: ByteArray)
+
+    fun crypto_core_ed25519_from_uniform(p: ByteArray, r: ByteArray): Int
+
+    fun crypto_core_ed25519_add(r: ByteArray, p: ByteArray, q: ByteArray): Int
+
+    fun crypto_core_ed25519_sub(r: ByteArray, p: ByteArray, q: ByteArray): Int
+
+    fun crypto_core_ed25519_scalar_random(r: ByteArray)
+
+    fun crypto_core_ed25519_scalar_reduce(r: ByteArray, s: ByteArray)
+
+    fun crypto_core_ed25519_scalar_invert(recip: ByteArray, s: ByteArray): Int
+
+    fun crypto_core_ed25519_scalar_negate(neg: ByteArray, s: ByteArray)
+
+    fun crypto_core_ed25519_scalar_complement(comp: ByteArray, s: ByteArray)
+
+    fun crypto_core_ed25519_scalar_add(z: ByteArray, x: ByteArray, y: ByteArray)
+
+    fun crypto_core_ed25519_scalar_sub(z: ByteArray, x: ByteArray, y: ByteArray)
+
+    fun crypto_core_ed25519_scalar_mul(z: ByteArray, x: ByteArray, y: ByteArray)
+
+    fun crypto_scalarmult_ed25519(q: ByteArray, n: ByteArray, p: ByteArray): Int
+
+    fun crypto_scalarmult_ed25519_noclamp(q: ByteArray, n: ByteArray, p: ByteArray): Int
+
+    fun crypto_scalarmult_ed25519_base(q: ByteArray, n: ByteArray): Int
+
+    fun crypto_scalarmult_ed25519_base_noclamp(q: ByteArray, n: ByteArray): Int
+
+//
+//    // ---- Ed25519 end ----
 }
diff --git a/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519LowLevel.kt b/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519LowLevel.kt
new file mode 100644
index 00000000..e9503c98
--- /dev/null
+++ b/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519LowLevel.kt
@@ -0,0 +1,136 @@
+package com.ionspin.kotlin.crypto.ed25519
+
+import com.ionspin.kotlin.crypto.GeneralLibsodiumException.Companion.ensureLibsodiumSuccess
+import com.ionspin.kotlin.crypto.LibsodiumInitializer.sodiumJna
+
+actual object Ed25519LowLevel {
+    actual fun isValidPoint(encoded: UByteArray): Boolean =
+        sodiumJna.crypto_core_ed25519_is_valid_point(encoded.asByteArray()) == 1
+
+    actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        sodiumJna.crypto_core_ed25519_add(result.asByteArray(), p.asByteArray(), q.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        sodiumJna.crypto_core_ed25519_sub(result.asByteArray(), p.asByteArray(), q.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun pointFromUniform(uniform: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        sodiumJna.crypto_core_ed25519_from_uniform(result.asByteArray(), uniform.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun randomPoint(): UByteArray = UByteArray(crypto_core_ed25519_BYTES).also {
+        sodiumJna.crypto_core_ed25519_random(it.asByteArray())
+    }
+
+    actual fun randomScalar(): UByteArray = UByteArray(crypto_core_ed25519_SCALARBYTES).also {
+        sodiumJna.crypto_core_ed25519_scalar_random(it.asByteArray())
+    }
+
+    actual fun invertScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        sodiumJna.crypto_core_ed25519_scalar_invert(result.asByteArray(), scalar.asByteArray()).ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun negateScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        sodiumJna.crypto_core_ed25519_scalar_negate(result.asByteArray(), scalar.asByteArray())
+
+        return result
+    }
+
+    actual fun complementScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        sodiumJna.crypto_core_ed25519_scalar_complement(result.asByteArray(), scalar.asByteArray())
+
+        return result
+    }
+
+    actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        sodiumJna.crypto_core_ed25519_scalar_add(result.asByteArray(), x.asByteArray(), y.asByteArray())
+
+        return result
+    }
+
+    actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        sodiumJna.crypto_core_ed25519_scalar_sub(result.asByteArray(), x.asByteArray(), y.asByteArray())
+
+        return result
+    }
+
+    actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        sodiumJna.crypto_core_ed25519_scalar_mul(result.asByteArray(), x.asByteArray(), y.asByteArray())
+
+        return result
+    }
+
+    actual fun reduceScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        sodiumJna.crypto_core_ed25519_scalar_reduce(result.asByteArray(), scalar.asByteArray())
+
+        return result
+    }
+
+    actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        sodiumJna.crypto_scalarmult_ed25519(result.asByteArray(), n.asByteArray(), p.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun scalarMultiplicationNoClamp(n: UByteArray, p: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        sodiumJna.crypto_scalarmult_ed25519_noclamp(result.asByteArray(), n.asByteArray(), p.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        sodiumJna.crypto_scalarmult_ed25519_base(result.asByteArray(), n.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun scalarMultiplicationBaseNoClamp(n: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        sodiumJna.crypto_scalarmult_ed25519_base_noclamp(result.asByteArray(), n.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+}
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255LowLevel.kt b/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255LowLevel.kt
new file mode 100644
index 00000000..cbf37527
--- /dev/null
+++ b/multiplatform-crypto-libsodium-bindings/src/jvmMain/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255LowLevel.kt
@@ -0,0 +1,118 @@
+package com.ionspin.kotlin.crypto.ristretto255
+
+import com.ionspin.kotlin.crypto.GeneralLibsodiumException.Companion.ensureLibsodiumSuccess
+import com.ionspin.kotlin.crypto.LibsodiumInitializer.sodiumJna
+
+actual object Ristretto255LowLevel {
+    actual fun isValidPoint(encoded: UByteArray): Boolean =
+        sodiumJna.crypto_core_ristretto255_is_valid_point(encoded.asByteArray()) == 1
+
+    actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_BYTES)
+
+        sodiumJna.crypto_core_ristretto255_add(result.asByteArray(), p.asByteArray(), q.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_BYTES)
+
+        sodiumJna.crypto_core_ristretto255_sub(result.asByteArray(), p.asByteArray(), q.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun pointFromHash(hash: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_BYTES)
+
+        sodiumJna.crypto_core_ristretto255_from_hash(result.asByteArray(), hash.asByteArray())
+
+        return result
+    }
+
+    actual fun randomPoint(): UByteArray = UByteArray(crypto_core_ristretto255_BYTES).also {
+        sodiumJna.crypto_core_ristretto255_random(it.asByteArray())
+    }
+
+    actual fun randomScalar(): UByteArray = UByteArray(crypto_core_ristretto255_SCALARBYTES).also {
+        sodiumJna.crypto_core_ristretto255_scalar_random(it.asByteArray())
+    }
+
+    actual fun invertScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        sodiumJna.crypto_core_ristretto255_scalar_invert(result.asByteArray(), scalar.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun negateScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        sodiumJna.crypto_core_ristretto255_scalar_negate(result.asByteArray(), scalar.asByteArray())
+
+        return result
+    }
+
+    actual fun complementScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        sodiumJna.crypto_core_ristretto255_scalar_complement(result.asByteArray(), scalar.asByteArray())
+
+        return result
+    }
+
+    actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        sodiumJna.crypto_core_ristretto255_scalar_add(result.asByteArray(), x.asByteArray(), y.asByteArray())
+
+        return result
+    }
+
+    actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        sodiumJna.crypto_core_ristretto255_scalar_sub(result.asByteArray(), x.asByteArray(), y.asByteArray())
+
+        return result
+    }
+
+    actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        sodiumJna.crypto_core_ristretto255_scalar_mul(result.asByteArray(), x.asByteArray(), y.asByteArray())
+
+        return result
+    }
+
+    actual fun reduceScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        sodiumJna.crypto_core_ristretto255_scalar_reduce(result.asByteArray(), scalar.asByteArray())
+
+        return result
+    }
+
+    actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_BYTES)
+
+        sodiumJna.crypto_scalarmult_ristretto255(result.asByteArray(), n.asByteArray(), p.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+
+    actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_BYTES)
+
+        sodiumJna.crypto_scalarmult_ristretto255_base(result.asByteArray(), n.asByteArray())
+            .ensureLibsodiumSuccess()
+
+        return result
+    }
+}
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/src/jvmMain/resources/libdynamic-macos.dylib b/multiplatform-crypto-libsodium-bindings/src/jvmMain/resources/libdynamic-macos.dylib
index b3947a58..50ea5b03 100755
Binary files a/multiplatform-crypto-libsodium-bindings/src/jvmMain/resources/libdynamic-macos.dylib and b/multiplatform-crypto-libsodium-bindings/src/jvmMain/resources/libdynamic-macos.dylib differ
diff --git a/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519LowLevel.kt b/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519LowLevel.kt
new file mode 100644
index 00000000..0526a035
--- /dev/null
+++ b/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/com/ionspin/kotlin/crypto/ed25519/Ed25519LowLevel.kt
@@ -0,0 +1,230 @@
+package com.ionspin.kotlin.crypto.ed25519
+
+import com.ionspin.kotlin.crypto.GeneralLibsodiumException.Companion.ensureLibsodiumSuccess
+import com.ionspin.kotlin.crypto.util.toPtr
+import kotlinx.cinterop.usePinned
+import libsodium.crypto_core_ed25519_add
+import libsodium.crypto_core_ed25519_from_uniform
+import libsodium.crypto_core_ed25519_is_valid_point
+import libsodium.crypto_core_ed25519_random
+import libsodium.crypto_core_ed25519_scalar_add
+import libsodium.crypto_core_ed25519_scalar_complement
+import libsodium.crypto_core_ed25519_scalar_invert
+import libsodium.crypto_core_ed25519_scalar_mul
+import libsodium.crypto_core_ed25519_scalar_negate
+import libsodium.crypto_core_ed25519_scalar_random
+import libsodium.crypto_core_ed25519_scalar_reduce
+import libsodium.crypto_core_ed25519_scalar_sub
+import libsodium.crypto_core_ed25519_sub
+import libsodium.crypto_scalarmult_ed25519
+import libsodium.crypto_scalarmult_ed25519_base
+import libsodium.crypto_scalarmult_ed25519_base_noclamp
+import libsodium.crypto_scalarmult_ed25519_noclamp
+
+
+actual object Ed25519LowLevel {
+    actual fun isValidPoint(encoded: UByteArray): Boolean {
+        return encoded.usePinned { crypto_core_ed25519_is_valid_point(it.toPtr()) == 1 }
+    }
+
+    actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        result.usePinned { resultPinned ->
+            p.usePinned { pPinned ->
+                q.usePinned { qPinned ->
+                    crypto_core_ed25519_add(resultPinned.toPtr(), pPinned.toPtr(), qPinned.toPtr())
+                        .ensureLibsodiumSuccess()
+                }
+            }
+        }
+
+        return result
+    }
+
+    actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        result.usePinned { resultPinned ->
+            p.usePinned { pPinned ->
+                q.usePinned { qPinned ->
+                    crypto_core_ed25519_sub(resultPinned.toPtr(), pPinned.toPtr(), qPinned.toPtr())
+                        .ensureLibsodiumSuccess()
+                }
+            }
+        }
+
+        return result
+    }
+
+    actual fun pointFromUniform(uniform: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        result.usePinned { resultPinned ->
+            uniform.usePinned { uniformPinned ->
+                crypto_core_ed25519_from_uniform(resultPinned.toPtr(), uniformPinned.toPtr())
+                    .ensureLibsodiumSuccess()
+            }
+        }
+
+        return result
+    }
+
+    actual fun randomPoint(): UByteArray = UByteArray(crypto_core_ed25519_BYTES).apply {
+        usePinned { crypto_core_ed25519_random(it.toPtr()) }
+    }
+
+    actual fun randomScalar(): UByteArray = UByteArray(crypto_core_ed25519_SCALARBYTES).apply {
+        usePinned { crypto_core_ed25519_scalar_random(it.toPtr()) }
+    }
+
+    actual fun invertScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            scalar.usePinned { scalarPinned ->
+                crypto_core_ed25519_scalar_invert(resultPinned.toPtr(), scalarPinned.toPtr()).ensureLibsodiumSuccess()
+            }
+        }
+
+
+        return result
+    }
+
+    actual fun negateScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            scalar.usePinned { scalarPinned ->
+                crypto_core_ed25519_scalar_negate(resultPinned.toPtr(), scalarPinned.toPtr())
+            }
+        }
+
+
+        return result
+    }
+
+    actual fun complementScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            scalar.usePinned { scalarPinned ->
+                crypto_core_ed25519_scalar_complement(resultPinned.toPtr(), scalarPinned.toPtr())
+            }
+        }
+
+        return result
+    }
+
+    actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            x.usePinned { xPinned ->
+                y.usePinned { yPinned ->
+                    crypto_core_ed25519_scalar_add(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
+                }
+            }
+        }
+
+        return result
+    }
+
+    actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            x.usePinned { xPinned ->
+                y.usePinned { yPinned ->
+                    crypto_core_ed25519_scalar_sub(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
+                }
+            }
+        }
+
+        return result
+    }
+
+    actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            x.usePinned { xPinned ->
+                y.usePinned { yPinned ->
+                    crypto_core_ed25519_scalar_mul(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
+                }
+            }
+        }
+
+        return result
+    }
+
+    actual fun reduceScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            scalar.usePinned { scalarPinned ->
+                crypto_core_ed25519_scalar_reduce(resultPinned.toPtr(), scalarPinned.toPtr())
+            }
+        }
+
+        return result
+    }
+
+    actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        result.usePinned { resultPinned ->
+            n.usePinned { nPinned ->
+                p.usePinned { pPinned ->
+                    crypto_scalarmult_ed25519(resultPinned.toPtr(), nPinned.toPtr(), pPinned.toPtr())
+                        .ensureLibsodiumSuccess()
+                }
+            }
+        }
+
+
+        return result
+    }
+
+    actual fun scalarMultiplicationNoClamp(n: UByteArray, p: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        result.usePinned { resultPinned ->
+            n.usePinned { nPinned ->
+                p.usePinned { pPinned ->
+                    crypto_scalarmult_ed25519_noclamp(resultPinned.toPtr(), nPinned.toPtr(), pPinned.toPtr())
+                        .ensureLibsodiumSuccess()
+                }
+            }
+        }
+
+
+        return result
+    }
+
+    actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        result.usePinned { resultPinned ->
+            n.usePinned { nPinned ->
+                crypto_scalarmult_ed25519_base(resultPinned.toPtr(), nPinned.toPtr())
+                    .ensureLibsodiumSuccess()
+            }
+        }
+
+        return result
+    }
+
+    actual fun scalarMultiplicationBaseNoClamp(n: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ed25519_BYTES)
+
+        result.usePinned { resultPinned ->
+            n.usePinned { nPinned ->
+                crypto_scalarmult_ed25519_base_noclamp(resultPinned.toPtr(), nPinned.toPtr())
+                    .ensureLibsodiumSuccess()
+            }
+        }
+
+        return result
+    }
+}
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255LowLevel.kt b/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255LowLevel.kt
new file mode 100644
index 00000000..61b9595c
--- /dev/null
+++ b/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/com/ionspin/kotlin/crypto/ristretto255/Ristretto255LowLevel.kt
@@ -0,0 +1,201 @@
+package com.ionspin.kotlin.crypto.ristretto255
+
+import com.ionspin.kotlin.crypto.GeneralLibsodiumException.Companion.ensureLibsodiumSuccess
+import com.ionspin.kotlin.crypto.util.toPtr
+import kotlinx.cinterop.usePinned
+import libsodium.crypto_core_ristretto255_add
+import libsodium.crypto_core_ristretto255_from_hash
+import libsodium.crypto_core_ristretto255_is_valid_point
+import libsodium.crypto_core_ristretto255_random
+import libsodium.crypto_core_ristretto255_scalar_add
+import libsodium.crypto_core_ristretto255_scalar_complement
+import libsodium.crypto_core_ristretto255_scalar_invert
+import libsodium.crypto_core_ristretto255_scalar_mul
+import libsodium.crypto_core_ristretto255_scalar_negate
+import libsodium.crypto_core_ristretto255_scalar_random
+import libsodium.crypto_core_ristretto255_scalar_reduce
+import libsodium.crypto_core_ristretto255_scalar_sub
+import libsodium.crypto_core_ristretto255_sub
+import libsodium.crypto_scalarmult_ristretto255
+import libsodium.crypto_scalarmult_ristretto255_base
+
+
+actual object Ristretto255LowLevel {
+    actual fun isValidPoint(encoded: UByteArray): Boolean {
+        return encoded.usePinned { crypto_core_ristretto255_is_valid_point(it.toPtr()) == 1 }
+    }
+
+    actual fun addPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_BYTES)
+
+        result.usePinned { resultPinned ->
+            p.usePinned { pPinned ->
+                q.usePinned { qPinned ->
+                    crypto_core_ristretto255_add(resultPinned.toPtr(), pPinned.toPtr(), qPinned.toPtr())
+                        .ensureLibsodiumSuccess()
+                }
+            }
+        }
+
+        return result
+    }
+
+    actual fun subtractPoints(p: UByteArray, q: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_BYTES)
+
+        result.usePinned { resultPinned ->
+            p.usePinned { pPinned ->
+                q.usePinned { qPinned ->
+                    crypto_core_ristretto255_sub(resultPinned.toPtr(), pPinned.toPtr(), qPinned.toPtr())
+                        .ensureLibsodiumSuccess()
+                }
+            }
+        }
+
+        return result
+    }
+
+    actual fun pointFromHash(hash: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_BYTES)
+
+        result.usePinned { resultPinned ->
+            hash.usePinned { hashPinned ->
+                crypto_core_ristretto255_from_hash(resultPinned.toPtr(), hashPinned.toPtr())
+            }
+        }
+
+        return result
+    }
+
+    actual fun randomPoint(): UByteArray = UByteArray(crypto_core_ristretto255_BYTES).apply {
+        usePinned { crypto_core_ristretto255_random(it.toPtr()) }
+    }
+
+    actual fun randomScalar(): UByteArray = UByteArray(crypto_core_ristretto255_SCALARBYTES).apply {
+        usePinned { crypto_core_ristretto255_scalar_random(it.toPtr()) }
+    }
+
+    actual fun invertScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            scalar.usePinned { scalarPinned ->
+                crypto_core_ristretto255_scalar_invert(
+                    resultPinned.toPtr(),
+                    scalarPinned.toPtr()
+                ).ensureLibsodiumSuccess()
+            }
+        }
+
+
+        return result
+    }
+
+    actual fun negateScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            scalar.usePinned { scalarPinned ->
+                crypto_core_ristretto255_scalar_negate(resultPinned.toPtr(), scalarPinned.toPtr())
+            }
+        }
+
+
+        return result
+    }
+
+    actual fun complementScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            scalar.usePinned { scalarPinned ->
+                crypto_core_ristretto255_scalar_complement(resultPinned.toPtr(), scalarPinned.toPtr())
+            }
+        }
+
+        return result
+    }
+
+    actual fun addScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            x.usePinned { xPinned ->
+                y.usePinned { yPinned ->
+                    crypto_core_ristretto255_scalar_add(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
+                }
+            }
+        }
+
+        return result
+    }
+
+    actual fun subtractScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            x.usePinned { xPinned ->
+                y.usePinned { yPinned ->
+                    crypto_core_ristretto255_scalar_sub(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
+                }
+            }
+        }
+
+        return result
+    }
+
+    actual fun multiplyScalars(x: UByteArray, y: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            x.usePinned { xPinned ->
+                y.usePinned { yPinned ->
+                    crypto_core_ristretto255_scalar_mul(resultPinned.toPtr(), xPinned.toPtr(), yPinned.toPtr())
+                }
+            }
+        }
+
+        return result
+    }
+
+    actual fun reduceScalar(scalar: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_SCALARBYTES)
+
+        result.usePinned { resultPinned ->
+            scalar.usePinned { scalarPinned ->
+                crypto_core_ristretto255_scalar_reduce(resultPinned.toPtr(), scalarPinned.toPtr())
+            }
+        }
+
+        return result
+    }
+
+    actual fun scalarMultiplication(n: UByteArray, p: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_BYTES)
+
+        result.usePinned { resultPinned ->
+            n.usePinned { nPinned ->
+                p.usePinned { pPinned ->
+                    crypto_scalarmult_ristretto255(resultPinned.toPtr(), nPinned.toPtr(), pPinned.toPtr())
+                        .ensureLibsodiumSuccess()
+                }
+            }
+        }
+
+
+        return result
+    }
+
+    actual fun scalarMultiplicationBase(n: UByteArray): UByteArray {
+        val result = UByteArray(crypto_core_ristretto255_BYTES)
+
+        result.usePinned { resultPinned ->
+            n.usePinned { nPinned ->
+                crypto_scalarmult_ristretto255_base(resultPinned.toPtr(), nPinned.toPtr())
+                    .ensureLibsodiumSuccess()
+            }
+        }
+
+        return result
+    }
+}
\ No newline at end of file
diff --git a/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/com/ionspin/kotlin/crypto/util/ConversionUtil.kt b/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/com/ionspin/kotlin/crypto/util/ConversionUtil.kt
index 360c7d76..8a882f67 100644
--- a/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/com/ionspin/kotlin/crypto/util/ConversionUtil.kt
+++ b/multiplatform-crypto-libsodium-bindings/src/nativeMain/kotlin/com/ionspin/kotlin/crypto/util/ConversionUtil.kt
@@ -4,7 +4,6 @@ import kotlinx.cinterop.CPointer
 import kotlinx.cinterop.Pinned
 import kotlinx.cinterop.UByteVar
 import kotlinx.cinterop.addressOf
-import kotlinx.cinterop.toCPointer
 
 /**
  * Created by Ugljesa Jovanovic
diff --git a/sodiumWrapper/makeMacosIosWatchosTvos.sh b/sodiumWrapper/makeMacosIosWatchosTvos.sh
index 1b6ac2f5..8a984e9e 100755
--- a/sodiumWrapper/makeMacosIosWatchosTvos.sh
+++ b/sodiumWrapper/makeMacosIosWatchosTvos.sh
@@ -1,6 +1,6 @@
 ./configureMacos64.sh
 cd libsodium
-./dist-build/apple-xcframework.sh
+LIBSODIUM_FULL_BUILD=1 ./dist-build/apple-xcframework.sh
 
 mkdir ../static-ios
 mkdir ../static-ios-simulators