Feat/improve txmetadata

README.md

@@ -36,7 +36,7 @@ Build the android libraries to publish to Maven Central
 
 ### Use in other projects
 ```groovy
-dppVersion = "1.7.1"
+dppVersion = "1.7.2-SNAPSHOT"
 dependencies {
     implementation "org.dashj.platform:dash-sdk-java:$dppVersion"
     implementation "org.dashj.platform:dash-sdk-kotlin:$dppVersion" // dpp

build.gradle

@@ -1,5 +1,5 @@
 buildscript {
-    ext.version = '1.7.1'
+    ext.version = '1.7.2-SNAPSHOT'
     ext.kotlin_version = '1.8.22'
     ext.dashj_version = '21.1.0'
     repositories {

dash-sdk-java/src/main/swig/generics/result.i

@@ -233,25 +233,18 @@
         if ($1->ok != NULL) {
             jobject elementObj = nullptr;
             if (strcmp(#RETURN_TYPE, "String") == 0) {
-                // printf("string item\n");
-                // printf("string item: %s\n", $1->ok);
                 elementObj = jenv->NewStringUTF((const char *)$1->ok);
             } else if (strcmp(#RETURN_TYPE, "Integer") == 0) {
-                //printf("int item\n");
-                //printf("int item: %d\n", *$1->ok);
                 jclass integerClass = (jenv)->FindClass("java/lang/Integer");
                 jmethodID constructor = (jenv)->GetMethodID(integerClass, "<init>", "(I)V");
                 elementObj = (jenv)->NewObject(integerClass, constructor, (int)(long)*$1->ok); // ok is a pointer, but acts as a value
             } else if (strcmp(#RETURN_TYPE, "Long") == 0) {
-                //printf("long item\n");
-                //printf("long item: %lld\n", $1->ok);
                 jclass integerClass = (jenv)->FindClass("java/lang/Long");
                 jmethodID constructor = (jenv)->GetMethodID(integerClass, "<init>", "(J)V");
                 elementObj = (jenv)->NewObject(integerClass, constructor, (long)*$1->ok);  // ok is a pointer, but acts as a value
             } else {
                 printf("invalid? item\n");
             }
-            printf("ok value is assigned, now create result\n");
             jmethodID midSuccess = jenv->GetStaticMethodID(resultClass, "Ok", "(Ljava/lang/Object;)Lorg/dashj/platform/sdk/base/Result;");
             $result = jenv->CallStaticObjectMethod(resultClass, midSuccess, elementObj);
         } else {

dpp/src/main/java/org/dashj/platform/dapiclient/SystemIds.kt

@@ -7,11 +7,14 @@
 
 package org.dashj.platform.dapiclient
 
+import org.bitcoinj.core.Sha256Hash
 import org.dashj.platform.dpp.identifier.Identifier
 
 object SystemIds {
-    val dpnsOwnerId = Identifier.from("4EfA9Jrvv3nnCFdSf7fad59851iiTRZ6Wcu6YVJ4iSeF")
+    val dpnsOwnerId = Identifier.from(Sha256Hash.ZERO_HASH)
     val dpnsDataContractId = Identifier.from("GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec")
-    val dashpayOwnerId = Identifier.from("5PhRFRrWZc5Mj8NqtpHNXCmmEQkcZE8akyDkKhsUVD4k")
+    val dashpayOwnerId = Identifier.from(Sha256Hash.ZERO_HASH)
     val dashpayDataContractId = Identifier.from("Bwr4WHCPz5rFVAD87RqTs3izo4zpzwsEdKPWUT1NS1C7")
+    val walletUtilsOwnerId = Identifier.from(Sha256Hash.ZERO_HASH)
+    val walletUtilsDataContractId = Identifier.from("7CSFGeF4WNzgDmx94zwvHkYaG3Dx4XEe5LFsFgJswLbm")
 }

dpp/src/main/java/org/dashj/platform/dashpay/BlockchainIdentity.kt

@@ -48,7 +48,7 @@ import org.bitcoinj.wallet.authentication.AuthenticationGroupExtension
 import org.bouncycastle.crypto.params.KeyParameter
 import org.dashj.platform.wallet.TxMetadata
 import org.dashj.platform.contracts.wallet.TxMetadataDocument
-import org.dashj.platform.contracts.wallet.TxMetadataItem
+import org.dashj.platform.wallet.TxMetadataItem
 import org.dashj.platform.dapiclient.MaxRetriesReachedException
 import org.dashj.platform.dapiclient.model.DocumentQuery
 import org.dashj.platform.dashpay.callback.*
@@ -66,6 +66,7 @@ import org.dashj.platform.dpp.util.Converters
 import org.dashj.platform.sdk.*
 import org.dashj.platform.sdk.platform.Names
 import org.dashj.platform.sdk.platform.Platform
+import org.dashj.platform.wallet.WalletUtils.TxMetadataBatch
 import org.slf4j.LoggerFactory
 import java.math.BigInteger
 import java.util.concurrent.ExecutionException
@@ -2248,18 +2249,26 @@ class BlockchainIdentity {
         return "assetlocktx=$txid&pk=$wif&du=${currentUsername!!}&islock=${cftx.confidence.instantSendlock.toStringHex()}"
     }
 
-    // Transaction Metadata Methods
     @Throws(KeyCrypterException::class)
-    fun publishTxMetaData(txMetadataItems: List<TxMetadataItem>, keyParameter: KeyParameter?) {
-        if (!platform.hasApp("dashwallet")) {
-            return
+    fun createTxMetadata(txMetadataItems: List<TxMetadataItem>, keyParameter: KeyParameter?, encryptionKeyIndex: Int, version: Int): List<Document> {
+        if (!platform.hasApp("wallet-utils")) {
+            return arrayListOf()
         }
-        val keyIndex = 1
-        val encryptionKeyIndex = 0
-        val encryptionKey = privateKeyAtPath(keyIndex, TxMetadataDocument.childNumber, encryptionKeyIndex, KeyType.ECDSA_SECP256K1, keyParameter)
+        val encryptionIdentityPublicKey = identity!!.getFirstPublicKey(Purpose.ENCRYPTION, SecurityLevel.MEDIUM)
+            ?: identity!!.getFirstPublicKey(Purpose.AUTHENTICATION, SecurityLevel.HIGH)
+            ?: error("can't find a authentication public key with HIGH security level or encryption key")
+        val keyIndex = encryptionIdentityPublicKey.id
+        val encryptionKey = privateKeyAtPath(
+            keyIndex,
+            TxMetadataDocument.childNumber,
+            encryptionKeyIndex,
+            KeyType.ECDSA_SECP256K1,
+            keyParameter
+        )
 
         var lastItem: TxMetadataItem? = null
         var currentIndex = 0
+        val result = arrayListOf<Document>()
         log.info("publish ${txMetadataItems.size} by breaking it up into pieces")
         while (currentIndex < txMetadataItems.size) {
             var estimatedDocSize = 0
@@ -2280,27 +2289,48 @@ class BlockchainIdentity {
             }
 
             log.info("publishing ${currentMetadataItems.size} items of ${txMetadataItems.size}")
-            val metadataBytes = Cbor.encode(currentMetadataItems.map { it.toObject() })
+            val txMetadata = TxMetadata(platform)
+            val metadataBytes = txMetadata.getBuffer(TxMetadataDocument.VERSION_PROTOBUF, currentMetadataItems)//Cbor.encode(currentMetadataItems.map { it.toObject() })
 
             // encrypt data
             val cipher = KeyCrypterAESCBC()
             val aesKey = cipher.deriveKey(encryptionKey)
             val encryptedData = cipher.encrypt(metadataBytes, aesKey)
-
-            TxMetadata(platform).create(
+            val allEncryptedData = ByteArray(1 + encryptedData.initialisationVector.size + encryptedData.encryptedBytes.size)
+            allEncryptedData[0] = version.toByte()
+            encryptedData.initialisationVector.copyInto(allEncryptedData, 1)
+            encryptedData.encryptedBytes.copyInto(allEncryptedData, encryptedData.initialisationVector.size + 1)
+            val txMetadataDocument = txMetadata.createDocument(
                 keyIndex,
                 encryptionKeyIndex,
-                encryptedData.initialisationVector.plus(encryptedData.encryptedBytes),
+                allEncryptedData,
                 identity!!,
-                KeyIndexPurpose.AUTHENTICATION.ordinal,
-                WalletSignerCallback(wallet!!, keyParameter)
             )
+            result.add(txMetadataDocument)
             currentMetadataItems.clear()
         }
+        return result
+    }
+
+    // Transaction Metadata Methods
+    @Throws(KeyCrypterException::class)
+    fun publishTxMetaData(txMetadataItems: List<TxMetadataItem>, keyParameter: KeyParameter?, encryptionKeyIndex: Int, version: Int) {
+        if (!platform.hasApp("wallet-utils")) {
+            return
+        }
+        val documentsToPublish = createTxMetadata(txMetadataItems, keyParameter, encryptionKeyIndex, version)
+        val txMetadata = TxMetadata(platform)
+        documentsToPublish.forEach { txMetadataDocument ->
+            txMetadata.publish(
+                txMetadataDocument,
+                identity!!,
+                WalletSignerCallback(wallet!!, keyParameter)
+            )
+        }
     }
 
     fun getTxMetaData(createdAfter: Long = -1, keyParameter: KeyParameter?): Map<TxMetadataDocument, List<TxMetadataItem>> {
-        if (!platform.hasApp("dashwallet")) {
+        if (!platform.hasApp("wallet-utils")) {
             return hashMapOf()
         }
         val documents = TxMetadata(platform).get(uniqueIdentifier, createdAfter)
@@ -2315,6 +2345,7 @@ class BlockchainIdentity {
 
     @Throws(KeyCrypterException::class)
     fun decryptTxMetadata(txMetadataDocument: TxMetadataDocument, keyParameter: KeyParameter?): List<TxMetadataItem> {
+        checkArgument(wallet!!.isEncrypted == (keyParameter != null), "isEncrypted must match keyParameter")
         val cipher = KeyCrypterAESCBC()
         val encryptionKey = privateKeyAtPath(
             txMetadataDocument.keyIndex,
@@ -2324,17 +2355,27 @@ class BlockchainIdentity {
             keyParameter
         )
         val aesKeyParameter = cipher.deriveKey(encryptionKey)
-
+        val version = txMetadataDocument.encryptedMetadata[0].toInt()
         // now decrypt
         val encryptedData = EncryptedData(
-            txMetadataDocument.encryptedMetadata.copyOfRange(0, 16),
-            txMetadataDocument.encryptedMetadata.copyOfRange(16, txMetadataDocument.encryptedMetadata.size)
+            txMetadataDocument.encryptedMetadata.copyOfRange(1, 17),
+            txMetadataDocument.encryptedMetadata.copyOfRange(17, txMetadataDocument.encryptedMetadata.size)
         )
 
         val decryptedData = cipher.decrypt(encryptedData, aesKeyParameter)
-        val decryptedList = Cbor.decodeList(decryptedData)
 
-        return decryptedList.map { TxMetadataItem(it as Map<String, Any?>) }
+
+        return when (version) {
+            TxMetadataDocument.VERSION_CBOR -> {
+                val decryptedList = Cbor.decodeList(decryptedData)
+                decryptedList.map { TxMetadataItem(it as Map<String, Any?>) }
+            }
+            TxMetadataDocument.VERSION_PROTOBUF -> {
+                val decryptedList = TxMetadataBatch.parser().parseFrom(decryptedData)
+                decryptedList.itemsList.map { TxMetadataItem(it) }
+            }
+            else -> error ("invalid tx metadata version $version")
+        }
     }
 
     fun deleteDocument(typeLocator: String, documentId: Identifier, keyParameter: KeyParameter?): Boolean {

dpp/src/main/java/org/dashj/platform/sdk/platform/Platform.kt

@@ -77,16 +77,17 @@ class Platform(val params: NetworkParameters) {
     init {
         apps["dpns"] = ClientAppDefinition(SystemIds.dpnsDataContractId)
         apps["dashpay"] = ClientAppDefinition(SystemIds.dashpayDataContractId)
+        apps["wallet-utils"] = ClientAppDefinition(SystemIds.walletUtilsDataContractId)
         when {
             params.id.contains("test") -> {
                 useWhiteList = true
-                apps["dashwallet"] = ClientAppDefinition("Bhptm3yBDhLkRNt7ofjpwaBHhMUKjDrQoPufKzQaxmpK")
+                apps["identity-verify"] = ClientAppDefinition("Bhptm3yBDhLkRNt7ofjpwaBHhMUKjDrQoPufKzQaxmpK")
             }
             params.id.contains("bintang") -> {
-                apps["dashwallet"] = ClientAppDefinition("Fds5DDfXoLwpUZ71AAVYZP1uod8S7Ze2bR28JExBvZKR")
+                apps["identity-verify"] = ClientAppDefinition("Fds5DDfXoLwpUZ71AAVYZP1uod8S7Ze2bR28JExBvZKR")
             }
             params.id.contains("production") -> {
-                apps["dashwallet"] = ClientAppDefinition("EVKMFboB3QBUa9Jo7PP5bsLyohzUz8zvw5c2gJs1SfcX")
+                apps["identity-verify"] = ClientAppDefinition("EVKMFboB3QBUa9Jo7PP5bsLyohzUz8zvw5c2gJs1SfcX")
             }
         }
         System.loadLibrary("sdklib")

dpp/src/main/java/org/dashj/platform/wallet/IdentityVerify.kt

@@ -27,7 +27,7 @@ class IdentityVerify(
 ) {
 
     companion object {
-        const val DOCUMENT: String = "dashwallet.identityVerify"
+        const val DOCUMENT: String = "identity-verify.identityVerify"
         private val log = LoggerFactory.getLogger(IdentityVerify::class.java)
     }
 

dpp/src/main/java/org/dashj/platform/wallet/TxMetadata.kt

@@ -10,28 +10,31 @@ package org.dashj.platform.wallet
 import java.util.Date
 import kotlin.collections.HashMap
 import org.bitcoinj.core.ECKey
+import org.dashj.platform.contracts.wallet.TxMetadataDocument
 import org.dashj.platform.dapiclient.model.DocumentQuery
 import org.dashj.platform.dashpay.callback.SingleKeySignerCallback
 import org.dashj.platform.dpp.document.Document
 import org.dashj.platform.dpp.document.DocumentCreateTransition
 import org.dashj.platform.dpp.document.DocumentsBatchTransition
 import org.dashj.platform.dpp.identifier.Identifier
 import org.dashj.platform.dpp.identity.Identity
+import org.dashj.platform.dpp.util.Cbor
 import org.dashj.platform.sdk.BlockHeight
 import org.dashj.platform.sdk.CoreBlockHeight
 import org.dashj.platform.sdk.Purpose
 import org.dashj.platform.sdk.SecurityLevel
 import org.dashj.platform.sdk.callbacks.Signer
 import org.dashj.platform.sdk.dashsdk
 import org.dashj.platform.sdk.platform.Platform
+import org.dashj.platform.wallet.WalletUtils.TxMetadataBatch
 import java.math.BigInteger
 
 class TxMetadata(
     val platform: Platform
 ) {
 
     companion object {
-        const val DOCUMENT: String = "dashwallet.tx_metadata"
+        const val DOCUMENT: String = "wallet-utils.txMetadata"
     }
 
     fun create(
@@ -63,6 +66,30 @@ class TxMetadata(
         return Document(domain, profileDocument.dataContractId!!)
     }
 
+    fun publish(
+        txMetadataDocument: Document,
+        identity: Identity,
+        signer: Signer
+    ): Document {
+        val highIdentityPublicKey = identity.getFirstPublicKey(Purpose.AUTHENTICATION, SecurityLevel.HIGH)
+            ?: error("can't find a public key with HIGH security level")
+
+        val documentResult = dashsdk.platformMobilePutPutDocumentSdk(
+            platform.rustSdk,
+            txMetadataDocument.toNative(),
+            txMetadataDocument.dataContractId!!.toNative(),
+            txMetadataDocument.type,
+            highIdentityPublicKey.toNative(),
+            BlockHeight(10000),
+            CoreBlockHeight(platform.coreBlockHeight),
+            signer.nativeContext,
+            BigInteger.valueOf(signer.signerCallback),
+        )
+        val domain = documentResult.unwrap()
+
+        return Document(domain, txMetadataDocument.dataContractId!!)
+    }
+
     fun createDocument(
         keyIndex: Int,
         encryptionKeyIndex: Int,
@@ -83,17 +110,27 @@ class TxMetadata(
         return document
     }
 
+    fun getBuffer(version: Int, metadataItems: List<TxMetadataItem>): ByteArray {
+        return when (version) {
+            TxMetadataDocument.VERSION_CBOR -> Cbor.encode(metadataItems.map { it.toObject() })
+            TxMetadataDocument.VERSION_PROTOBUF -> {
+                TxMetadataBatch.newBuilder().addAllItems(metadataItems.map { it.toProtobuf() }).build().toByteArray()
+            }
+            else -> error("Invalid version txmetadata $version")
+        }
+    }
+
     fun get(userId: String): List<Document> {
         return get(Identifier.from(userId))
     }
 
     fun get(userId: Identifier, createdAfter: Long = -1): List<Document> {
         val queryBuilder = DocumentQuery.Builder()
             .where("\$ownerId", "==", userId)
-            .orderBy("\$createdAt")
+            .orderBy("\$updatedAt")
 
         if (createdAfter != -1L) {
-            queryBuilder.where(listOf("\$createdAt", ">=", createdAfter))
+            queryBuilder.where(listOf("\$updatedAt", ">=", createdAfter))
         }
 
         val query = queryBuilder.build()

dpp/src/main/java/org/dashj/platform/wallet/TxMetadataDocument.kt

@@ -14,13 +14,19 @@ import org.bouncycastle.crypto.params.KeyParameter
 import org.dashj.platform.dpp.document.Document
 import org.dashj.platform.dpp.util.Cbor
 import org.dashj.platform.sdk.platform.AbstractDocument
+import org.dashj.platform.wallet.TxMetadataItem
+import org.dashj.platform.wallet.WalletUtils.TxMetadataBatch
 
 class TxMetadataDocument(document: Document) : AbstractDocument(document) {
 
     companion object {
         // 2^16 + 2
         val childNumber = ChildNumber(2 shl 15 + 1, true)
         const val MAX_ENCRYPTED_SIZE = 4096 - 32 // leave room for a partially filled block and the IV
+
+        const val VERSION_UNKNOWN = -1
+        const val VERSION_CBOR = 0
+        const val VERSION_PROTOBUF = 1
     }
 
     val keyIndex: Int
@@ -29,6 +35,8 @@ class TxMetadataDocument(document: Document) : AbstractDocument(document) {
         get() = (document.data["encryptionKeyIndex"] as Long).toInt()
     val encryptedMetadata: ByteArray
         get() = getFieldByteArray("encryptedMetadata")!!
+    var txMetadataVersion = VERSION_UNKNOWN
+        private set
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
@@ -53,9 +61,20 @@ class TxMetadataDocument(document: Document) : AbstractDocument(document) {
         val iv = encryptedMetadata.copyOfRange(0, 16)
         val encryptedData = encryptedMetadata.copyOfRange(16, encryptedMetadata.size)
         val decryptedData = cipher.decrypt(EncryptedData(iv, encryptedData), keyParameter)
-        // use Cbor.decodeList
-        val list = Cbor.decodeList(decryptedData)
-        // use .map to convert to List<TxMetadataItem>
-        return list.map { TxMetadataItem(it as Map<String, Any?>) }
+        val version = decryptedData.copyOfRange(0, 1)[0].toInt() and 0xFF
+        return when (version) {
+            VERSION_CBOR -> {
+                val list = Cbor.decodeList(decryptedData)
+                this.txMetadataVersion = VERSION_CBOR
+                // use .map to convert to List<TxMetadataItem>
+                list.map { TxMetadataItem(it as Map<String, Any?>) }
+            }
+            VERSION_PROTOBUF -> {
+                val batch = TxMetadataBatch.parser().parseFrom(decryptedData, 1, decryptedData.size - 1)
+                txMetadataVersion = VERSION_PROTOBUF
+                batch.itemsList.map { TxMetadataItem(it) }
+            }
+            else -> error("")
+        }
     }
 }