diff --git a/build.gradle b/build.gradle index f04e1b5..2289eb1 100644 --- a/build.gradle +++ b/build.gradle @@ -3,32 +3,32 @@ buildscript { ext { - kotlin_version = "1.3.70" - kotlin_serialization_version = "0.20.0" - coroutines_version = "1.3.5" + kotlin_version = "1.5.20" + kotlin_serialization_version = "1.2.1" + coroutines_version = "1.5.0" junit_version = "4.12" - mockk_version = "1.9.3" - assertk_version = "0.22" - detekt_version = "1.6.0" - jacoco_version = "0.8.4" - - bivrost_version = "v0.7.1" - kethereum_version = "0.81.4" - khex_version = "1.0.0-RC6" - khash_version = "1.0.0-RC5" - kbase58_version = "0.1" + mockk_version = "1.11.0" + assertk_version = "0.24" + detekt_version = "1.17.1" + jacoco_version = "0.8.7" + + bivrost_version = "v0.8.1" spongycastle_version = "1.58.0.0" - uport_kotlin_common_version = "0.4.3" + kethereum_version = "0.83.4" + khex_version = "1.0.0" + khash_version = "1.0.0-RC5" + kbase58_version = "0.2" + uport_kotlin_common_version = "0.4.4" current_release_version = "0.4.0" } repositories { google() - jcenter() + mavenCentral() + gradlePluginPortal() maven { url "https://jitpack.io" } - maven { url "https://kotlin.bintray.com/kotlinx" } } dependencies { @@ -78,9 +78,8 @@ allprojects { repositories { google() - jcenter() + mavenCentral() maven { url "https://jitpack.io" } - maven { url "https://kotlin.bintray.com/kotlinx" } // mavenLocal() } diff --git a/ethr-did/build.gradle b/ethr-did/build.gradle index 4d9b38c..8fd68f4 100644 --- a/ethr-did/build.gradle +++ b/ethr-did/build.gradle @@ -10,7 +10,8 @@ project.ext.description = "DID resolver for the ethr-did (ERC 1056) lightweight dependencies { implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version" implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version" - implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$kotlin_serialization_version" + implementation "org.jetbrains.kotlinx:kotlinx-serialization-core:$kotlin_serialization_version" + implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialization_version" api "com.github.gnosis.bivrost-kotlin:bivrost-solidity-types:$bivrost_version" diff --git a/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDDocument.kt b/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDDocument.kt index 9c018fb..1412e66 100644 --- a/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDDocument.kt +++ b/ethr-did/src/main/java/me/uport/sdk/ethrdid/EthrDIDDocument.kt @@ -5,7 +5,6 @@ package me.uport.sdk.ethrdid import kotlinx.serialization.SerialName import kotlinx.serialization.Serializable import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonConfiguration import me.uport.sdk.universaldid.AuthenticationEntry import me.uport.sdk.universaldid.DIDDocument import me.uport.sdk.universaldid.PublicKeyEntry @@ -35,7 +34,7 @@ data class EthrDIDDocument( /** * serialize this [EthrDIDDocument] to a JSON string */ - fun toJson() = jsonParser.stringify(serializer(), this) + fun toJson() = jsonParser.encodeToString(serializer(), this) companion object { /** @@ -46,10 +45,13 @@ data class EthrDIDDocument( /** * Parse a json serialized [EthrDIDDocument] into an object */ - fun fromJson(json: String) = jsonParser.parse(serializer(), json) + fun fromJson(json: String) = jsonParser.decodeFromString(serializer(), json) private val jsonParser = - Json(JsonConfiguration.Stable.copy(isLenient = true, ignoreUnknownKeys = true)) + Json { + isLenient = true + ignoreUnknownKeys = true + } } } diff --git a/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt b/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt index 922ab7f..9904812 100644 --- a/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt +++ b/ethr-did/src/test/java/me/uport/sdk/ethrdid/EthrDIDResolverTest.kt @@ -480,7 +480,7 @@ class EthrDIDResolverTest { validDids.forEach { val normalizedDid = EthrDIDResolver.normalizeDid(it) - assertThat(normalizedDid.toLowerCase()).isEqualTo("did:ethr:0xb9c5714089478a327f09197987f16f9e5d936e8a") + assertThat(normalizedDid.lowercase()).isEqualTo("did:ethr:0xb9c5714089478a327f09197987f16f9e5d936e8a") } invalidDids.forEach { @@ -509,7 +509,7 @@ class EthrDIDResolverTest { "did:ethr:0x04:0xB9C5714089478a327F09197987f16f9E5d936E8a#owner" ) validNetworkedDIDs.forEach { - val normalizedDid = EthrDIDResolver.normalizeDid(it).toLowerCase() + val normalizedDid = EthrDIDResolver.normalizeDid(it).lowercase() println("normalizing `$it` got `$normalizedDid`") assertThat(normalizedDid).isNotEmpty() assertThat(normalizedDid).doesNotContain("#owner") @@ -536,7 +536,7 @@ class EthrDIDResolverTest { "did:ethr:0x04:0xB9C5714089478a327F09197987f16f9E5d936E8a#owner" ) validNetworkedDIDs.forEach { - val address = EthrDIDResolver.extractAddress(it).toLowerCase() + val address = EthrDIDResolver.extractAddress(it).lowercase() println("extracting address from `$it` got `$address`") assertThat(address).isEqualTo("0xb9c5714089478a327f09197987f16f9e5d936e8a") } @@ -562,7 +562,7 @@ class EthrDIDResolverTest { "did:ethr:0x04:0xB9C5714089478a327F09197987f16f9E5d936E8a#owner" to "0x04" ) validNetworkedDIDs.forEach { (did, expectedNetwork) -> - val extractedNetwork = EthrDIDResolver.extractNetwork(did).toLowerCase() + val extractedNetwork = EthrDIDResolver.extractNetwork(did).lowercase() println("extracting network from `$did` got `$extractedNetwork`") assertThat(extractedNetwork).isEqualTo(expectedNetwork) } diff --git a/ethr-status/src/main/java/me/uport/sdk/ethrstatus/EthrStatusResolver.kt b/ethr-status/src/main/java/me/uport/sdk/ethrstatus/EthrStatusResolver.kt index de0deeb..65d5930 100644 --- a/ethr-status/src/main/java/me/uport/sdk/ethrstatus/EthrStatusResolver.kt +++ b/ethr-status/src/main/java/me/uport/sdk/ethrstatus/EthrStatusResolver.kt @@ -60,7 +60,7 @@ class EthrStatusResolver : StatusResolver { result.hexToBigInteger() } .filter { it != BigInteger.ZERO } - .min() + .minOrNull() ?: BigInteger.ZERO return EthrStatus(minRevocationBlock) diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 7f44983..30360d4 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-5.6-all.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-all.zip diff --git a/jwt-test/build.gradle b/jwt-test/build.gradle index d57d8df..7157787 100644 --- a/jwt-test/build.gradle +++ b/jwt-test/build.gradle @@ -7,7 +7,7 @@ project.ext.description = "tools to enable testing of the did-jwt library" dependencies { implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version" - implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$kotlin_serialization_version" + implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialization_version" implementation project(":ethr-did") api "com.github.uport-project.kotlin-common:test-helpers:$uport_kotlin_common_version" diff --git a/jwt/build.gradle b/jwt/build.gradle index 32e2df0..8acde0d 100644 --- a/jwt/build.gradle +++ b/jwt/build.gradle @@ -9,7 +9,7 @@ project.ext.description = "tools for creating and verifying JWTs that use uPort dependencies { implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version" implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version" - implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$kotlin_serialization_version" + implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialization_version" api "com.github.komputing.khex:extensions:$khex_version" api "com.github.komputing.kethereum:extensions_kotlin:$kethereum_version" diff --git a/jwt/src/main/java/me/uport/sdk/jwt/JWTTools.kt b/jwt/src/main/java/me/uport/sdk/jwt/JWTTools.kt index e5f8a9e..ec2a8ba 100644 --- a/jwt/src/main/java/me/uport/sdk/jwt/JWTTools.kt +++ b/jwt/src/main/java/me/uport/sdk/jwt/JWTTools.kt @@ -7,15 +7,7 @@ package me.uport.sdk.jwt import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonConfiguration -import kotlinx.serialization.json.JsonException -import me.uport.sdk.core.EthNetwork -import me.uport.sdk.core.ITimeProvider -import me.uport.sdk.core.SystemTimeProvider -import me.uport.sdk.core.clean0xPrefix -import me.uport.sdk.core.decodeBase64 -import me.uport.sdk.core.hexToByteArray -import me.uport.sdk.core.toBase64UrlSafe +import me.uport.sdk.core.* import me.uport.sdk.jwt.JWTUtils.normalizeKnownDID import me.uport.sdk.jwt.JWTUtils.splitToken import me.uport.sdk.jwt.model.ArbitraryMapSerializer @@ -23,11 +15,7 @@ import me.uport.sdk.jwt.model.JwtHeader import me.uport.sdk.jwt.model.JwtHeader.Companion.ES256K import me.uport.sdk.jwt.model.JwtHeader.Companion.ES256K_R import me.uport.sdk.jwt.model.JwtPayload -import me.uport.sdk.signer.SIG_RECOVERABLE_SIZE -import me.uport.sdk.signer.Signer -import me.uport.sdk.signer.decodeJose -import me.uport.sdk.signer.normalize -import me.uport.sdk.signer.utf8 +import me.uport.sdk.signer.* import me.uport.sdk.universaldid.DIDDocument import me.uport.sdk.universaldid.DIDResolver import me.uport.sdk.universaldid.PublicKeyEntry @@ -134,8 +122,8 @@ class JWTTools( mutablePayload["iss"] = issuerDID } - val serializedPayload = Json(JsonConfiguration.Stable) - .stringify(ArbitraryMapSerializer, mutablePayload) + val serializedPayload = Json + .encodeToString(ArbitraryMapSerializer, mutablePayload) @Suppress("SimplifiableCallChain", "ConvertCallChainIntoSequence") val signingInput = listOf(header.toJson(), serializedPayload) @@ -170,7 +158,7 @@ class JWTTools( val header = JwtHeader.fromJson(headerString) val payload = JwtPayload.fromJson(payloadString) return Triple(header, payload, signatureBytes) - } catch (ex: JsonException) { + } catch (ex: Exception) { throw JWTEncodingException("cannot parse the JWT($token)", ex) } } @@ -196,10 +184,10 @@ class JWTTools( //Parse Json val header = JwtHeader.fromJson(headerString) - val payload = jsonParser.parse(ArbitraryMapSerializer, payloadString) + val payload = jsonParser.decodeFromString(ArbitraryMapSerializer, payloadString) return Triple(header, payload, signatureBytes) - } catch (ex: JsonException) { + } catch (ex: Exception) { throw JWTEncodingException("cannot parse the JWT($token)", ex) } } @@ -283,7 +271,10 @@ class JWTTools( } private val jsonParser = - Json(JsonConfiguration.Stable.copy(isLenient = true, ignoreUnknownKeys = true)) + Json { + isLenient = true + ignoreUnknownKeys = true + } /** * maps known algorithms to the corresponding verification method @@ -353,7 +344,7 @@ class JWTTools( } }.map { pubKey -> val pubKeyNoPrefix = PublicKey(pubKey).normalize() - pubKeyNoPrefix.toAddress().cleanHex.toLowerCase() + pubKeyNoPrefix.toAddress().cleanHex.lowercase() } val matches = publicKeys.map { pubKeyEntry -> @@ -367,7 +358,7 @@ class JWTTools( (pubKeyEntry.ethereumAddress?.clean0xPrefix() ?: pubKey.toAddress().cleanHex) }.filter { ethereumAddress -> - ethereumAddress.toLowerCase() in recoveredAddresses + ethereumAddress.lowercase() in recoveredAddresses } return matches.isNotEmpty() diff --git a/jwt/src/main/java/me/uport/sdk/jwt/model/ArbitraryMapSerializer.kt b/jwt/src/main/java/me/uport/sdk/jwt/model/ArbitraryMapSerializer.kt index 421f022..049aac6 100644 --- a/jwt/src/main/java/me/uport/sdk/jwt/model/ArbitraryMapSerializer.kt +++ b/jwt/src/main/java/me/uport/sdk/jwt/model/ArbitraryMapSerializer.kt @@ -1,22 +1,13 @@ package me.uport.sdk.jwt.model -import kotlinx.serialization.Decoder -import kotlinx.serialization.Encoder -import kotlinx.serialization.ImplicitReflectionSerializer +import kotlinx.serialization.ExperimentalSerializationApi import kotlinx.serialization.KSerializer -import kotlinx.serialization.PolymorphicKind -import kotlinx.serialization.SerialDescriptor -import kotlinx.serialization.encode -import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonArray -import kotlinx.serialization.json.JsonConfiguration -import kotlinx.serialization.json.JsonElement -import kotlinx.serialization.json.JsonLiteral -import kotlinx.serialization.json.JsonNull -import kotlinx.serialization.json.JsonObject -import kotlinx.serialization.json.JsonObjectSerializer -import kotlinx.serialization.json.JsonPrimitive -import kotlinx.serialization.modules.getContextualOrDefault +import kotlinx.serialization.descriptors.* +import kotlinx.serialization.encoding.Decoder +import kotlinx.serialization.encoding.Encoder +import kotlinx.serialization.json.* +import kotlinx.serialization.json.Json.Default.encodeToJsonElement +import kotlin.reflect.typeOf /** * This handles serialization and deserialization of arbitrary JSON trees represented as @@ -33,12 +24,10 @@ object ArbitraryMapSerializer : KSerializer> { //////////////////////// // converting to Json // //////////////////////// - @ImplicitReflectionSerializer private fun Map<*, *>.toJsonObject(): JsonObject = JsonObject(map { it.key.toString() to it.value.toJsonElement() }.toMap()) - @ImplicitReflectionSerializer private fun Any?.toJsonElement(): JsonElement = when (this) { null -> JsonNull is Number -> JsonPrimitive(this) @@ -49,9 +38,8 @@ object ArbitraryMapSerializer : KSerializer> { is Array<*> -> JsonArray(this.map { it.toJsonElement() }) else -> { //supporting classes that declare serializers - val jsonParser = Json(JsonConfiguration.Stable) - val serializer = jsonParser.context.getContextualOrDefault(this) - jsonParser.toJson(serializer, this) + val jsonParser = Json + jsonParser.encodeToJsonElement(this) } } @@ -59,7 +47,7 @@ object ArbitraryMapSerializer : KSerializer> { // converting back to primitives (no type info) // ////////////////////////////////////////////////// private fun JsonObject.toPrimitiveMap(): Map = - this.content.map { + this.map { it.key to it.value.toPrimitive() }.toMap() @@ -67,7 +55,7 @@ object ArbitraryMapSerializer : KSerializer> { is JsonNull -> null is JsonObject -> this.toPrimitiveMap() is JsonArray -> this.map { it.toPrimitive() } - is JsonLiteral -> { + is JsonPrimitive -> { if (isString) { contentOrNull } else { @@ -78,16 +66,19 @@ object ArbitraryMapSerializer : KSerializer> { } override fun deserialize(decoder: Decoder): Map { - val asJsonObject: JsonObject = decoder.decodeSerializableValue(JsonObjectSerializer) + assert(decoder is JsonDecoder) {"Only JsonDecoder supported, found " + decoder::class.java} + val asJsonObject: JsonObject = (decoder as JsonDecoder).decodeJsonElement().jsonObject return asJsonObject.toPrimitiveMap() } + @ExperimentalSerializationApi override val descriptor: SerialDescriptor - get() = SerialDescriptor("arbitrary map", PolymorphicKind.OPEN) + get() = mapSerialDescriptor(PrimitiveSerialDescriptor("key", PrimitiveKind.STRING), + PrimitiveSerialDescriptor("value", PrimitiveKind.STRING)) - @ImplicitReflectionSerializer override fun serialize(encoder: Encoder, value: Map) { + assert(encoder is JsonEncoder) {"Only JsonEncoder support, found " + encoder::class.java} val asJsonObj: JsonObject = value.toJsonObject() - encoder.encode(JsonObjectSerializer, asJsonObj) + (encoder as JsonEncoder).encodeJsonElement(asJsonObj) } } diff --git a/jwt/src/main/java/me/uport/sdk/jwt/model/JwtHeader.kt b/jwt/src/main/java/me/uport/sdk/jwt/model/JwtHeader.kt index 4730105..60f7900 100644 --- a/jwt/src/main/java/me/uport/sdk/jwt/model/JwtHeader.kt +++ b/jwt/src/main/java/me/uport/sdk/jwt/model/JwtHeader.kt @@ -2,7 +2,6 @@ package me.uport.sdk.jwt.model import kotlinx.serialization.Serializable import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonConfiguration /** * Standard JWT header @@ -14,16 +13,16 @@ class JwtHeader( val alg: String = ES256K ) { - fun toJson(): String = jsonAdapter.stringify(serializer(), this) + fun toJson(): String = jsonAdapter.encodeToString(serializer(), this) companion object { const val ES256K = "ES256K" const val ES256K_R = "ES256K-R" fun fromJson(headerString: String): JwtHeader = - jsonAdapter.parse(serializer(), headerString) + jsonAdapter.decodeFromString(serializer(), headerString) private val jsonAdapter = - Json(JsonConfiguration.Stable.copy(isLenient = true, ignoreUnknownKeys = true)) + Json { isLenient = true; ignoreUnknownKeys = true; } } } diff --git a/jwt/src/main/java/me/uport/sdk/jwt/model/JwtPayload.kt b/jwt/src/main/java/me/uport/sdk/jwt/model/JwtPayload.kt index f013b2c..24d01e2 100644 --- a/jwt/src/main/java/me/uport/sdk/jwt/model/JwtPayload.kt +++ b/jwt/src/main/java/me/uport/sdk/jwt/model/JwtPayload.kt @@ -1,10 +1,9 @@ package me.uport.sdk.jwt.model -import kotlinx.serialization.ContextualSerialization import kotlinx.serialization.SerialName import kotlinx.serialization.Serializable import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonConfiguration +import me.uport.sdk.jsonrpc.model.request.DynamicLookupSerializer @Serializable data class JwtPayload( @@ -65,7 +64,7 @@ data class JwtPayload( */ @Serializable(with = ArbitraryMapSerializer::class) @SerialName("claim") - val claims: Map? = null, + val claims: Map? = null, /** * Specific to Private Chain * Also includes dad @@ -78,9 +77,9 @@ data class JwtPayload( ) { companion object { fun fromJson(payloadString: String): JwtPayload = - jsonAdapter.parse(serializer(), payloadString) + jsonAdapter.decodeFromString(serializer(), payloadString) private val jsonAdapter = - Json(JsonConfiguration.Stable.copy(isLenient = true, ignoreUnknownKeys = true)) + Json { isLenient = true; ignoreUnknownKeys = true } } } diff --git a/jwt/src/test/java/me/uport/sdk/jwt/SerializationTesting.kt b/jwt/src/test/java/me/uport/sdk/jwt/SerializationTesting.kt index 3016805..6bbdcdc 100644 --- a/jwt/src/test/java/me/uport/sdk/jwt/SerializationTesting.kt +++ b/jwt/src/test/java/me/uport/sdk/jwt/SerializationTesting.kt @@ -2,28 +2,30 @@ package me.uport.sdk.jwt import assertk.assertThat import assertk.assertions.isEqualTo -import kotlinx.serialization.ContextualSerialization +import kotlinx.serialization.ExperimentalSerializationApi import kotlinx.serialization.SerialName import kotlinx.serialization.Serializable import kotlinx.serialization.json.Json -import kotlinx.serialization.json.JsonConfiguration +import me.uport.sdk.jsonrpc.model.request.DynamicLookupSerializer import me.uport.sdk.jwt.model.ArbitraryMapSerializer import org.junit.Test +@ExperimentalSerializationApi class SerializationTesting { @Serializable data class ClassWithSerializer( - //test serializtion of annotated types + //test serialization of annotated types @SerialName("@context") val context: List ) + @ExperimentalSerializationApi @Serializable data class CompoundTestObject( //use custom serializers for arbitrary map types @Serializable(with = ArbitraryMapSerializer::class) - val generic: Map + val generic: Map ) @Test @@ -44,7 +46,7 @@ class SerializationTesting { ) ) val serialized = - Json(JsonConfiguration.Stable).stringify(CompoundTestObject.serializer(), aa) + Json.encodeToString(CompoundTestObject.serializer(), aa) assertThat(serialized).isEqualTo("""{"generic":{"hello":"world","missing":null,"some number":4321,"number as string":"1234","boolean":false,"boolean as string":"true","custom object":{"@context":["asdf"]},"obj":{"a":"b","c":null}}}""") } @@ -52,7 +54,7 @@ class SerializationTesting { fun `can deserialize known object`() { val input = """{"generic":{"hello":"world","missing":null,"some number":4321,"number as string":"1234","boolean":false,"boolean as string":"true","custom object":{"@context":["asdf"]},"obj":{"a":"b","c":null}}}""" - val parsed = Json(JsonConfiguration.Stable).parse(CompoundTestObject.serializer(), input) + val parsed = Json.decodeFromString(CompoundTestObject.serializer(), input) assertThat(parsed.generic).isEqualTo( mapOf( "hello" to "world", diff --git a/universal-did/build.gradle b/universal-did/build.gradle index 02de60b..b6f1a26 100644 --- a/universal-did/build.gradle +++ b/universal-did/build.gradle @@ -9,7 +9,7 @@ project.ext.description = "wrapper for multiple DID resolvers" dependencies { implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version" implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version" - implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$kotlin_serialization_version" + implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialization_version" testImplementation "junit:junit:$junit_version" testImplementation "com.willowtreeapps.assertk:assertk-jvm:$assertk_version" diff --git a/universal-did/src/main/java/me/uport/sdk/universaldid/DIDDocument.kt b/universal-did/src/main/java/me/uport/sdk/universaldid/DIDDocument.kt index 04ee1c3..64cf35a 100644 --- a/universal-did/src/main/java/me/uport/sdk/universaldid/DIDDocument.kt +++ b/universal-did/src/main/java/me/uport/sdk/universaldid/DIDDocument.kt @@ -2,13 +2,14 @@ package me.uport.sdk.universaldid -import kotlinx.serialization.Decoder -import kotlinx.serialization.Encoder import kotlinx.serialization.KSerializer import kotlinx.serialization.SerialName import kotlinx.serialization.Serializable import kotlinx.serialization.Serializer +import kotlinx.serialization.encoding.Decoder +import kotlinx.serialization.encoding.Encoder import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonBuilder import kotlinx.serialization.json.JsonConfiguration /** @@ -49,22 +50,20 @@ data class DIDDocumentImpl( * Serializes this [DIDDocument] into a JSON string */ fun toJson(): String = JSON - .stringify(serializer(), this) + .encodeToString(serializer(), this) companion object { - private val JSON = Json( - JsonConfiguration.Stable.copy( - encodeDefaults = true, - isLenient = true, - useArrayPolymorphism = false - ) - ) + private val JSON = Json{ + encodeDefaults = true + isLenient = true + useArrayPolymorphism = false + } /** * Attempts to deserialize a given [json] string into a [DIDDocument] */ - fun fromJson(json: String) = JSON.parse(serializer(), json) + fun fromJson(json: String) = JSON.decodeFromString(serializer(), json) } } diff --git a/web-did/build.gradle b/web-did/build.gradle index 84f074b..c2ba97c 100644 --- a/web-did/build.gradle +++ b/web-did/build.gradle @@ -9,7 +9,7 @@ project.ext.description = "resolver for the web-did method" dependencies { implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version" implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version" - implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$kotlin_serialization_version" + implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlin_serialization_version" api "com.github.uport-project.kotlin-common:core:$uport_kotlin_common_version" api project(":universal-did")