feat: add mock staterepo

build.gradle

@@ -2,10 +2,10 @@ import org.jlleitschuh.gradle.ktlint.reporter.ReporterType
 
 buildscript {
     ext.kotlin_version = '1.4.32'
-    ext.dashpay_version = '0.24-SNAPSHOT'
+    ext.dashpay_version = '0.24-MOCK-SNAPSHOT'
     ext.dpp_version = '0.24-SNAPSHOT'
     ext.dapi_client_version = '0.24-SNAPSHOT'
-    ext.dashj_version = '19.1-CJ-SNAPSHOT'
+    ext.dashj_version = '20.0.2-CJ-SNAPSHOT'
     repositories {
         mavenCentral()
         maven { url "https://plugins.gradle.org/m2/" }

dashpay/src/main/kotlin/org/dashj/platform/dashpay/BlockchainIdentity.kt

@@ -31,7 +31,7 @@ import org.bitcoinj.crypto.HDUtils
 import org.bitcoinj.crypto.KeyCrypterAESCBC
 import org.bitcoinj.crypto.KeyCrypterECDH
 import org.bitcoinj.crypto.KeyCrypterException
-import org.bitcoinj.evolution.CreditFundingTransaction
+import org.bitcoinj.evolution.AssetLockTransaction
 import org.bitcoinj.evolution.EvolutionContact
 import org.bitcoinj.quorums.InstantSendLock
 import org.bitcoinj.wallet.AuthenticationKeyChain
@@ -185,7 +185,7 @@ class BlockchainIdentity {
     lateinit var keyInfo: MutableMap<Long, MutableMap<String, Any>>
     var currentMainKeyIndex: Int = 0
     var currentMainKeyType: IdentityPublicKey.Type = IdentityPublicKey.Type.ECDSA_SECP256K1
-    var creditFundingTransaction: CreditFundingTransaction? = null
+    var assetLockTransaction: AssetLockTransaction? = null
     lateinit var registrationFundingPrivateKey: ECKey
 
     // profile
@@ -236,14 +236,14 @@ class BlockchainIdentity {
 
     constructor(
         platform: Platform,
-        transaction: CreditFundingTransaction,
+        transaction: AssetLockTransaction,
         wallet: Wallet,
         authenticationGroupExtension: AuthenticationGroupExtension,
         registeredIdentity: Identity? = null
-    ) : this(platform, transaction.usedDerivationPathIndex, transaction.lockedOutpoint, wallet, authenticationGroupExtension) {
-        Preconditions.checkArgument(!transaction.creditBurnPublicKey.isPubKeyOnly || transaction.creditBurnPublicKey.isEncrypted)
-        creditFundingTransaction = transaction
-        registrationFundingPrivateKey = transaction.creditBurnPublicKey
+    ) : this(platform, transaction.getUsedDerivationPathIndex(0), transaction.lockedOutpoint, wallet, authenticationGroupExtension) {
+        Preconditions.checkArgument(!transaction.assetLockPublicKey.isPubKeyOnly || transaction.assetLockPublicKey.isEncrypted)
+        assetLockTransaction = transaction
+        registrationFundingPrivateKey = transaction.assetLockPublicKey
 
         // see if the identity is registered.
         initializeIdentity(registeredIdentity, false)
@@ -288,7 +288,7 @@ class BlockchainIdentity {
 
     constructor(
         platform: Platform,
-        transaction: CreditFundingTransaction,
+        transaction: AssetLockTransaction,
         usernameStatus: MutableMap<String, Any>,
         wallet: Wallet,
         authenticationGroupExtension: AuthenticationGroupExtension
@@ -314,7 +314,7 @@ class BlockchainIdentity {
     constructor(
         platform: Platform,
         index: Int,
-        transaction: CreditFundingTransaction,
+        transaction: AssetLockTransaction,
         usernameStatus: MutableMap<String, Any>,
         credits: Coin,
         registrationStatus: RegistrationStatus,
@@ -328,47 +328,47 @@ class BlockchainIdentity {
 
     // MARK: - Full Registration agglomerate
 
-    fun createCreditFundingTransaction(credits: Coin, keyParameter: KeyParameter?, useCoinJoin: Boolean = false): CreditFundingTransaction {
-        checkState(creditFundingTransaction == null, "The credit funding transaction must not exist")
+    fun createAssetLockTransaction(credits: Coin, keyParameter: KeyParameter?, useCoinJoin: Boolean, returnChange: Boolean): AssetLockTransaction {
+        checkState(assetLockTransaction == null, "The credit funding transaction must not exist")
         checkState(
             registrationStatus == RegistrationStatus.UNKNOWN,
             "The identity must not be registered"
         )
-        return createFundingTransaction(AuthenticationKeyChain.KeyChainType.BLOCKCHAIN_IDENTITY_FUNDING, credits, keyParameter, useCoinJoin)
+        return createFundingTransaction(AuthenticationKeyChain.KeyChainType.BLOCKCHAIN_IDENTITY_FUNDING, credits, keyParameter, useCoinJoin, returnChange)
     }
 
-    fun createTopupFundingTransaction(credits: Coin, keyParameter: KeyParameter?, useCoinJoin: Boolean): CreditFundingTransaction {
-        return createFundingTransaction(AuthenticationKeyChain.KeyChainType.BLOCKCHAIN_IDENTITY_TOPUP, credits, keyParameter, useCoinJoin)
+    fun createTopupFundingTransaction(credits: Coin, keyParameter: KeyParameter?, useCoinJoin: Boolean, returnChange: Boolean): AssetLockTransaction {
+        return createFundingTransaction(AuthenticationKeyChain.KeyChainType.BLOCKCHAIN_IDENTITY_TOPUP, credits, keyParameter, useCoinJoin, returnChange)
     }
 
-    fun createInviteFundingTransaction(credits: Coin, keyParameter: KeyParameter?, useCoinJoin: Boolean): CreditFundingTransaction {
-        return createFundingTransaction(AuthenticationKeyChain.KeyChainType.INVITATION_FUNDING, credits, keyParameter, useCoinJoin)
+    fun createInviteFundingTransaction(credits: Coin, keyParameter: KeyParameter?, useCoinJoin: Boolean, returnChange: Boolean): AssetLockTransaction {
+        return createFundingTransaction(AuthenticationKeyChain.KeyChainType.INVITATION_FUNDING, credits, keyParameter, useCoinJoin, returnChange)
     }
 
     private fun createFundingTransaction(
         type: AuthenticationKeyChain.KeyChainType,
         credits: Coin,
         keyParameter: KeyParameter?,
-        useCoinJoin: Boolean
-    ): CreditFundingTransaction {
+        useCoinJoin: Boolean,
+        returnChange: Boolean
+    ): AssetLockTransaction {
         Preconditions.checkArgument(if (wallet!!.isEncrypted) keyParameter != null else true)
         val privateKey = authenticationGroup!!.currentKey(type)
         val request = SendRequest.creditFundingTransaction(wallet!!.params, privateKey as ECKey, credits)
         if (useCoinJoin) {
             // these are the settings for coinjoin
             request.coinSelector = CoinJoinCoinSelector(wallet!!)
-            request.returnChange = false
-            request.emptyWallet = true // spend all coinjoin balance
+            request.returnChange = returnChange
         } else {
             request.coinSelector = ZeroConfCoinSelector.get()
         }
         request.aesKey = keyParameter
 
-        return wallet!!.sendCoinsOffline(request) as CreditFundingTransaction
+        return wallet!!.sendCoinsOffline(request) as AssetLockTransaction
     }
 
-    fun initializeCreditFundingTransaction(creditFundingTransaction: CreditFundingTransaction) {
-        this.creditFundingTransaction = creditFundingTransaction
+    fun initializeAssetLockTransaction(creditFundingTransaction: AssetLockTransaction) {
+        this.assetLockTransaction = creditFundingTransaction
         registrationStatus = RegistrationStatus.NOT_REGISTERED
     }
 
@@ -389,23 +389,23 @@ class BlockchainIdentity {
             registrationStatus != RegistrationStatus.REGISTERED,
             "The identity must not be registered"
         )
-        checkState(creditFundingTransaction != null, "The credit funding transaction must exist")
+        checkState(assetLockTransaction != null, "The credit funding transaction must exist")
 
         val (privateKeyList, identityPublicKeys) = createIdentityPublicKeys(keyParameter)
         val privateKeys = privateKeyList.map { maybeDecryptKey(it, keyParameter)?.privKeyBytes!! }
 
-        val signingKey = maybeDecryptKey(creditFundingTransaction!!.creditBurnPublicKey, keyParameter)
+        val signingKey = maybeDecryptKey(assetLockTransaction!!.assetLockPublicKey, keyParameter)
 
-        val coreHeight = if (creditFundingTransaction!!.confidence.confidenceType == TransactionConfidence.ConfidenceType.BUILDING) {
-            creditFundingTransaction!!.confidence.appearedAtChainHeight
+        val coreHeight = if (assetLockTransaction!!.confidence.confidenceType == TransactionConfidence.ConfidenceType.BUILDING) {
+            assetLockTransaction!!.confidence.appearedAtChainHeight
         } else {
-            val txInfo = platform.client.getTransaction(creditFundingTransaction!!.txId.toString())
+            val txInfo = platform.client.getTransaction(assetLockTransaction!!.txId.toString())
             txInfo?.height ?: -1
         }.toLong()
 
         identity = platform.identities.register(
-            creditFundingTransaction!!.outputIndex,
-            creditFundingTransaction!!,
+            0,
+            assetLockTransaction!!,
             coreHeight,
             signingKey!!,
             privateKeys,
@@ -414,7 +414,7 @@ class BlockchainIdentity {
 
         registrationStatus = RegistrationStatus.REGISTERED
 
-        finalizeIdentityRegistration(creditFundingTransaction!!)
+        finalizeIdentityRegistration(assetLockTransaction!!)
 
         registrationStatus = RegistrationStatus.REGISTERED
     }
@@ -424,41 +424,41 @@ class BlockchainIdentity {
             registrationStatus != RegistrationStatus.REGISTERED,
             "The identity must not be registered"
         )
-        checkState(creditFundingTransaction != null, "The credit funding transaction must exist")
+        checkState(assetLockTransaction != null, "The credit funding transaction must exist")
 
         val (privateKeyList, identityPublicKeys) = createIdentityPublicKeys(keyParameter)
 
-        val signingKey = maybeDecryptKey(creditFundingTransaction!!.creditBurnPublicKey, keyParameter)
+        val signingKey = maybeDecryptKey(assetLockTransaction!!.assetLockPublicKey, keyParameter)
         val privateKeys = privateKeyList.map {
             println(it)
             maybeDecryptKey(it, keyParameter)?.privKeyBytes!!
         }
 
         var instantLock: InstantSendLock? =
-            wallet!!.context.instantSendManager?.getInstantSendLockByTxId(creditFundingTransaction!!.txId)
+            wallet!!.context.instantSendManager?.getInstantSendLockByTxId(assetLockTransaction!!.txId)
 
         if (instantLock == null) {
-            instantLock = creditFundingTransaction!!.confidence?.instantSendlock
+            instantLock = assetLockTransaction!!.confidence?.instantSendlock
 
-            val coreHeight = if (creditFundingTransaction!!.confidence.confidenceType == TransactionConfidence.ConfidenceType.BUILDING) {
-                creditFundingTransaction!!.confidence.appearedAtChainHeight.toLong()
+            val coreHeight = if (assetLockTransaction!!.confidence.confidenceType == TransactionConfidence.ConfidenceType.BUILDING) {
+                assetLockTransaction!!.confidence.appearedAtChainHeight.toLong()
             } else {
                 -1L
             }
 
             if (instantLock == null && coreHeight > 0) {
                 identity = platform.identities.register(
-                    creditFundingTransaction!!.outputIndex,
-                    creditFundingTransaction!!,
+                    0,
+                    assetLockTransaction!!,
                     coreHeight,
                     signingKey!!,
                     privateKeys,
                     identityPublicKeys
                 )
             } else if (instantLock != null) {
                 identity = platform.identities.register(
-                    creditFundingTransaction!!.outputIndex,
-                    creditFundingTransaction!!,
+                    0,
+                    assetLockTransaction!!,
                     instantLock,
                     signingKey!!,
                     privateKeys,
@@ -467,8 +467,8 @@ class BlockchainIdentity {
             } else throw InvalidInstantAssetLockProofException("instantLock == null")
         } else {
             identity = platform.identities.register(
-                creditFundingTransaction!!.outputIndex,
-                creditFundingTransaction!!,
+                0,
+                assetLockTransaction!!,
                 instantLock,
                 signingKey!!,
                 privateKeys,
@@ -478,7 +478,7 @@ class BlockchainIdentity {
 
         registrationStatus = RegistrationStatus.REGISTERED
 
-        finalizeIdentityRegistration(creditFundingTransaction!!)
+        finalizeIdentityRegistration(assetLockTransaction!!)
     }
 
     private fun createIdentityPublicKeys(keyParameter: KeyParameter?): Pair<List<ECKey>, List<IdentityPublicKey>> {
@@ -519,14 +519,14 @@ class BlockchainIdentity {
         return Pair(listOf(identityPrivateKey, identityPrivateKey2), listOf(masterKey, highKey))
     }
 
-    fun recoverIdentity(creditFundingTransaction: CreditFundingTransaction): Boolean {
+    fun recoverIdentity(creditFundingTransaction: AssetLockTransaction): Boolean {
         checkState(
             registrationStatus == RegistrationStatus.UNKNOWN,
             "The identity must not be registered"
         )
 
         identity =
-            platform.identities.get(creditFundingTransaction.creditBurnIdentityIdentifier.toStringBase58())
+            platform.identities.get(creditFundingTransaction.identityId.toStringBase58())
             ?: return false
 
         registrationStatus = RegistrationStatus.REGISTERED
@@ -563,11 +563,11 @@ class BlockchainIdentity {
         finalizeIdentityRegistration(creditBurnIdentifier)
     }
 
-    private fun finalizeIdentityRegistration(fundingTransaction: CreditFundingTransaction) {
-        this.creditFundingTransaction = fundingTransaction
-        this.registrationFundingPrivateKey = fundingTransaction.creditBurnPublicKey
+    private fun finalizeIdentityRegistration(fundingTransaction: AssetLockTransaction) {
+        this.assetLockTransaction = fundingTransaction
+        this.registrationFundingPrivateKey = fundingTransaction.assetLockPublicKey
         this.lockedOutpoint = fundingTransaction.lockedOutpoint
-        finalizeIdentityRegistration(fundingTransaction.creditBurnIdentityIdentifier)
+        finalizeIdentityRegistration(fundingTransaction.identityId)
     }
 
     private fun finalizeIdentityRegistration(uniqueId: Sha256Hash) {
@@ -1916,15 +1916,15 @@ class BlockchainIdentity {
 
     fun getInvitationHistory(): Map<Identifier, Identity?> {
         val inviteTxs = authenticationGroup!!.invitationFundingTransactions
-        val listIds = inviteTxs.map { Identifier.from(it.creditBurnIdentityIdentifier) }
+        val listIds = inviteTxs.map { Identifier.from(it.identityId) }
 
         return listIds.associateBy({ it }, { platform.identities.get(it) })
     }
 
-    fun getInvitationString(cftx: CreditFundingTransaction, encryptionKey: KeyParameter?): String {
+    fun getInvitationString(cftx: AssetLockTransaction, encryptionKey: KeyParameter?): String {
         val txid = cftx.txId
 
-        val privateKey = maybeDecryptKey(cftx.creditBurnPublicKey, encryptionKey)
+        val privateKey = maybeDecryptKey(cftx.assetLockPublicKey, encryptionKey)
         val wif = privateKey?.getPrivateKeyEncoded(wallet!!.params)
         return "assetlocktx=$txid&pk=$wif&du=${currentUsername!!}&islock=${cftx.confidence.instantSendlock.toStringHex()}"
     }

dashpay/src/main/kotlin/org/dashj/platform/dashpay/DashPayWalletExtension.kt

@@ -82,11 +82,11 @@ class DashPayWalletExtension(
     fun validate(containingWallet: Wallet): Boolean {
         val authExtension = containingWallet.addOrGetExistingExtension(AuthenticationGroupExtension(containingWallet.params)) as AuthenticationGroupExtension
         // validate
-        val list = authExtension.creditFundingTransactions
+        val list = authExtension.assetLockTransactions
         for (cftx in list) {
-            val tx = authExtension.getCreditFundingTransaction(cftx)
-            if (tx.creditBurnIdentityIdentifier.toString() != blockchainIdentity?.uniqueId.toString()) {
-                log.error("Error: ${tx.creditBurnIdentityIdentifier} != ${blockchainIdentity?.uniqueId}")
+            val tx = authExtension.getAssetLockTransaction(cftx)
+            if (tx.identityId.toString() != blockchainIdentity?.uniqueId.toString()) {
+                log.error("Error: ${tx.identityId} != ${blockchainIdentity?.uniqueId}")
                 return false
             }
         }

examples/src/main/kotlin/org/dashj/platform/examples/CreateIdentity.kt

@@ -7,7 +7,7 @@
 package org.dashj.platform.examples
 
 import java.lang.Thread.sleep
-import org.bitcoinj.evolution.CreditFundingTransaction
+import org.bitcoinj.evolution.AssetLockTransaction
 import org.bitcoinj.quorums.InstantSendLock
 import org.dashj.platform.dpp.identity.IdentityPublicKey
 import org.dashj.platform.sdk.Client
@@ -26,12 +26,12 @@ class CreateIdentity {
         fun createIdentity() {
             val platform = sdk.platform
 
-            val cftx = CreditFundingTransaction(platform.params, DefaultIdentity.creditBurnTx)
-            cftx.setCreditBurnPublicKeyAndIndex(DefaultIdentity.identityPrivateKey, 0)
+            val cftx = AssetLockTransaction(platform.params, DefaultIdentity.creditBurnTx)
+            cftx.setAssetLockPublicKey(DefaultIdentity.identityPrivateKey)
             val islock = InstantSendLock(platform.params, DefaultIdentity.islock, InstantSendLock.ISLOCK_VERSION)
 
             try {
-                var identity = platform.identities.get(cftx.creditBurnIdentityIdentifier.toStringBase58())
+                var identity = platform.identities.get(cftx.identityId.toStringBase58())
 
                 if (identity == null) {
                     // only create the identity if it does not exist
@@ -48,7 +48,7 @@ class CreateIdentity {
                         )
                     )
                     sleep(10000)
-                    identity = platform.identities.get(cftx.creditBurnIdentityIdentifier.toString())
+                    identity = platform.identities.get(cftx.identityId.toString())
                 }
 
                 // check that the identity public key matches our public key information
@@ -57,7 +57,7 @@ class CreateIdentity {
                 }
 
                 // display information
-                println("Identity Created: ${cftx.creditBurnIdentityIdentifier.toStringBase58()}")
+                println("Identity Created: ${cftx.identityId.toStringBase58()}")
                 println(JSONObject(identity!!.toJSON()).toString(2))
                 println("Private Key: ${DefaultIdentity.privateKeyHex} (hex)")
             } catch (e: Exception) {

examples/src/main/kotlin/org/dashj/platform/examples/CreateWallets.kt

@@ -18,7 +18,7 @@ import org.bitcoinj.core.Coin
 import org.bitcoinj.core.ECKey
 import org.bitcoinj.core.Transaction
 import org.bitcoinj.core.TransactionOutput
-import org.bitcoinj.evolution.CreditFundingTransaction
+import org.bitcoinj.evolution.AssetLockTransaction
 import org.bitcoinj.params.TestNet3Params
 import org.bitcoinj.utils.BriefLogFormatter
 import org.bitcoinj.wallet.AuthenticationKeyChain
@@ -192,12 +192,12 @@ class CreateWallets {
                     CoinSelection(Coin.valueOf(total), selected)
                 }
 
-                val cftx = wallet.sendCoinsOffline(sendRequest) as CreditFundingTransaction
+                val cftx = wallet.sendCoinsOffline(sendRequest) as AssetLockTransaction
                 val cftxid = runRpc("sendrawtransaction ${cftx.bitcoinSerialize().toHex()}")
                 println("credit funding tx: ${cftx.txId}")
                 println("credit funding tx sent via rpc: $cftxid")
-                println("identity id: ${cftx.creditBurnIdentityIdentifier.toStringBase58()}")
-                println("pubkey hash: ${cftx.creditBurnPublicKeyId}")
+                println("identity id: ${cftx.identityId.toStringBase58()}")
+                println("pubkey hash: ${cftx.assetLockPublicKeyId}")
 
                 // we need to wait until the transaction is confirmed or instantsend
                 var transaction = runRpc("getrawtransaction ${cftxid!!.trim()} true")

examples/src/main/kotlin/org/dashj/platform/examples/DefaultIdentity.kt

@@ -64,7 +64,7 @@ class DefaultIdentity(val params: NetworkParameters) {
     init {
         when {
             params.id.contains("test") -> {
-                seed = "horn welcome exact penalty beauty marble current leave arrest chunk emotion upset"
+                seed = "also negative confirm imitate balance foam edit under mule indoor cream huge"
             }
             params.id.contains("jack-daniels") -> {
                 seed = "print shuffle enlist object actress allow quality convince believe gauge tree laundry"