DRAFT: Offline Token Money - 2

README.md

@@ -27,6 +27,97 @@ An online indicator and the last message is shown for each contact. Users can ex
 
 ### DeToks
 **Decentralised TikTok** skeleton app for the CS4160 Blockchain Engineering (2022/23) course.
+### Detoks - Offline Token 2
+An offline payment application that makes sending and receiving tokens easily.
+A user can choose the amount to be received and create a request which can be paid by a preadded contact.
+The payment can then be done by scanning the generated QR code and a transaction is then made.
+A Eurotoken is minted and verified by a central authority.
+
+Code Link - https://github.com/Ne184/trustchain-superapp/
+
+APK - https://drive.google.com/file/d/1r2p7AvBQ-pumPTApD-cKcR0m7v0g8q1D/view?usp=share_link
+
+### Use case
+The application can be used for the following use cases:
+
+**1. Create and store EuroToken**
+
+Creating eurotokens can be performed currently from both the wallet page and admin page by first specifying
+the value of the token and then pressing the "Create new coin" button. The new token can then be seen on the screen.
+
+<img src="https://user-images.githubusercontent.com/51911288/234987435-1e243fc7-2fb0-48b9-b92b-15b700237178.gif" width="250">
+
+
+**2. Send and receive EuroToken between contacts** (by encoding and creating QR for EuroToken)
+
+To send money, you need to press the "Send" button on the screen with the video.
+After that, the recipient of the token and positive amount needs to be specified.
+If the balance is enough and the specified amount could be created exactly then the QR code is displayed and the receiver can scan it by clicking on the "Scan" button.
+
+  **1. Send Money**
+
+  <img src="https://user-images.githubusercontent.com/51911288/234988501-b7d9c9e7-196b-44a3-af13-0b1f256bfded.gif" width="250">
+
+  **2. Receive Money**
+
+  <img src="https://user-images.githubusercontent.com/51911288/234988273-5d7c7dd7-cc49-4ff0-9dc9-05f2d4d6be33.gif" width="250">
+
+
+**3. Add new contact**
+
+To add a new contact, first press on the "Send" button on the top right of the screen with the displayed video. After that to navigate to the contact page, press on the top right the button "Add Friend". You should now see a screen with two big buttons "Show My Public Key" and "Scan Recipient's Key" the QR code that encodes the public key is shown. Depending on whether you want to add a contact or another user wants to save your contact you should press on one of the buttons.
+
+Pressing on "Show My Public Key" a QR code that encodes your public key is shown.
+"Scan Recipient's Key" triggers the scanner and the QR code of the new contact can be scanned.
+After that the name should be specified and pressing "Save" will save the new entry.
+
+<img src="https://user-images.githubusercontent.com/51911288/234988799-410dbeba-405b-4a30-97a1-aee00c5b5a39.gif" width="250">
+
+
+### Double spending
+To mitigate double spending, contacts are to be added before users can send or receive EuroTokens.
+This makes it easier for admins to track double-spend EuroToken and give users warnings when trying to add malicious users.
+Another important concept is used to make sure that the detection of double spending is relatively on time.
+After receiving a new token, the token is valid for a limited amount of time (a month).
+After that month a token must be verified before being able to re-spend it. The token will be restamped with a new timestamp which makes it a valid euro token.
+
+### Preventing Double Spending
+
+We prevent the same QR Code to be scanned by two different people, thereby preventing Double Spending. This is achieved with the concept of maintaining an addressbook. An addressbook keeps a list of recipients and their corresponding Public Key. In order to send money, the recipient needs to be added to the sender's addressbook.
+
+- More Details
+Before sending the token, the public key of the receiver is encoded in the recipients of the token.
+Once the token is scanned, prior to adding it to the wallet, the public key of the receiver and the encoded public key of the recipient are compared.
+In case they match, the transaction is successful, otherwise, a message for the user is displayed - "This token is not for you!".
+Since the public key is unique, this token has a unique receiver.
+
+<img src="https://user-images.githubusercontent.com/51911288/234989059-bcbc8d96-9500-4d31-8120-56175909178f.gif" width="250">
+
+
+### QR codes explanation
+#### Contact QR Code:
+In order to be able to send tokens, first the receiver contact needs to be saved as a friend. This could be performed by pressing the button "Add Friend" and then "Show My Public Key" and the QR code that encodes the public key is shown. The sender of the money can then scan it and save it as a contact for later use.
+First, the public key is serialized to a JSON object and then it is encoded to bitmap and the QR code is created and shown on the screen of the user.
+
+<img src="https://user-images.githubusercontent.com/51911288/234995696-dfe0f268-b0be-4f5a-be69-f61e5d6ea270.jpg" width="250">
+
+
+#### Token QR Code:
+This QR code is shown once a positive amount less or equal to the balance of the user is specified and the receiver is also chosen from the dropdown menu.
+The QR code contains all tokens whose value sums exactly to the specified amount by the user. In case the specified amount can not be formed by the existent tokens then the following message is shown to the user - "Not Successful (not enough money or could get amount)". In case however, the amount can be made by the existing tokens, then those tokens are first serialized to JSON objects, then compressed and the compression is encoded as a bitmap and displayed to the user.
+After this, a message -"Successful " with the new balance is shown.
+
+<img src="https://user-images.githubusercontent.com/51911288/234995712-3321eaf0-a533-4309-863b-aedf662573f6.jpg" width="250">
+
+
+### Limitations
+1. Even though we compress and uncompress the QR code, the QR code gets very cluttered while encoding large number of tokens and makes it difficult for the recipient receiving money to scan the QR Code.
+2. Cannot do more transactions due to the limited size of QR Code.
+
+### Future work
+To detect the double spending, two ideas were discussed which can be implemented in the future:
+1. Using the verifivation mechanism, double spending can be easily detected when two users try to verify the same token. The authority will be able to direcly detect the double spender.
+2. To prevent double spending in offline transactions, a given precentage of the user tokens is preserved and cannot be used to make payments until the user comes online.
 
 ### Digital Euro
 

app/src/main/AndroidManifest.xml

@@ -125,7 +125,7 @@
         <activity
             android:name="nl.tudelft.trustchain.detoks.DeToksActivity"
             android:parentActivityName=".ui.dashboard.DashboardActivity"
-            android:theme="@style/Fullscreen" />
+            android:theme="@style/Theme.PeerChat" />
 
         <activity
             android:name="nl.tudelft.trustchain.valuetransfer.ValueTransferMainActivity"

detoks/build.gradle

@@ -53,6 +53,7 @@ dependencies {
     implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
     implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
     implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
+    implementation 'androidx.cardview:cardview:1.0.0'
 
     // Material
     implementation 'com.google.android.material:material:1.8.0'
@@ -61,6 +62,8 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version"
+//    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.0")
+    implementation 'com.google.code.gson:gson:2.10.1'
     implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
 
     // Logging

detoks/src/main/AndroidManifest.xml

@@ -13,7 +13,6 @@
             android:name="nl.tudelft.trustchain.detoks.DeToksActivity"
             android:configChanges="keyboardHidden|orientation|screenSize"
             android:label="@string/title_activity_main_detoks"
-            android:theme="@style/Fullscreen"
             android:windowSoftInputMode="stateHidden" />
     </application>
 

detoks/src/main/MainCoin.kt

@@ -0,0 +1,32 @@
+import newcoin.*
+
+/**
+ * Code source is https://medium.com/@vasilyf/lets-implement-a-cryptocurrency-in-kotlin-part-1-blockchain-8704069f8580
+ */
+fun main(args: Array<String>) {
+
+
+    val blockChain = BlockChain()
+    val walletA = Wallet.create(blockChain)
+    val walletB = Wallet.create(blockChain)
+
+    println("Wallet A balance: ${walletA.balance}")
+    println("Wallet B balance: ${walletB.balance}")
+
+    val tx1 = Transaction.create(sender = walletA.publicKey, recipient = walletA.publicKey, amount = 100)
+    tx1.outputs.add(TransactionOutput(recipient = walletA.publicKey, amount = 100, transactionHash = tx1.hash))
+    tx1.sign(walletA.privateKey)
+
+    var genesisBlock = Block(previousHash = "0")
+    genesisBlock.addTransaction(tx1)
+    genesisBlock = blockChain.add(genesisBlock)
+
+    println("Wallet A balance: ${walletA.balance}")
+    println("Wallet B balance: ${walletB.balance}")
+
+    val tx2 = walletA.sendFundsTo(recipient = walletB.publicKey, amountToSend = 33)
+    val secondBlock = blockChain.add(Block(genesisBlock.hash).addTransaction(tx2))
+
+    println("Wallet A balance: ${walletA.balance}")
+    println("Wallet B balance: ${walletB.balance}")
+}

detoks/src/main/java/nl/tudelft/trustchain/detoks/AddFriendFragment.kt

@@ -0,0 +1,169 @@
+package nl.tudelft.trustchain.detoks
+
+import android.annotation.SuppressLint
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+import androidx.fragment.app.Fragment
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.EditText
+import android.widget.ImageView
+import android.widget.TextView
+import android.widget.Toast
+import androidx.annotation.RequiresApi
+import nl.tudelft.trustchain.common.ui.BaseFragment
+import nl.tudelft.trustchain.common.util.QRCodeUtils
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import androidx.lifecycle.lifecycleScope
+import androidx.navigation.findNavController
+import androidx.navigation.fragment.findNavController
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import nl.tudelft.ipv8.keyvault.PrivateKey
+import nl.tudelft.ipv8.keyvault.PublicKey
+import nl.tudelft.trustchain.detoks.db.DbHelper
+import nl.tudelft.trustchain.detoks.newcoin.OfflineFriend
+
+// TODO: Rename parameter arguments, choose names that match
+// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
+private const val ARG_PARAM1 = "param1"
+private const val ARG_PARAM2 = "param2"
+
+/**
+ * A simple [Fragment] subclass.
+ * Use the [AddFriendFragment.newInstance] factory method to
+ * create an instance of this fragment.
+ */
+class AddFriendFragment : BaseFragment(R.layout.fragment_add_friend) {
+    // TODO: Rename and change types of parameters
+    private var param1: String? = null
+    private var param2: String? = null
+
+    private val qrCodeUtils by lazy {
+        QRCodeUtils(requireContext())
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        arguments?.let {
+            param1 = it.getString(ARG_PARAM1)
+            param2 = it.getString(ARG_PARAM2)
+        }
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        // Inflate the layout for this fragment
+        return inflater.inflate(R.layout.fragment_add_friend, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        val pubKey = view.findViewById<TextView>(R.id.myKey)
+        var detail = "Scan Public Key of the Recipient to add in your Addressbook"
+
+        pubKey.text = detail
+        val buttonScan = view.findViewById<Button>(R.id.button_scan_public_key)
+        buttonScan.setOnClickListener {
+            qrCodeUtils.startQRScanner(this, null, true)
+        }
+
+        val My_QR = view.findViewById<ImageView>(R.id.My_QR)
+
+
+        val buttonShow = view.findViewById<Button>(R.id.button_show)
+        buttonShow.setOnClickListener {
+            buttonScan.visibility = View.INVISIBLE
+            pubKey.text = "Scan the QR Code to add me as a friend!"
+            val myPublicKey = getIpv8().myPeer.publicKey.keyToBin()
+            val gsonObject = GsonBuilder().create()
+            val result = gsonObject.toJson(myPublicKey)
+
+            lifecycleScope.launch {
+                var bitmap = withContext(Dispatchers.Default) {
+                    // qrCodeUtils.createQR(payload.serialize().toHex())
+                    qrCodeUtils.createQR(result)
+                }
+                My_QR.visibility = View.VISIBLE
+                My_QR.setImageBitmap(bitmap)
+                buttonShow.visibility = View.INVISIBLE
+            }
+        }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        val content = qrCodeUtils.parseActivityResult(requestCode,resultCode,data)
+        Log.v("PublicKey content", content.toString())
+
+        val nameFriend = view?.findViewById<EditText>(R.id.name)
+        nameFriend?.visibility = View.VISIBLE
+
+        val buttonSave = view?.findViewById<Button>(R.id.save_friend)
+        buttonSave?.visibility = View.VISIBLE
+
+        buttonSave?.setOnClickListener{
+            val username = nameFriend?.text
+           if(nameFriend?.text == null){
+               Toast.makeText(this.context,"Enter friend's name!", Toast.LENGTH_LONG).show()
+           } else {
+               if(content != null) {
+                   val myPublicKey = getIpv8().myPeer.publicKey
+                   val wallet = Wallet.getInstance(
+                       this.requireContext(),
+                       myPublicKey,
+                       getIpv8().myPeer.key as PrivateKey
+                   )
+                   var map = object :  TypeToken<ByteArray>() {}.type
+                   val result: ByteArray = Gson().fromJson(content, map)
+                   val newRowId = wallet.addFriend(
+                       OfflineFriend(username.toString(), result)
+                   )
+                   if (newRowId != -1L) {
+                       Toast.makeText(this.context, "Added Friend!", Toast.LENGTH_LONG).show()
+                   } else {
+                       Toast.makeText(this.context, "Duplicate Entry!", Toast.LENGTH_LONG).show()
+                   }
+                   //save call to db
+
+                   Log.v("Save pub key", content.toString())
+                   Log.v("Name ", username.toString())
+                   val navController = this.findNavController()
+                   navController.navigate(R.id.offlineTransferFragment)
+               } else {
+                   Toast.makeText(this.context, "Scanning failed!", Toast.LENGTH_LONG).show()
+               }
+           }
+        }
+
+    }
+
+    companion object {
+        /**
+         * Use this factory method to create a new instance of
+         * this fragment using the provided parameters.
+         *
+         * @param param1 Parameter 1.
+         * @param param2 Parameter 2.
+         * @return A new instance of fragment AddFriendFragment.
+         */
+        // TODO: Rename and change types and number of parameters
+        @JvmStatic
+        fun newInstance(param1: String, param2: String) =
+            AddFriendFragment().apply {
+                arguments = Bundle().apply {
+                    putString(ARG_PARAM1, param1)
+                    putString(ARG_PARAM2, param2)
+                }
+            }
+    }
+}

detoks/src/main/java/nl/tudelft/trustchain/detoks/DeToksFragment.kt

@@ -1,8 +1,13 @@
 package nl.tudelft.trustchain.detoks
 
+import android.content.Intent
 import android.os.Bundle
 import android.util.Log
 import android.view.View
+import android.widget.Button
+import androidx.appcompat.app.AppCompatActivity
+import androidx.navigation.findNavController
+import androidx.navigation.fragment.NavHostFragment
 import androidx.viewpager2.widget.ViewPager2
 import kotlinx.android.synthetic.main.fragment_detoks.*
 import mu.KotlinLogging
@@ -12,7 +17,7 @@ import java.io.FileOutputStream
 
 class DeToksFragment : BaseFragment(R.layout.fragment_detoks) {
     private lateinit var torrentManager: TorrentManager
-    private val logger = KotlinLogging.logger {}
+    private val logger = KotlinLogging.logger {} // == ({})
     private var previousVideoAdapterIndex = 0
 
     private val torrentDir: String
@@ -49,7 +54,7 @@ class DeToksFragment : BaseFragment(R.layout.fragment_detoks) {
         torrentManager = TorrentManager(
             File("${requireActivity().cacheDir.absolutePath}/media"),
             File("${requireActivity().cacheDir.absolutePath}/torrent"),
-            DEFAULT_CACHING_AMOUNT
+            DEFAULT_CACHING_AMOUNT,
         )
     }
 
@@ -59,6 +64,22 @@ class DeToksFragment : BaseFragment(R.layout.fragment_detoks) {
         viewPagerVideos.adapter = VideosAdapter(torrentManager)
         viewPagerVideos.currentItem = 0
         onPageChangeCallback()
+        val buttonOffline = view.findViewById<Button>(R.id.button_offline)
+        buttonOffline.setOnClickListener {
+//            OfflineTransferFragment.newInstance("param1", "param2")
+//            val activity = view.context as (AppCompatActivity)
+            val navController = view.findNavController()
+            navController.navigate(R.id.offlineTransferFragment)
+            Log.v("Offline fragment", "hello")
+            Log.v("Offline fragment", "activated")
+        }
+        val walletButton = view.findViewById<Button>(R.id.wallet_button)
+        walletButton.setOnClickListener {
+            val navController = view.findNavController()
+            navController.navigate(R.id.walletFragment)
+            Log.v("Wallet fragment", "hello")
+            Log.v("Wallet fragment", "activated")
+        }
     }
 
     /**