From b5e3128628b5487cfb1bd80e813ab840b677ac93 Mon Sep 17 00:00:00 2001 From: Vexta Project Date: Sun, 2 Aug 2026 23:17:40 +0000 Subject: [PATCH] Initial release of Vexta Wallet for Android --- .gitignore | 10 + PRIVACY.md | 11 + README.md | 43 + SECURITY.md | 7 + app/build.gradle.kts | 63 + app/src/main/AndroidManifest.xml | 38 + .../org/vextaproject/wallet/BlockScanner.kt | 746 +++++ .../wallet/CompactFilterClient.kt | 557 ++++ .../java/org/vextaproject/wallet/GcsFilter.kt | 312 ++ .../org/vextaproject/wallet/MainActivity.kt | 719 ++++ .../wallet/VextaTransactionSender.kt | 922 ++++++ .../org/vextaproject/wallet/WalletActivity.kt | 2911 +++++++++++++++++ .../main/res/drawable-nodpi/vexta_logo.png | Bin 0 -> 124217 bytes .../res/drawable/vexta_icon_foreground.png | Bin 0 -> 126679 bytes .../res/mipmap-anydpi-v26/ic_launcher.xml | 5 + .../mipmap-anydpi-v26/ic_launcher_round.xml | 5 + app/src/main/res/mipmap-hdpi/ic_launcher.png | Bin 0 -> 10310 bytes .../res/mipmap-hdpi/ic_launcher_round.png | Bin 0 -> 10310 bytes app/src/main/res/mipmap-mdpi/ic_launcher.png | Bin 0 -> 4961 bytes .../res/mipmap-mdpi/ic_launcher_round.png | Bin 0 -> 4961 bytes app/src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 17685 bytes .../res/mipmap-xhdpi/ic_launcher_round.png | Bin 0 -> 17685 bytes .../main/res/mipmap-xxhdpi/ic_launcher.png | Bin 0 -> 37291 bytes .../res/mipmap-xxhdpi/ic_launcher_round.png | Bin 0 -> 37291 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.png | Bin 0 -> 63622 bytes .../res/mipmap-xxxhdpi/ic_launcher_round.png | Bin 0 -> 63622 bytes app/src/main/res/values/icon_colors.xml | 4 + app/src/main/res/values/styles.xml | 22 + build.gradle.kts | 3 + gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 48462 bytes gradle/wrapper/gradle-wrapper.properties | 9 + gradlew | 248 ++ gradlew.bat | 82 + settings.gradle.kts | 18 + 34 files changed, 6735 insertions(+) create mode 100644 .gitignore create mode 100644 PRIVACY.md create mode 100644 README.md create mode 100644 SECURITY.md create mode 100644 app/build.gradle.kts create mode 100644 app/src/main/AndroidManifest.xml create mode 100644 app/src/main/java/org/vextaproject/wallet/BlockScanner.kt create mode 100644 app/src/main/java/org/vextaproject/wallet/CompactFilterClient.kt create mode 100644 app/src/main/java/org/vextaproject/wallet/GcsFilter.kt create mode 100644 app/src/main/java/org/vextaproject/wallet/MainActivity.kt create mode 100644 app/src/main/java/org/vextaproject/wallet/VextaTransactionSender.kt create mode 100644 app/src/main/java/org/vextaproject/wallet/WalletActivity.kt create mode 100644 app/src/main/res/drawable-nodpi/vexta_logo.png create mode 100644 app/src/main/res/drawable/vexta_icon_foreground.png create mode 100644 app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml create mode 100644 app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png create mode 100644 app/src/main/res/values/icon_colors.xml create mode 100644 app/src/main/res/values/styles.xml create mode 100644 build.gradle.kts create mode 100644 gradle/wrapper/gradle-wrapper.jar create mode 100644 gradle/wrapper/gradle-wrapper.properties create mode 100755 gradlew create mode 100644 gradlew.bat create mode 100644 settings.gradle.kts diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..93eef40 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +.gradle/ +.kotlin/ +local.properties +**/build/ +*.iml +.idea/ +*.jks +*.keystore +keystore.properties +app/build.gradle.kts.backup-* diff --git a/PRIVACY.md b/PRIVACY.md new file mode 100644 index 0000000..e007374 --- /dev/null +++ b/PRIVACY.md @@ -0,0 +1,11 @@ +# Privacy Policy + +Vexta Wallet is a non-custodial wallet. + +Recovery phrases and private keys remain on the users device. The recovery phrase is stored locally in encrypted form using Android Keystore protection. + +The wallet does not require an account and does not intentionally collect names, email addresses, phone numbers, or recovery phrases. + +The wallet connects to Vexta network nodes and the official update endpoint. Network operators may observe standard connection information such as IP address and connection time. + +Users are responsible for securely backing up their recovery phrase. diff --git a/README.md b/README.md new file mode 100644 index 0000000..8b4a18b --- /dev/null +++ b/README.md @@ -0,0 +1,43 @@ +# Vexta Wallet for Android + +Official open-source Android wallet for the Vexta (VTX) blockchain. + +## Features + +- Create and restore a 12-word recovery phrase +- Multiple deterministic receiving addresses +- Native SegWit Vexta addresses +- Verified SPV block headers +- BIP158 compact-filter scanning +- Local transaction history +- Send and receive VTX +- QR-code scanning +- Encrypted recovery phrase storage +- Signed in-app updates with SHA256 verification + +## Requirements + +- Android 8.0 or newer +- Android SDK 36 +- Java 17 + +## Build + +Run: ./gradlew assembleDebug + +Debug APK: app/build/outputs/apk/debug/app-debug.apk + +## Official release signature + +Certificate SHA256: +12b3de2573af4a23fca222ee6609e60c6f685a624f510151128087a8c4d0020e + +## Official links + +- Website: https://vextaproject.org +- Explorer: https://vextaproject.org/explorer/ +- Discord: https://discord.gg/zzpm7ghN3e + +## Disclaimer + +Keep a secure offline backup of the recovery phrase. This software is provided without warranty. diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..ecaf093 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,7 @@ +# Security Policy + +Report security vulnerabilities privately through official Vexta Project contact channels. + +Never send recovery phrases, private keys, signing keystores, signing passwords, or screenshots containing recovery phrases. + +The Vexta Project will never ask for a recovery phrase or private key. diff --git a/app/build.gradle.kts b/app/build.gradle.kts new file mode 100644 index 0000000..eb428c6 --- /dev/null +++ b/app/build.gradle.kts @@ -0,0 +1,63 @@ +import java.util.Properties +import java.io.FileInputStream + +plugins { + id("com.android.application") +} + +val keystorePropertiesFile = rootProject.file("keystore.properties") +val keystoreProperties = Properties() + +if (keystorePropertiesFile.exists()) { + FileInputStream(keystorePropertiesFile).use { + keystoreProperties.load(it) + } +} + +android { + namespace = "org.vextaproject.wallet" + compileSdk = 36 + + defaultConfig { + applicationId = "org.vextaproject.wallet" + minSdk = 26 + targetSdk = 36 + versionCode = 27 + versionName = "0.4.5" + } + + signingConfigs { + if (keystorePropertiesFile.exists()) { + create("release") { + storeFile = file( + keystoreProperties.getProperty("storeFile") + ) + storePassword = + keystoreProperties.getProperty("storePassword") + keyAlias = + keystoreProperties.getProperty("keyAlias") + keyPassword = + keystoreProperties.getProperty("keyPassword") + } + } + } + + buildTypes { + getByName("release") { + if (keystorePropertiesFile.exists()) { + signingConfig = signingConfigs.getByName("release") + } + + isMinifyEnabled = false + isShrinkResources = false + } + } +} + +dependencies { + implementation("org.bitcoinj:bitcoinj-core:0.16.3") + implementation("com.google.zxing:core:3.5.3") + implementation( + "com.google.android.gms:play-services-code-scanner:16.1.0" + ) +} diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..bd5ba98 --- /dev/null +++ b/app/src/main/AndroidManifest.xml @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/java/org/vextaproject/wallet/BlockScanner.kt b/app/src/main/java/org/vextaproject/wallet/BlockScanner.kt new file mode 100644 index 0000000..3d815c1 --- /dev/null +++ b/app/src/main/java/org/vextaproject/wallet/BlockScanner.kt @@ -0,0 +1,746 @@ +package org.vextaproject.wallet + +import android.content.Context +import java.io.ByteArrayOutputStream +import java.io.DataInputStream +import java.io.File +import java.io.OutputStream +import java.net.InetAddress +import java.net.InetSocketAddress +import java.net.Socket +import java.nio.ByteBuffer +import java.nio.ByteOrder +import java.security.MessageDigest +import kotlin.random.Random + +object BlockScanner { + + private val magic = byteArrayOf(0x56, 0x54, 0x58, 0x31) + private const val port = 19333 + private const val protocolVersion = 70018 + private const val msgWitnessBlock = 0x40000002 + + private const val genesisHash = + "0000027626959d894ae1c8a6f9050cdcbdf58eb0037ab06345cb5502955370f1" + + data class SpendableUtxo( + val txid: String, + val outputIndex: Long, + val value: Long, + val height: Int, + val addressIndex: Int + ) + + data class WalletTransaction( + val txid: String, + val height: Int, + val netSatoshis: Long + ) + + data class Result( + val downloadedBlocks: Int, + val receivedTransactions: Int, + val spentTransactions: Int, + val utxoCount: Int, + val balanceSatoshis: Long, + val utxos: List, + val transactions: List + ) + + private data class Utxo( + val txidWire: ByteArray, + val outputIndex: Long, + val value: Long, + val height: Int, + val addressIndex: Int + ) + + private data class ParsedTransaction( + val txidWire: ByteArray, + val inputs: List, + val outputs: List + ) + + private data class OutPoint( + val txidWire: ByteArray, + val index: Long + ) + + private data class TransactionOutput( + val index: Int, + val value: Long, + val script: ByteArray + ) + + fun scan( + context: Context, + peer: String, + matchingHeights: List, + walletScript: ByteArray, + addressIndex: Int, + progress: (Int, Int) -> Unit + ): Result { + if (matchingHeights.isEmpty()) { + return Result( + downloadedBlocks = 0, + receivedTransactions = 0, + spentTransactions = 0, + utxoCount = 0, + balanceSatoshis = 0, + utxos = emptyList(), + transactions = emptyList() + ) + } + + val hashes = loadHeaderHashes(context) + val requested = matchingHeights + .distinct() + .sorted() + .associateWith { height -> + hashes.getOrNull(height) + ?: throw IllegalStateException( + "Missing verified header at height $height" + ) + } + + val heightByHash = requested.entries.associate { + it.value.toHex() to it.key + } + + val utxos = linkedMapOf() + var receivedTransactions = 0 + var spentTransactions = 0 + var downloadedBlocks = 0 + val walletTransactions = mutableListOf() + + Socket().use { socket -> + socket.soTimeout = 30000 + socket.connect(InetSocketAddress(peer, port), 5000) + + val input = DataInputStream(socket.getInputStream()) + val output = socket.getOutputStream() + + sendMessage(output, "version", createVersionPayload(peer)) + + var gotVersion = false + var gotVerack = false + var requestedBlocks = false + + repeat(100000) { + val (command, payload) = readMessage(input) + + when (command) { + "version" -> { + gotVersion = true + sendMessage(output, "verack", byteArrayOf()) + } + + "verack" -> gotVerack = true + + "ping" -> sendMessage(output, "pong", payload) + + "block" -> { + if (payload.size < 81) { + throw IllegalStateException("Short block payload") + } + + val blockHeader = payload.copyOfRange(0, 80) + val blockHashWire = doubleSha256(blockHeader) + val height = heightByHash[blockHashWire.toHex()] + ?: throw IllegalStateException( + "Received an unrequested block" + ) + + parseBlock(payload, walletScript).forEach { transaction -> + var spentWalletValue = 0L + + transaction.inputs.forEach { inputPoint -> + val key = outPointKey( + inputPoint.txidWire, + inputPoint.index + ) + + val spentOutput = utxos.remove(key) + + if (spentOutput != null) { + spentWalletValue += spentOutput.value + } + } + + if (spentWalletValue > 0L) { + spentTransactions++ + } + + var receivedWalletValue = 0L + + transaction.outputs.forEach { transactionOutput -> + if ( + transactionOutput.script.contentEquals( + walletScript + ) + ) { + val key = outPointKey( + transaction.txidWire, + transactionOutput.index.toLong() + ) + + utxos[key] = Utxo( + txidWire = transaction.txidWire, + outputIndex = + transactionOutput.index.toLong(), + value = transactionOutput.value, + height = height, + addressIndex = addressIndex + ) + + receivedWalletValue += + transactionOutput.value + } + } + + if (receivedWalletValue > 0L) { + receivedTransactions++ + } + + val netSatoshis = + receivedWalletValue - spentWalletValue + + if (netSatoshis != 0L) { + walletTransactions.add( + WalletTransaction( + txid = transaction.txidWire + .reversedArray() + .toHex(), + height = height, + netSatoshis = netSatoshis + ) + ) + } + } + + downloadedBlocks++ + progress(downloadedBlocks, requested.size) + + if (downloadedBlocks == requested.size) { + val spendable = utxos.values + .sortedWith( + compareBy { it.height } + .thenBy { it.txidWire.toHex() } + .thenBy { it.outputIndex } + ) + .map { utxo -> + SpendableUtxo( + txid = utxo.txidWire + .reversedArray() + .toHex(), + outputIndex = utxo.outputIndex, + value = utxo.value, + height = utxo.height, + addressIndex = utxo.addressIndex + ) + } + + return Result( + downloadedBlocks = downloadedBlocks, + receivedTransactions = receivedTransactions, + spentTransactions = spentTransactions, + utxoCount = spendable.size, + balanceSatoshis = spendable.sumOf { + it.value + }, + utxos = spendable, + transactions = walletTransactions + .sortedWith( + compareByDescending { + it.height + }.thenByDescending { + it.txid + } + ) + ) + } + } + + "notfound" -> { + throw IllegalStateException( + "Peer could not provide a requested block" + ) + } + } + + if ( + gotVersion && + gotVerack && + !requestedBlocks + ) { + sendMessage( + output, + "getdata", + createGetDataPayload(requested.values.toList()) + ) + + requestedBlocks = true + } + } + + throw IllegalStateException("Block download did not complete") + } + } + + private fun parseBlock( + payload: ByteArray, + walletScript: ByteArray + ): List { + val cursor = Cursor(payload) + cursor.skip(80) + + val transactionCount = cursor.readCompactSize() + + if (transactionCount > 1_000_000) { + throw IllegalStateException("Invalid transaction count") + } + + val transactions = ArrayList( + transactionCount.toInt() + ) + + repeat(transactionCount.toInt()) { + transactions.add(parseTransaction(cursor, walletScript)) + } + + if (!cursor.isFinished()) { + throw IllegalStateException("Unexpected bytes after block") + } + + return transactions + } + + private fun parseTransaction( + cursor: Cursor, + walletScript: ByteArray + ): ParsedTransaction { + val stripped = ByteArrayOutputStream() + + val version = cursor.readBytes(4) + stripped.write(version) + + var hasWitness = false + + if ( + cursor.remaining() >= 2 && + cursor.peekByte(0) == 0 && + cursor.peekByte(1) != 0 + ) { + cursor.skip(2) + hasWitness = true + } + + val inputCount = cursor.readCompactSize() + writeCompactSize(stripped, inputCount) + + val inputs = ArrayList(inputCount.toInt()) + + repeat(inputCount.toInt()) { + val previousTxid = cursor.readBytes(32) + val previousIndexBytes = cursor.readBytes(4) + val previousIndex = ByteBuffer + .wrap(previousIndexBytes) + .order(ByteOrder.LITTLE_ENDIAN) + .int + .toLong() and 0xffffffffL + + val scriptLength = cursor.readCompactSize() + val script = cursor.readBytes(scriptLength.toInt()) + val sequence = cursor.readBytes(4) + + stripped.write(previousTxid) + stripped.write(previousIndexBytes) + writeCompactSize(stripped, scriptLength) + stripped.write(script) + stripped.write(sequence) + + inputs.add( + OutPoint( + txidWire = previousTxid, + index = previousIndex + ) + ) + } + + val outputCount = cursor.readCompactSize() + writeCompactSize(stripped, outputCount) + + val outputs = ArrayList(outputCount.toInt()) + + repeat(outputCount.toInt()) { outputIndex -> + val valueBytes = cursor.readBytes(8) + val value = ByteBuffer + .wrap(valueBytes) + .order(ByteOrder.LITTLE_ENDIAN) + .long + + if (value < 0) { + throw IllegalStateException("Negative transaction output") + } + + val scriptLength = cursor.readCompactSize() + val script = cursor.readBytes(scriptLength.toInt()) + + stripped.write(valueBytes) + writeCompactSize(stripped, scriptLength) + stripped.write(script) + + if (script.contentEquals(walletScript)) { + outputs.add( + TransactionOutput( + index = outputIndex, + value = value, + script = script + ) + ) + } + } + + if (hasWitness) { + repeat(inputCount.toInt()) { + val itemCount = cursor.readCompactSize() + + repeat(itemCount.toInt()) { + val itemLength = cursor.readCompactSize() + cursor.skip(itemLength.toInt()) + } + } + } + + val lockTime = cursor.readBytes(4) + stripped.write(lockTime) + + return ParsedTransaction( + txidWire = doubleSha256(stripped.toByteArray()), + inputs = inputs, + outputs = outputs + ) + } + + private fun createGetDataPayload( + blockHashesWire: List + ): ByteArray { + val output = ByteArrayOutputStream() + + writeCompactSize(output, blockHashesWire.size.toLong()) + + blockHashesWire.forEach { hash -> + writeInt32LE(output, msgWitnessBlock) + output.write(hash) + } + + return output.toByteArray() + } + + private fun loadHeaderHashes(context: Context): List { + val hashes = mutableListOf( + hashHexToWireBytes(genesisHash) + ) + + val file = File(context.filesDir, "vexta-headers.dat") + + if (!file.exists()) { + return hashes + } + + val data = file.readBytes() + + if (data.size % 80 != 0) { + throw IllegalStateException( + "Corrupt local block-header database" + ) + } + + var offset = 0 + + while (offset < data.size) { + hashes.add( + doubleSha256( + data.copyOfRange(offset, offset + 80) + ) + ) + + offset += 80 + } + + return hashes + } + + private fun outPointKey( + txidWire: ByteArray, + index: Long + ): String = "${txidWire.toHex()}:$index" + + private fun createVersionPayload(peerHost: String): ByteArray { + val output = ByteArrayOutputStream() + + writeInt32LE(output, protocolVersion) + writeInt64LE(output, 0) + writeInt64LE(output, System.currentTimeMillis() / 1000) + + writeNetworkAddress(output, peerHost, port) + writeNetworkAddress(output, "0.0.0.0", 0) + + writeInt64LE(output, Random.nextLong()) + writeVarString(output, "/VextaAndroidWallet:0.4.3/") + writeInt32LE(output, 0) + output.write(0) + + return output.toByteArray() + } + + private fun readMessage( + input: DataInputStream + ): Pair { + val header = ByteArray(24) + input.readFully(header) + + if (!header.copyOfRange(0, 4).contentEquals(magic)) { + throw IllegalStateException("Invalid Vexta network magic") + } + + val command = header.copyOfRange(4, 16) + .takeWhile { it.toInt() != 0 } + .toByteArray() + .toString(Charsets.US_ASCII) + + val payloadLength = ByteBuffer + .wrap(header, 16, 4) + .order(ByteOrder.LITTLE_ENDIAN) + .int + + if (payloadLength < 0 || payloadLength > 32_000_000) { + throw IllegalStateException("Invalid P2P payload length") + } + + val expectedChecksum = header.copyOfRange(20, 24) + val payload = ByteArray(payloadLength) + input.readFully(payload) + + val actualChecksum = doubleSha256(payload).copyOfRange(0, 4) + + if (!expectedChecksum.contentEquals(actualChecksum)) { + throw IllegalStateException("Invalid P2P checksum") + } + + return command to payload + } + + private fun sendMessage( + output: OutputStream, + command: String, + payload: ByteArray + ) { + val message = ByteArrayOutputStream() + message.write(magic) + + val commandBytes = ByteArray(12) + command.toByteArray(Charsets.US_ASCII).copyInto( + commandBytes, + endIndex = minOf(command.length, 12) + ) + + message.write(commandBytes) + writeInt32LE(message, payload.size) + message.write(doubleSha256(payload).copyOfRange(0, 4)) + message.write(payload) + + output.write(message.toByteArray()) + output.flush() + } + + private fun writeNetworkAddress( + output: ByteArrayOutputStream, + host: String, + port: Int + ) { + writeInt64LE(output, 0) + + val address = InetAddress.getByName(host).address + val ipv6 = ByteArray(16) + + if (address.size == 4) { + ipv6[10] = 0xff.toByte() + ipv6[11] = 0xff.toByte() + address.copyInto(ipv6, 12) + } else { + address.copyInto(ipv6) + } + + output.write(ipv6) + output.write((port shr 8) and 0xff) + output.write(port and 0xff) + } + + private fun writeVarString( + output: ByteArrayOutputStream, + value: String + ) { + val bytes = value.toByteArray(Charsets.UTF_8) + writeCompactSize(output, bytes.size.toLong()) + output.write(bytes) + } + + private fun writeCompactSize( + output: ByteArrayOutputStream, + value: Long + ) { + when { + value < 253 -> output.write(value.toInt()) + + value <= 0xffff -> { + output.write(253) + output.write((value and 0xff).toInt()) + output.write(((value shr 8) and 0xff).toInt()) + } + + value <= 0xffffffffL -> { + output.write(254) + + repeat(4) { index -> + output.write( + ((value shr (8 * index)) and 0xff).toInt() + ) + } + } + + else -> { + output.write(255) + + repeat(8) { index -> + output.write( + ((value shr (8 * index)) and 0xff).toInt() + ) + } + } + } + } + + private fun hashHexToWireBytes(hash: String): ByteArray = + hash.chunked(2) + .map { it.toInt(16).toByte() } + .toByteArray() + .reversedArray() + + private fun ByteArray.toHex(): String = + joinToString("") { + "%02x".format(it.toInt() and 0xff) + } + + private fun writeInt32LE( + output: ByteArrayOutputStream, + value: Int + ) { + output.write( + ByteBuffer.allocate(4) + .order(ByteOrder.LITTLE_ENDIAN) + .putInt(value) + .array() + ) + } + + private fun writeInt64LE( + output: ByteArrayOutputStream, + value: Long + ) { + output.write( + ByteBuffer.allocate(8) + .order(ByteOrder.LITTLE_ENDIAN) + .putLong(value) + .array() + ) + } + + private fun doubleSha256(data: ByteArray): ByteArray { + val digest = MessageDigest.getInstance("SHA-256") + return digest.digest(digest.digest(data)) + } + + private class Cursor( + private val data: ByteArray + ) { + private var offset = 0 + + fun remaining(): Int = data.size - offset + + fun isFinished(): Boolean = offset == data.size + + fun peekByte(relativeOffset: Int): Int { + require(offset + relativeOffset < data.size) { + "Transaction data is truncated" + } + + return data[offset + relativeOffset].toInt() and 0xff + } + + fun readBytes(length: Int): ByteArray { + require(length >= 0 && offset + length <= data.size) { + "Transaction data is truncated" + } + + val result = data.copyOfRange(offset, offset + length) + offset += length + return result + } + + fun skip(length: Int) { + require(length >= 0 && offset + length <= data.size) { + "Transaction data is truncated" + } + + offset += length + } + + fun readCompactSize(): Long { + val first = readBytes(1)[0].toInt() and 0xff + + return when (first) { + in 0..252 -> first.toLong() + + 253 -> { + val bytes = readBytes(2) + + (bytes[0].toLong() and 0xff) or + ((bytes[1].toLong() and 0xff) shl 8) + } + + 254 -> { + val bytes = readBytes(4) + var value = 0L + + repeat(4) { index -> + value = value or ( + (bytes[index].toLong() and 0xff) shl + (8 * index) + ) + } + + value + } + + else -> { + val bytes = readBytes(8) + var value = 0L + + repeat(8) { index -> + value = value or ( + (bytes[index].toLong() and 0xff) shl + (8 * index) + ) + } + + require(value >= 0) { + "CompactSize is too large" + } + + value + } + } + } + } +} diff --git a/app/src/main/java/org/vextaproject/wallet/CompactFilterClient.kt b/app/src/main/java/org/vextaproject/wallet/CompactFilterClient.kt new file mode 100644 index 0000000..dfa0143 --- /dev/null +++ b/app/src/main/java/org/vextaproject/wallet/CompactFilterClient.kt @@ -0,0 +1,557 @@ +package org.vextaproject.wallet + +import android.content.Context +import java.io.ByteArrayOutputStream +import java.io.DataInputStream +import java.io.File +import java.io.OutputStream +import java.net.InetAddress +import java.net.InetSocketAddress +import java.net.Socket +import java.nio.ByteBuffer +import java.nio.ByteOrder +import java.security.MessageDigest +import kotlin.random.Random + +object CompactFilterClient { + + private val magic = byteArrayOf(0x56, 0x54, 0x58, 0x31) + private const val port = 19333 + private const val protocolVersion = 70018 + private const val compactFiltersService = 1L shl 6 + private const val maxFiltersPerRequest = 1000 + + private const val genesisHash = + "0000027626959d894ae1c8a6f9050cdcbdf58eb0037ab06345cb5502955370f1" + + data class AvailabilityResult( + val peer: String, + val servicesCompactFilters: Boolean, + val filterHashesReceived: Int + ) + + data class ScanResult( + val peer: String, + val scannedFilters: Int, + val matchingHeights: List, + val localHeaderHeight: Int + ) + + fun check(peer: String): AvailabilityResult { + Socket().use { socket -> + socket.soTimeout = 15000 + socket.connect(InetSocketAddress(peer, port), 5000) + + val input = DataInputStream(socket.getInputStream()) + val output = socket.getOutputStream() + + sendMessage(output, "version", createVersionPayload(peer)) + + var compactFiltersAvailable = false + var gotVersion = false + var gotVerack = false + var requested = false + + repeat(100) { + val (command, payload) = readMessage(input) + + when (command) { + "version" -> { + val services = parseServices(payload) + compactFiltersAvailable = + (services and compactFiltersService) != 0L + + gotVersion = true + sendMessage(output, "verack", byteArrayOf()) + } + + "verack" -> gotVerack = true + "ping" -> sendMessage(output, "pong", payload) + + "cfheaders" -> { + if (payload.size < 66) { + throw IllegalStateException( + "short cfheaders payload" + ) + } + + val buffer = ByteBuffer.wrap(payload) + .order(ByteOrder.LITTLE_ENDIAN) + + val filterType = buffer.get().toInt() and 0xff + + if (filterType != 0) { + throw IllegalStateException( + "unexpected filter type $filterType" + ) + } + + buffer.position(buffer.position() + 64) + val count = readCompactSize(buffer) + + return AvailabilityResult( + peer, + compactFiltersAvailable, + count + ) + } + } + + if ( + gotVersion && + gotVerack && + compactFiltersAvailable && + !requested + ) { + sendMessage( + output, + "getcfheaders", + createGetCfHeadersPayload() + ) + requested = true + } + + if ( + gotVersion && + gotVerack && + !compactFiltersAvailable + ) { + return AvailabilityResult(peer, false, 0) + } + } + + throw IllegalStateException("compact filter response timeout") + } + } + + fun scan( + context: Context, + peer: String, + scriptPubKey: ByteArray, + progress: (Int, Int) -> Unit + ): ScanResult { + val headerHashes = loadHeaderHashes(context) + val localHeight = headerHashes.lastIndex + + if (localHeight < 1) { + throw IllegalStateException( + "No locally verified block headers available" + ) + } + + Socket().use { socket -> + socket.soTimeout = 30000 + socket.connect(InetSocketAddress(peer, port), 5000) + + val input = DataInputStream(socket.getInputStream()) + val output = socket.getOutputStream() + + sendMessage(output, "version", createVersionPayload(peer)) + + var compactFiltersAvailable = false + var gotVersion = false + var gotVerack = false + var nextHeight = 1 + var requestedEndHeight = 0 + var receivedInBatch = 0 + var totalScanned = 0 + val matches = mutableListOf() + + repeat(100000) { + val (command, payload) = readMessage(input) + + when (command) { + "version" -> { + val services = parseServices(payload) + compactFiltersAvailable = + (services and compactFiltersService) != 0L + + gotVersion = true + sendMessage(output, "verack", byteArrayOf()) + } + + "verack" -> gotVerack = true + "ping" -> sendMessage(output, "pong", payload) + + "cfilter" -> { + val filter = parseCFilter(payload) + val expectedHeight = nextHeight + receivedInBatch + val expectedHash = headerHashes[expectedHeight] + + if (!filter.blockHashWire.contentEquals(expectedHash)) { + throw IllegalStateException( + "Unexpected filter block hash at height " + + expectedHeight + ) + } + + if ( + GcsFilter.matches( + filter.encodedFilter, + filter.blockHashWire, + scriptPubKey + ) + ) { + matches.add(expectedHeight) + } + + receivedInBatch++ + totalScanned++ + progress(totalScanned, localHeight) + + if ( + nextHeight + receivedInBatch - 1 == + requestedEndHeight + ) { + nextHeight = requestedEndHeight + 1 + receivedInBatch = 0 + + if (nextHeight > localHeight) { + return ScanResult( + peer, + totalScanned, + matches, + localHeight + ) + } + + requestedEndHeight = minOf( + nextHeight + maxFiltersPerRequest - 1, + localHeight + ) + + sendMessage( + output, + "getcfilters", + createGetCFiltersPayload( + nextHeight, + headerHashes[requestedEndHeight] + ) + ) + } + } + } + + if ( + gotVersion && + gotVerack && + compactFiltersAvailable && + requestedEndHeight == 0 + ) { + requestedEndHeight = minOf( + maxFiltersPerRequest, + localHeight + ) + + sendMessage( + output, + "getcfilters", + createGetCFiltersPayload( + nextHeight, + headerHashes[requestedEndHeight] + ) + ) + } + + if ( + gotVersion && + gotVerack && + !compactFiltersAvailable + ) { + throw IllegalStateException( + "Peer does not provide compact filters" + ) + } + } + + throw IllegalStateException("filter scan did not complete") + } + } + + private data class ParsedCFilter( + val blockHashWire: ByteArray, + val encodedFilter: ByteArray + ) + + private fun parseCFilter(payload: ByteArray): ParsedCFilter { + if (payload.size < 34) { + throw IllegalStateException("short cfilter payload") + } + + val filterType = payload[0].toInt() and 0xff + + if (filterType != 0) { + throw IllegalStateException( + "unexpected filter type $filterType" + ) + } + + val blockHashWire = payload.copyOfRange(1, 33) + val buffer = ByteBuffer.wrap(payload) + .order(ByteOrder.LITTLE_ENDIAN) + + buffer.position(33) + val filterLength = readCompactSize(buffer) + + if (filterLength < 0 || filterLength > buffer.remaining()) { + throw IllegalStateException("invalid cfilter length") + } + + val encodedFilter = ByteArray(filterLength) + buffer.get(encodedFilter) + + return ParsedCFilter(blockHashWire, encodedFilter) + } + + private fun loadHeaderHashes(context: Context): List { + val result = mutableListOf( + hashHexToWireBytes(genesisHash) + ) + + val file = File(context.filesDir, "vexta-headers.dat") + + if (!file.exists()) { + return result + } + + val data = file.readBytes() + + if (data.size % 80 != 0) { + throw IllegalStateException("Corrupt local header database") + } + + var offset = 0 + + while (offset < data.size) { + val header = data.copyOfRange(offset, offset + 80) + result.add(doubleSha256(header)) + offset += 80 + } + + return result + } + + private fun createGetCFiltersPayload( + startHeight: Int, + stopHashWire: ByteArray + ): ByteArray { + val output = ByteArrayOutputStream() + + output.write(0) + writeInt32LE(output, startHeight) + output.write(stopHashWire) + + return output.toByteArray() + } + + private fun createGetCfHeadersPayload(): ByteArray { + val output = ByteArrayOutputStream() + + output.write(0) + writeInt32LE(output, 0) + output.write(hashHexToWireBytes(genesisHash)) + + return output.toByteArray() + } + + private fun parseServices(payload: ByteArray): Long { + if (payload.size < 12) { + throw IllegalStateException("short version payload") + } + + return ByteBuffer.wrap(payload) + .order(ByteOrder.LITTLE_ENDIAN) + .apply { int } + .long + } + + private fun createVersionPayload(peerHost: String): ByteArray { + val output = ByteArrayOutputStream() + + writeInt32LE(output, protocolVersion) + writeInt64LE(output, 0) + writeInt64LE(output, System.currentTimeMillis() / 1000) + + writeNetworkAddress(output, peerHost, port) + writeNetworkAddress(output, "0.0.0.0", 0) + + writeInt64LE(output, Random.nextLong()) + writeVarString(output, "/VextaAndroidWallet:0.1.0/") + writeInt32LE(output, 0) + output.write(0) + + return output.toByteArray() + } + + private fun readMessage( + input: DataInputStream + ): Pair { + val header = ByteArray(24) + input.readFully(header) + + if (!header.copyOfRange(0, 4).contentEquals(magic)) { + throw IllegalStateException("invalid Vexta network magic") + } + + val command = header.copyOfRange(4, 16) + .takeWhile { it.toInt() != 0 } + .toByteArray() + .toString(Charsets.US_ASCII) + + val payloadLength = ByteBuffer.wrap(header, 16, 4) + .order(ByteOrder.LITTLE_ENDIAN) + .int + + if (payloadLength < 0 || payloadLength > 4_000_000) { + throw IllegalStateException("invalid payload length") + } + + val expectedChecksum = header.copyOfRange(20, 24) + val payload = ByteArray(payloadLength) + input.readFully(payload) + + val actualChecksum = doubleSha256(payload).copyOfRange(0, 4) + + if (!expectedChecksum.contentEquals(actualChecksum)) { + throw IllegalStateException("invalid message checksum") + } + + return command to payload + } + + private fun sendMessage( + output: OutputStream, + command: String, + payload: ByteArray + ) { + val message = ByteArrayOutputStream() + + message.write(magic) + + val commandBytes = ByteArray(12) + command.toByteArray(Charsets.US_ASCII).copyInto( + commandBytes, + endIndex = minOf(command.length, 12) + ) + + message.write(commandBytes) + writeInt32LE(message, payload.size) + message.write(doubleSha256(payload).copyOfRange(0, 4)) + message.write(payload) + + output.write(message.toByteArray()) + output.flush() + } + + private fun writeNetworkAddress( + output: ByteArrayOutputStream, + host: String, + port: Int + ) { + writeInt64LE(output, 0) + + val address = InetAddress.getByName(host).address + val ipv6 = ByteArray(16) + + if (address.size == 4) { + ipv6[10] = 0xff.toByte() + ipv6[11] = 0xff.toByte() + address.copyInto(ipv6, 12) + } else { + address.copyInto(ipv6) + } + + output.write(ipv6) + output.write((port shr 8) and 0xff) + output.write(port and 0xff) + } + + private fun writeVarString( + output: ByteArrayOutputStream, + value: String + ) { + val bytes = value.toByteArray(Charsets.UTF_8) + writeCompactSize(output, bytes.size) + output.write(bytes) + } + + private fun writeCompactSize( + output: ByteArrayOutputStream, + value: Int + ) { + when { + value < 253 -> output.write(value) + + value <= 0xffff -> { + output.write(253) + output.write(value and 0xff) + output.write((value shr 8) and 0xff) + } + + else -> { + output.write(254) + writeInt32LE(output, value) + } + } + } + + private fun readCompactSize(buffer: ByteBuffer): Int { + if (!buffer.hasRemaining()) { + throw IllegalStateException("missing CompactSize") + } + + return when (val first = buffer.get().toInt() and 0xff) { + 253 -> buffer.short.toInt() and 0xffff + 254 -> buffer.int + + 255 -> { + val value = buffer.long + + if (value < 0 || value > Int.MAX_VALUE) { + throw IllegalStateException( + "CompactSize too large" + ) + } + + value.toInt() + } + + else -> first + } + } + + private fun hashHexToWireBytes(hash: String): ByteArray = + hash.chunked(2) + .map { it.toInt(16).toByte() } + .toByteArray() + .reversedArray() + + private fun writeInt32LE( + output: ByteArrayOutputStream, + value: Int + ) { + output.write( + ByteBuffer.allocate(4) + .order(ByteOrder.LITTLE_ENDIAN) + .putInt(value) + .array() + ) + } + + private fun writeInt64LE( + output: ByteArrayOutputStream, + value: Long + ) { + output.write( + ByteBuffer.allocate(8) + .order(ByteOrder.LITTLE_ENDIAN) + .putLong(value) + .array() + ) + } + + private fun doubleSha256(data: ByteArray): ByteArray { + val digest = MessageDigest.getInstance("SHA-256") + return digest.digest(digest.digest(data)) + } +} diff --git a/app/src/main/java/org/vextaproject/wallet/GcsFilter.kt b/app/src/main/java/org/vextaproject/wallet/GcsFilter.kt new file mode 100644 index 0000000..da6f4ae --- /dev/null +++ b/app/src/main/java/org/vextaproject/wallet/GcsFilter.kt @@ -0,0 +1,312 @@ +package org.vextaproject.wallet + +import java.math.BigInteger +import java.nio.ByteBuffer +import java.nio.ByteOrder + +object GcsFilter { + + private const val P = 19 + private const val M = 784931L + + fun matches( + encodedFilter: ByteArray, + blockHashWire: ByteArray, + element: ByteArray + ): Boolean { + require(blockHashWire.size == 32) { + "Block hash must contain 32 bytes" + } + + val compactSize = readCompactSize(encodedFilter, 0) + val count = compactSize.first + + if (count == 0L) { + return false + } + + if (count > Int.MAX_VALUE) { + throw IllegalArgumentException("Filter contains too many elements") + } + + val key0 = readInt64LE(blockHashWire, 0) + val key1 = readInt64LE(blockHashWire, 8) + + val range = BigInteger.valueOf(count) + .multiply(BigInteger.valueOf(M)) + + val sipHash = sipHash24(key0, key1, element) + val query = mapIntoRange(sipHash, range) + + val reader = BitReader( + encodedFilter, + compactSize.second + ) + + var value = BigInteger.ZERO + + repeat(count.toInt()) { + val quotient = reader.readUnary() + val remainder = reader.readBits(P) + + val delta = BigInteger.valueOf(quotient) + .shiftLeft(P) + .add(BigInteger.valueOf(remainder)) + + value = value.add(delta) + + val comparison = value.compareTo(query) + + if (comparison == 0) { + return true + } + + if (comparison > 0) { + return false + } + } + + return false + } + + private fun mapIntoRange( + hash: Long, + range: BigInteger + ): BigInteger { + val unsignedHash = if (hash >= 0) { + BigInteger.valueOf(hash) + } else { + BigInteger.valueOf(hash and Long.MAX_VALUE) + .setBit(63) + } + + return unsignedHash + .multiply(range) + .shiftRight(64) + } + + private fun readCompactSize( + data: ByteArray, + offset: Int + ): Pair { + if (offset >= data.size) { + throw IllegalArgumentException("Missing CompactSize") + } + + val first = data[offset].toInt() and 0xff + + return when (first) { + in 0..252 -> first.toLong() to offset + 1 + + 253 -> { + require(offset + 3 <= data.size) { + "Truncated CompactSize" + } + + val value = + (data[offset + 1].toLong() and 0xff) or + ((data[offset + 2].toLong() and 0xff) shl 8) + + value to offset + 3 + } + + 254 -> { + require(offset + 5 <= data.size) { + "Truncated CompactSize" + } + + var value = 0L + + for (index in 0 until 4) { + value = value or ( + (data[offset + 1 + index].toLong() and 0xff) shl + (8 * index) + ) + } + + value to offset + 5 + } + + else -> { + require(offset + 9 <= data.size) { + "Truncated CompactSize" + } + + var value = 0L + + for (index in 0 until 8) { + value = value or ( + (data[offset + 1 + index].toLong() and 0xff) shl + (8 * index) + ) + } + + require(value >= 0) { + "CompactSize exceeds signed Long range" + } + + value to offset + 9 + } + } + } + + private fun readInt64LE( + data: ByteArray, + offset: Int + ): Long { + return ByteBuffer.wrap(data, offset, 8) + .order(ByteOrder.LITTLE_ENDIAN) + .long + } + + private fun sipHash24( + key0: Long, + key1: Long, + data: ByteArray + ): Long { + var v0 = key0 xor 0x736f6d6570736575L + var v1 = key1 xor 0x646f72616e646f6dL + var v2 = key0 xor 0x6c7967656e657261L + var v3 = key1 xor 0x7465646279746573L + + var offset = 0 + + while (offset + 8 <= data.size) { + val message = readInt64LE(data, offset) + v3 = v3 xor message + + repeat(2) { + val result = sipRound(v0, v1, v2, v3) + v0 = result[0] + v1 = result[1] + v2 = result[2] + v3 = result[3] + } + + v0 = v0 xor message + offset += 8 + } + + var finalBlock = data.size.toLong() shl 56 + var shift = 0 + + while (offset < data.size) { + finalBlock = finalBlock or ( + (data[offset].toLong() and 0xff) shl shift + ) + + shift += 8 + offset++ + } + + v3 = v3 xor finalBlock + + repeat(2) { + val result = sipRound(v0, v1, v2, v3) + v0 = result[0] + v1 = result[1] + v2 = result[2] + v3 = result[3] + } + + v0 = v0 xor finalBlock + v2 = v2 xor 0xffL + + repeat(4) { + val result = sipRound(v0, v1, v2, v3) + v0 = result[0] + v1 = result[1] + v2 = result[2] + v3 = result[3] + } + + return v0 xor v1 xor v2 xor v3 + } + + private fun sipRound( + input0: Long, + input1: Long, + input2: Long, + input3: Long + ): LongArray { + var v0 = input0 + var v1 = input1 + var v2 = input2 + var v3 = input3 + + v0 += v1 + v1 = java.lang.Long.rotateLeft(v1, 13) + v1 = v1 xor v0 + v0 = java.lang.Long.rotateLeft(v0, 32) + + v2 += v3 + v3 = java.lang.Long.rotateLeft(v3, 16) + v3 = v3 xor v2 + + v0 += v3 + v3 = java.lang.Long.rotateLeft(v3, 21) + v3 = v3 xor v0 + + v2 += v1 + v1 = java.lang.Long.rotateLeft(v1, 17) + v1 = v1 xor v2 + v2 = java.lang.Long.rotateLeft(v2, 32) + + return longArrayOf(v0, v1, v2, v3) + } + + private class BitReader( + private val data: ByteArray, + startOffset: Int + ) { + private var byteOffset = startOffset + private var bitOffset = 0 + + fun readUnary(): Long { + var value = 0L + + while (readBit()) { + value++ + + if (value > Int.MAX_VALUE) { + throw IllegalArgumentException( + "Invalid Golomb-Rice quotient" + ) + } + } + + return value + } + + fun readBits(count: Int): Long { + var value = 0L + + repeat(count) { + value = (value shl 1) or + if (readBit()) 1L else 0L + } + + return value + } + + private fun readBit(): Boolean { + if (byteOffset >= data.size) { + throw IllegalArgumentException( + "Unexpected end of GCS filter" + ) + } + + val bit = + (data[byteOffset].toInt() ushr (7 - bitOffset)) and 1 + + bitOffset++ + + if (bitOffset == 8) { + bitOffset = 0 + byteOffset++ + } + + return bit == 1 + } + } +} diff --git a/app/src/main/java/org/vextaproject/wallet/MainActivity.kt b/app/src/main/java/org/vextaproject/wallet/MainActivity.kt new file mode 100644 index 0000000..ee51d1f --- /dev/null +++ b/app/src/main/java/org/vextaproject/wallet/MainActivity.kt @@ -0,0 +1,719 @@ +package org.vextaproject.wallet + +import android.app.Activity +import android.graphics.Color +import android.os.Bundle +import android.view.Gravity +import android.widget.LinearLayout +import android.widget.ScrollView +import android.widget.TextView +import java.io.ByteArrayOutputStream +import java.io.DataInputStream +import java.io.File +import java.io.OutputStream +import java.math.BigInteger +import java.net.InetAddress +import java.net.InetSocketAddress +import java.net.Socket +import java.nio.ByteBuffer +import java.nio.ByteOrder +import java.security.MessageDigest +import kotlin.random.Random + +class MainActivity : Activity() { + + private lateinit var status: TextView + + companion object { + private val MAGIC = byteArrayOf(0x56, 0x54, 0x58, 0x31) + private const val PORT = 19333 + private const val PROTOCOL_VERSION = 70018 + + private const val GENESIS_HASH = + "0000027626959d894ae1c8a6f9050cdcbdf58eb0037ab06345cb5502955370f1" + + private const val GENESIS_TIME = 1782770400L + private const val GENESIS_BITS = 0x1e0ffff0L + + private const val AVERAGING_WINDOW = 10 + private const val TARGET_SPACING = 600L + private const val TARGET_TIMESPAN = AVERAGING_WINDOW * TARGET_SPACING + private const val MIN_TIMESPAN = TARGET_TIMESPAN * 92 / 100 + private const val MAX_TIMESPAN = TARGET_TIMESPAN * 116 / 100 + + private val POW_LIMIT = + BigInteger.ONE.shiftLeft(256).subtract(BigInteger.ONE).shiftRight(20) + } + + data class VersionInfo( + val protocol: Int, + val height: Int, + val userAgent: String + ) + + data class ChainHeader( + val height: Int, + val raw: ByteArray?, + val hashWire: ByteArray, + val hashDisplay: String, + val time: Long, + val bits: Long + ) + + data class SyncResult( + val received: Int, + val cachedBefore: Int, + val chainHeight: Int, + val lastHash: String + ) + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + + if (intent.getBooleanExtra("sync_only", false)) { + window.setBackgroundDrawableResource( + android.R.color.transparent + ) + startSync() + return + } + + val layout = LinearLayout(this).apply { + orientation = LinearLayout.VERTICAL + gravity = Gravity.CENTER_HORIZONTAL + setPadding(48, 100, 48, 100) + setBackgroundColor(Color.rgb(7, 24, 46)) + } + + val title = TextView(this).apply { + text = "Vexta Wallet" + textSize = 32f + setTextColor(Color.WHITE) + gravity = Gravity.CENTER + } + + status = TextView(this).apply { + text = "\nLoading and verifying cached headers..." + textSize = 16f + setTextColor(Color.LTGRAY) + gravity = Gravity.CENTER + } + + layout.addView(title) + layout.addView(status) + + setContentView(ScrollView(this).apply { addView(layout) }) + + startSync() + } + + private fun startSync() { + Thread { + try { + val chain = loadCachedChain() + val cachedAtStart = chain.last().height + + val peers = listOf( + "87.106.99.23", + "74.208.53.160" + ) + + val results = mutableListOf() + + for ((index, peer) in peers.withIndex()) { + try { + val result = syncFromPeer(peer, chain) + + if (result.received > 0) { + saveChain(chain) + } + + results.add( + "$peer:$PORT\n" + + "Handshake: successful\n" + + "Headers received: ${result.received}\n" + + "Cached before: ${result.cachedBefore}\n" + + "Verified height: ${result.chainHeight}\n" + + "Proof of work: valid\n" + + "Difficulty rules: valid\n" + + "Chain linkage: valid\n\n" + + "Tip hash:\n${result.lastHash}" + ) + } catch (e: Exception) { + results.add( + "$peer:$PORT\nFailed: ${e.message ?: e.javaClass.simpleName}" + ) + } + } + + runOnUiThread { + if (intent.getBooleanExtra("sync_only", false)) { + setResult( + RESULT_OK, + android.content.Intent().putExtra( + "verified_height", + chain.last().height + ) + ) + finish() + } else { + status.text = + "\nVexta SPV verification\n\n" + + "Initial cached height: $cachedAtStart\n" + + "Stored header file: " + + "${chain.last().height} blocks\n\n" + + results.joinToString( + "\n\n--------------------\n\n" + ) + } + } + } catch (e: Exception) { + runOnUiThread { + if (intent.getBooleanExtra("sync_only", false)) { + setResult(RESULT_CANCELED) + finish() + } else { + status.text = + "\nVerification failed\n\n" + + (e.message ?: e.javaClass.simpleName) + } + } + } + }.start() + } + + private fun loadCachedChain(): MutableList { + val chain = mutableListOf( + ChainHeader( + height = 0, + raw = null, + hashWire = hashHexToWireBytes(GENESIS_HASH), + hashDisplay = GENESIS_HASH, + time = GENESIS_TIME, + bits = GENESIS_BITS + ) + ) + + val file = File(filesDir, "vexta-headers.dat") + + if (!file.exists()) { + return chain + } + + val data = file.readBytes() + + if (data.size % 80 != 0) { + file.delete() + return chain + } + + try { + var offset = 0 + + while (offset < data.size) { + val raw = data.copyOfRange(offset, offset + 80) + appendVerifiedHeader(chain, raw) + offset += 80 + } + } catch (_: Exception) { + file.delete() + return mutableListOf(chain.first()) + } + + return chain + } + + private fun saveChain(chain: List) { + val file = File(filesDir, "vexta-headers.dat") + val temporary = File(filesDir, "vexta-headers.tmp") + + temporary.outputStream().use { output -> + chain.drop(1).forEach { header -> + output.write( + header.raw + ?: throw IllegalStateException("missing stored header") + ) + } + } + + if (file.exists()) { + file.delete() + } + + if (!temporary.renameTo(file)) { + throw IllegalStateException("unable to save header database") + } + } + + private fun syncFromPeer( + host: String, + chain: MutableList + ): SyncResult { + Socket().use { socket -> + socket.soTimeout = 15000 + socket.connect(InetSocketAddress(host, PORT), 5000) + + val input = DataInputStream(socket.getInputStream()) + val output = socket.getOutputStream() + + sendMessage(output, "version", createVersionPayload(host)) + + var versionInfo: VersionInfo? = null + var gotVerack = false + var requested = false + val cachedBefore = chain.last().height + + repeat(200) { + val message = readMessage(input) + + when (message.first) { + "version" -> { + versionInfo = parseVersionPayload(message.second) + sendMessage(output, "verack", byteArrayOf()) + } + + "verack" -> gotVerack = true + + "ping" -> sendMessage(output, "pong", message.second) + + "headers" -> { + val received = parseHeaders(message.second, chain) + val remote = versionInfo + ?: throw IllegalStateException("missing node version") + + if (chain.last().height > remote.height) { + throw IllegalStateException( + "local verified chain exceeds peer height" + ) + } + + return SyncResult( + received = received, + cachedBefore = cachedBefore, + chainHeight = chain.last().height, + lastHash = chain.last().hashDisplay + ) + } + } + + if (versionInfo != null && gotVerack && !requested) { + sendMessage( + output, + "getheaders", + createGetHeadersPayload(chain.last().hashWire) + ) + requested = true + } + } + + throw IllegalStateException("headers response timeout") + } + } + + private fun parseHeaders( + payload: ByteArray, + chain: MutableList + ): Int { + val buffer = ByteBuffer.wrap(payload).order(ByteOrder.LITTLE_ENDIAN) + val count = readCompactSize(buffer) + + if (count > 2000) { + throw IllegalStateException("too many headers: $count") + } + + repeat(count) { + if (buffer.remaining() < 81) { + throw IllegalStateException("truncated headers message") + } + + val raw = ByteArray(80) + buffer.get(raw) + + val transactionCount = readCompactSize(buffer) + + if (transactionCount != 0) { + throw IllegalStateException( + "headers message contains transactions" + ) + } + + appendVerifiedHeader(chain, raw) + } + + return count + } + + private fun appendVerifiedHeader( + chain: MutableList, + raw: ByteArray + ) { + val previous = chain.last() + val previousHash = raw.copyOfRange(4, 36) + + if (!previousHash.contentEquals(previous.hashWire)) { + throw IllegalStateException( + "header linkage failed at height ${previous.height + 1}" + ) + } + + val buffer = ByteBuffer.wrap(raw).order(ByteOrder.LITTLE_ENDIAN) + val time = buffer.getInt(68).toLong() and 0xffffffffL + val bits = buffer.getInt(72).toLong() and 0xffffffffL + + val target = compactToTarget(bits) + + if (target <= BigInteger.ZERO || target > POW_LIMIT) { + throw IllegalStateException( + "invalid target at height ${previous.height + 1}" + ) + } + + val hashWire = doubleSha256(raw) + val hashNumber = BigInteger(1, hashWire.reversedArray()) + + if (hashNumber > target) { + throw IllegalStateException( + "proof of work failed at height ${previous.height + 1}" + ) + } + + val expectedBits = expectedBits(chain) + + if (bits != expectedBits) { + throw IllegalStateException( + "difficulty mismatch at height ${previous.height + 1}: " + + "expected ${expectedBits.toString(16)}, " + + "received ${bits.toString(16)}" + ) + } + + chain.add( + ChainHeader( + height = previous.height + 1, + raw = raw, + hashWire = hashWire, + hashDisplay = hashWire.reversedArray().toHex(), + time = time, + bits = bits + ) + ) + } + + private fun expectedBits(chain: List): Long { + val last = chain.last() + + if (last.height < AVERAGING_WINDOW) { + return targetToCompact(POW_LIMIT) + } + + val first = chain[last.height - AVERAGING_WINDOW] + + var actualTimespan = + medianTimePast(chain, last.height) - + medianTimePast(chain, first.height) + + actualTimespan = + TARGET_TIMESPAN + + (actualTimespan - TARGET_TIMESPAN) / 4 + + actualTimespan = actualTimespan.coerceIn( + MIN_TIMESPAN, + MAX_TIMESPAN + ) + + var newTarget = + compactToTarget(last.bits) + .multiply(BigInteger.valueOf(actualTimespan)) + .divide(BigInteger.valueOf(TARGET_TIMESPAN)) + + if (newTarget > POW_LIMIT) { + newTarget = POW_LIMIT + } + + return targetToCompact(newTarget) + } + + private fun medianTimePast( + chain: List, + height: Int + ): Long { + val start = maxOf(0, height - 10) + val times = (start..height) + .map { chain[it].time } + .sorted() + + return times[times.size / 2] + } + + private fun compactToTarget(compact: Long): BigInteger { + val size = ((compact ushr 24) and 0xff).toInt() + var word = compact and 0x007fffffL + + var value = BigInteger.valueOf(word) + + value = if (size <= 3) { + value.shiftRight(8 * (3 - size)) + } else { + value.shiftLeft(8 * (size - 3)) + } + + return if ((compact and 0x00800000L) != 0L) { + value.negate() + } else { + value + } + } + + private fun targetToCompact(targetValue: BigInteger): Long { + if (targetValue == BigInteger.ZERO) { + return 0 + } + + val negative = targetValue.signum() < 0 + val target = targetValue.abs() + + var size = (target.bitLength() + 7) / 8 + + var compact = if (size <= 3) { + target.toLong() shl (8 * (3 - size)) + } else { + target.shiftRight(8 * (size - 3)).toLong() + } + + if ((compact and 0x00800000L) != 0L) { + compact = compact ushr 8 + size++ + } + + compact = compact and 0x007fffffL + compact = compact or (size.toLong() shl 24) + + if (negative && (compact and 0x007fffffL) != 0L) { + compact = compact or 0x00800000L + } + + return compact + } + + private fun createGetHeadersPayload(locatorHash: ByteArray): ByteArray { + val out = ByteArrayOutputStream() + + writeInt32LE(out, PROTOCOL_VERSION) + writeCompactSize(out, 1) + out.write(locatorHash) + out.write(ByteArray(32)) + + return out.toByteArray() + } + + private fun readMessage(input: DataInputStream): Pair { + val header = ByteArray(24) + input.readFully(header) + + if (!header.copyOfRange(0, 4).contentEquals(MAGIC)) { + throw IllegalStateException("invalid Vexta network magic") + } + + val command = header.copyOfRange(4, 16) + .takeWhile { it.toInt() != 0 } + .toByteArray() + .toString(Charsets.US_ASCII) + + val payloadLength = ByteBuffer.wrap(header, 16, 4) + .order(ByteOrder.LITTLE_ENDIAN) + .int + + if (payloadLength < 0 || payloadLength > 4_000_000) { + throw IllegalStateException("invalid payload length") + } + + val expectedChecksum = header.copyOfRange(20, 24) + val payload = ByteArray(payloadLength) + input.readFully(payload) + + val actualChecksum = doubleSha256(payload).copyOfRange(0, 4) + + if (!expectedChecksum.contentEquals(actualChecksum)) { + throw IllegalStateException("invalid message checksum") + } + + return command to payload + } + + private fun createVersionPayload(peerHost: String): ByteArray { + val out = ByteArrayOutputStream() + + writeInt32LE(out, PROTOCOL_VERSION) + writeInt64LE(out, 0) + writeInt64LE(out, System.currentTimeMillis() / 1000) + + writeNetworkAddress(out, peerHost, PORT) + writeNetworkAddress(out, "0.0.0.0", 0) + + writeInt64LE(out, Random.nextLong()) + writeVarString(out, "/VextaAndroidWallet:0.1.0/") + writeInt32LE(out, 0) + out.write(0) + + return out.toByteArray() + } + + private fun parseVersionPayload(payload: ByteArray): VersionInfo { + val buffer = ByteBuffer.wrap(payload).order(ByteOrder.LITTLE_ENDIAN) + + if (payload.size < 80) { + throw IllegalStateException("short version payload") + } + + val version = buffer.int + buffer.long + buffer.long + buffer.position(buffer.position() + 26) + buffer.position(buffer.position() + 26) + buffer.long + + val userAgent = readVarString(buffer) + val height = if (buffer.remaining() >= 4) buffer.int else 0 + + return VersionInfo(version, height, userAgent) + } + + private fun sendMessage( + output: OutputStream, + command: String, + payload: ByteArray + ) { + val message = ByteArrayOutputStream() + + message.write(MAGIC) + + val commandBytes = ByteArray(12) + command.toByteArray(Charsets.US_ASCII).copyInto( + destination = commandBytes, + endIndex = minOf(command.length, 12) + ) + + message.write(commandBytes) + writeInt32LE(message, payload.size) + message.write(doubleSha256(payload).copyOfRange(0, 4)) + message.write(payload) + + output.write(message.toByteArray()) + output.flush() + } + + private fun writeNetworkAddress( + out: ByteArrayOutputStream, + host: String, + port: Int + ) { + writeInt64LE(out, 0) + + val address = InetAddress.getByName(host).address + val ipv6 = ByteArray(16) + + if (address.size == 4) { + ipv6[10] = 0xff.toByte() + ipv6[11] = 0xff.toByte() + address.copyInto(ipv6, 12) + } else { + address.copyInto(ipv6) + } + + out.write(ipv6) + out.write((port shr 8) and 0xff) + out.write(port and 0xff) + } + + private fun writeVarString(out: ByteArrayOutputStream, value: String) { + val bytes = value.toByteArray(Charsets.UTF_8) + writeCompactSize(out, bytes.size) + out.write(bytes) + } + + private fun readVarString(buffer: ByteBuffer): String { + val length = readCompactSize(buffer) + + if (length > buffer.remaining()) { + throw IllegalStateException("invalid string length") + } + + val bytes = ByteArray(length) + buffer.get(bytes) + + return bytes.toString(Charsets.UTF_8) + } + + private fun writeCompactSize(out: ByteArrayOutputStream, value: Int) { + when { + value < 253 -> out.write(value) + + value <= 0xffff -> { + out.write(253) + out.write(value and 0xff) + out.write((value shr 8) and 0xff) + } + + else -> { + out.write(254) + writeInt32LE(out, value) + } + } + } + + private fun readCompactSize(buffer: ByteBuffer): Int { + if (!buffer.hasRemaining()) { + throw IllegalStateException("missing compact size") + } + + return when (val first = buffer.get().toInt() and 0xff) { + 253 -> buffer.short.toInt() and 0xffff + 254 -> buffer.int + + 255 -> { + val value = buffer.long + + if (value < 0 || value > Int.MAX_VALUE) { + throw IllegalStateException("compact size too large") + } + + value.toInt() + } + + else -> first + } + } + + private fun hashHexToWireBytes(hash: String): ByteArray = + hash.removePrefix("0x") + .chunked(2) + .map { it.toInt(16).toByte() } + .toByteArray() + .reversedArray() + + private fun ByteArray.toHex(): String = + joinToString("") { "%02x".format(it.toInt() and 0xff) } + + private fun writeInt32LE(out: ByteArrayOutputStream, value: Int) { + out.write( + ByteBuffer.allocate(4) + .order(ByteOrder.LITTLE_ENDIAN) + .putInt(value) + .array() + ) + } + + private fun writeInt64LE(out: ByteArrayOutputStream, value: Long) { + out.write( + ByteBuffer.allocate(8) + .order(ByteOrder.LITTLE_ENDIAN) + .putLong(value) + .array() + ) + } + + private fun doubleSha256(data: ByteArray): ByteArray { + val digest = MessageDigest.getInstance("SHA-256") + return digest.digest(digest.digest(data)) + } +} diff --git a/app/src/main/java/org/vextaproject/wallet/VextaTransactionSender.kt b/app/src/main/java/org/vextaproject/wallet/VextaTransactionSender.kt new file mode 100644 index 0000000..a89fce4 --- /dev/null +++ b/app/src/main/java/org/vextaproject/wallet/VextaTransactionSender.kt @@ -0,0 +1,922 @@ +package org.vextaproject.wallet + +import org.bitcoinj.core.ECKey +import org.bitcoinj.script.ScriptBuilder +import org.bitcoinj.params.MainNetParams +import org.bitcoinj.core.TransactionWitness +import org.bitcoinj.core.Utils +import org.bitcoinj.core.TransactionOutput +import org.bitcoinj.core.TransactionOutPoint +import org.bitcoinj.core.TransactionInput +import org.bitcoinj.core.Transaction +import org.bitcoinj.core.Coin +import org.bitcoinj.core.Sha256Hash +import java.io.ByteArrayOutputStream +import java.io.DataInputStream +import java.io.OutputStream +import java.net.InetAddress +import java.net.InetSocketAddress +import java.net.Socket +import java.net.SocketTimeoutException +import java.nio.ByteBuffer +import java.nio.ByteOrder +import java.security.MessageDigest +import kotlin.random.Random + +object VextaTransactionSender { + + private val magic = byteArrayOf(0x56, 0x54, 0x58, 0x31) + private const val port = 19333 + private const val protocolVersion = 70018 + private const val sighashAll = 1L + private const val sequence = 0xffffffffL + private const val dustLimit = 546L + + data class CreatedTransaction( + val rawTransaction: ByteArray, + val txid: String, + val amount: Long, + val fee: Long, + val change: Long, + val inputCount: Int, + val spentOutpoints: Set + ) + + fun createAndSign( + spendableUtxos: List, + recipientAddress: String, + amountSatoshis: Long, + privateKeysByIndex: Map, + changePubKeyHash: ByteArray + ): CreatedTransaction { + require(amountSatoshis > 0L) { + "Amount must be greater than zero" + } + + require(changePubKeyHash.size == 20) { + "Invalid change public-key hash" + } + + require(privateKeysByIndex.isNotEmpty()) { + "No wallet private keys supplied" + } + + val recipientScript = addressToScript(recipientAddress) + val changeScript = + byteArrayOf(0x00, 0x14) + changePubKeyHash + + val orderedUtxos = spendableUtxos.sortedWith( + compareBy { it.height } + .thenBy { it.txid } + .thenBy { it.outputIndex } + ) + + val selected = + mutableListOf() + + var selectedValue = 0L + + for (utxo in orderedUtxos) { + selected.add(utxo) + selectedValue = + Math.addExact(selectedValue, utxo.value) + + val estimatedFee = estimateFee( + inputCount = selected.size, + outputCount = 2 + ) + + if ( + selectedValue >= + amountSatoshis + estimatedFee + ) { + break + } + } + + if (selected.isEmpty()) { + throw IllegalStateException( + "Wallet has no spendable outputs" + ) + } + + var fee = estimateFee( + inputCount = selected.size, + outputCount = 2 + ) + + if (selectedValue < amountSatoshis + fee) { + throw IllegalStateException( + "Insufficient balance including transaction fee" + ) + } + + var change = + selectedValue - amountSatoshis - fee + + val outputs = mutableListOf( + TransactionOutputData( + value = amountSatoshis, + script = recipientScript + ) + ) + + if (change >= dustLimit) { + outputs.add( + TransactionOutputData( + value = change, + script = changeScript + ) + ) + } else { + fee += change + change = 0L + } + + /* + * Network parameters do not affect transaction serialization or + * SegWit signature hashing. Vexta uses Bitcoin-compatible transaction + * and witness serialization, so bitcoinj's transaction implementation + * can safely perform the BIP143 signature calculation. + */ + val parameters = MainNetParams.get() + val transaction = Transaction(parameters) + transaction.setVersion(2) + + selected.forEach { utxo -> + val outPoint = TransactionOutPoint( + parameters, + utxo.outputIndex, + Sha256Hash.wrap(utxo.txid) + ) + + val input = TransactionInput( + parameters, + transaction, + byteArrayOf(), + outPoint, + Coin.valueOf(utxo.value) + ) + + input.sequenceNumber = 0xffffffffL + transaction.addInput(input) + } + + outputs.forEach { output -> + transaction.addOutput( + TransactionOutput( + parameters, + transaction, + Coin.valueOf(output.value), + output.script + ) + ) + } + + selected.forEachIndexed { index, utxo -> + val privateKey = + privateKeysByIndex[utxo.addressIndex] + ?: throw IllegalStateException( + "Missing private key for address index " + + utxo.addressIndex + ) + + val walletPubKeyHash = + Utils.sha256hash160(privateKey.pubKey) + + val scriptCode = + ScriptBuilder.createP2PKHOutputScript( + walletPubKeyHash + ) + + val signature = + transaction.calculateWitnessSignature( + index, + privateKey, + scriptCode, + Coin.valueOf(utxo.value), + Transaction.SigHash.ALL, + false + ) + + transaction.getInput(index.toLong()).setWitness( + TransactionWitness.redeemP2WPKH( + signature, + privateKey + ) + ) + } + + val rawTransaction = + transaction.bitcoinSerialize() + + return CreatedTransaction( + rawTransaction = rawTransaction, + txid = transaction.txId.toString(), + amount = amountSatoshis, + fee = fee, + change = change, + inputCount = selected.size, + spentOutpoints = selected.map { + "${it.txid}:${it.outputIndex}" + }.toSet() + ) + } + + fun broadcast( + transaction: CreatedTransaction, + peers: List + ): Int { + var successfulPeers = 0 + var lastError: Exception? = null + + peers.distinct().forEach { peer -> + try { + broadcastToPeer(peer, transaction.rawTransaction) + successfulPeers++ + } catch (error: Exception) { + lastError = error + } + } + + if (successfulPeers == 0) { + throw lastError + ?: IllegalStateException("Transaction broadcast failed") + } + + return successfulPeers + } + + private fun serializeTransaction( + selected: List, + outputs: List, + signatures: List, + publicKey: ByteArray, + includeWitness: Boolean + ): ByteArray { + val output = ByteArrayOutputStream() + + writeInt32LE(output, 2) + + if (includeWitness) { + output.write(0x00) + output.write(0x01) + } + + writeCompactSize(output, selected.size.toLong()) + + selected.forEach { utxo -> + output.write(hashDisplayToWire(utxo.txid)) + writeUInt32LE(output, utxo.outputIndex) + output.write(0x00) + writeUInt32LE(output, sequence) + } + + output.write(serializeOutputs(outputs)) + + if (includeWitness) { + selected.indices.forEach { index -> + output.write(0x02) + + val signature = signatures[index] + writeCompactSize(output, signature.size.toLong()) + output.write(signature) + + writeCompactSize(output, publicKey.size.toLong()) + output.write(publicKey) + } + } + + writeUInt32LE(output, 0) + return output.toByteArray() + } + + private fun serializeOutputs( + outputs: List + ): ByteArray { + return ByteArrayOutputStream().apply { + writeCompactSize(this, outputs.size.toLong()) + + outputs.forEach { transactionOutput -> + writeInt64LE(this, transactionOutput.value) + writeCompactSize( + this, + transactionOutput.script.size.toLong() + ) + write(transactionOutput.script) + } + }.toByteArray() + } + + private fun estimateFee( + inputCount: Int, + outputCount: Int + ): Long { + val virtualBytes = + 11L + + inputCount * 69L + + outputCount * 31L + + return maxOf( + 1_000L, + virtualBytes * 10L + ) + } + + private fun addressToScript(address: String): ByteArray { + val value = address.trim() + + if (value.lowercase().startsWith("vtx1")) { + val witnessProgram = decodeBech32Witness(value) + + require(witnessProgram.size == 20) { + "Only Vexta P2WPKH addresses are supported" + } + + return byteArrayOf(0x00, 0x14) + witnessProgram + } + + val decoded = decodeBase58Check(value) + + require(decoded.size == 21) { + "Invalid legacy Vexta address" + } + + require((decoded[0].toInt() and 0xff) == 70) { + "Wrong legacy Vexta address prefix" + } + + val publicKeyHash = decoded.copyOfRange(1, 21) + + return byteArrayOf( + 0x76, + 0xa9.toByte(), + 0x14 + ) + + publicKeyHash + + byteArrayOf( + 0x88.toByte(), + 0xac.toByte() + ) + } + + private fun decodeBech32Witness(address: String): ByteArray { + require(address == address.lowercase()) { + "Mixed-case Bech32 address" + } + + val separator = address.lastIndexOf('1') + + require(separator > 0 && separator + 7 <= address.length) { + "Invalid Bech32 address" + } + + val hrp = address.substring(0, separator) + require(hrp == "vtx") { + "Wrong Bech32 network" + } + + val charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l" + val values = address.substring(separator + 1).map { character -> + val index = charset.indexOf(character) + require(index >= 0) { + "Invalid Bech32 character" + } + index + } + + require(bech32Polymod(expandHrp(hrp) + values) == 1) { + "Invalid Bech32 checksum" + } + + val data = values.dropLast(6) + require(data.isNotEmpty() && data[0] == 0) { + "Unsupported witness version" + } + + return convertBits( + data.drop(1), + 5, + 8, + false + ).map { it.toByte() }.toByteArray() + } + + private fun convertBits( + input: List, + fromBits: Int, + toBits: Int, + pad: Boolean + ): List { + var accumulator = 0 + var bits = 0 + val result = mutableListOf() + val maxValue = (1 shl toBits) - 1 + val maxAccumulator = + (1 shl (fromBits + toBits - 1)) - 1 + + input.forEach { value -> + require(value >= 0 && value shr fromBits == 0) { + "Invalid address data" + } + + accumulator = + ((accumulator shl fromBits) or value) and + maxAccumulator + bits += fromBits + + while (bits >= toBits) { + bits -= toBits + result.add( + (accumulator shr bits) and maxValue + ) + } + } + + if (pad) { + if (bits > 0) { + result.add( + (accumulator shl (toBits - bits)) and + maxValue + ) + } + } else { + require(bits < fromBits) { + "Invalid address padding" + } + + require( + bits == 0 || + ((accumulator shl (toBits - bits)) and + maxValue) == 0 + ) { + "Non-zero address padding" + } + } + + return result + } + + private fun expandHrp(hrp: String): List = + hrp.map { it.code shr 5 } + + listOf(0) + + hrp.map { it.code and 31 } + + private fun bech32Polymod(values: List): Int { + val generators = intArrayOf( + 0x3b6a57b2, + 0x26508e6d, + 0x1ea119fa, + 0x3d4233dd, + 0x2a1462b3 + ) + + var checksum = 1 + + values.forEach { value -> + val top = checksum ushr 25 + checksum = + ((checksum and 0x1ffffff) shl 5) xor value + + for (index in 0..4) { + if (((top shr index) and 1) != 0) { + checksum = + checksum xor generators[index] + } + } + } + + return checksum + } + + private fun decodeBase58Check(value: String): ByteArray { + val alphabet = + "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" + + var number = java.math.BigInteger.ZERO + val base = java.math.BigInteger.valueOf(58) + + value.forEach { character -> + val digit = alphabet.indexOf(character) + + require(digit >= 0) { + "Invalid Base58 character" + } + + number = number + .multiply(base) + .add(java.math.BigInteger.valueOf(digit.toLong())) + } + + val rawNumber = number.toByteArray().let { bytes -> + if (bytes.size > 1 && bytes[0].toInt() == 0) { + bytes.copyOfRange(1, bytes.size) + } else { + bytes + } + } + + val leadingZeros = value.takeWhile { it == '1' }.length + val decoded = ByteArray(leadingZeros) + rawNumber + + require(decoded.size >= 5) { + "Invalid Base58 address" + } + + val payload = decoded.copyOfRange(0, decoded.size - 4) + val checksum = decoded.copyOfRange( + decoded.size - 4, + decoded.size + ) + + require( + doubleSha256(payload) + .copyOfRange(0, 4) + .contentEquals(checksum) + ) { + "Invalid Base58 checksum" + } + + return payload + } + + private fun broadcastToPeer( + peer: String, + rawTransaction: ByteArray + ) { + Socket().use { socket -> + socket.soTimeout = 5_000 + socket.connect( + InetSocketAddress(peer, port), + 5_000 + ) + + val input = DataInputStream(socket.getInputStream()) + val output = socket.getOutputStream() + + sendMessage( + output, + "version", + createVersionPayload(peer) + ) + + var gotVersion = false + var gotVerack = false + var transactionSent = false + + repeat(100) { + try { + val message = readMessage(input) + + when (message.first) { + "version" -> { + gotVersion = true + sendMessage( + output, + "verack", + byteArrayOf() + ) + } + + "verack" -> gotVerack = true + + "ping" -> sendMessage( + output, + "pong", + message.second + ) + + "reject" -> { + throw IllegalStateException( + parseRejectMessage(message.second) + ) + } + + "inv" -> { + if (transactionSent) { + return + } + } + } + + if ( + gotVersion && + gotVerack && + !transactionSent + ) { + sendMessage( + output, + "tx", + rawTransaction + ) + transactionSent = true + socket.soTimeout = 5_000 + } + } catch (_: SocketTimeoutException) { + if (transactionSent) { + return + } + + throw IllegalStateException( + "Peer handshake timed out" + ) + } + } + + if (!transactionSent) { + throw IllegalStateException( + "Peer handshake did not complete" + ) + } + } + } + + private fun parseRejectMessage( + payload: ByteArray + ): String { + return try { + val buffer = ByteBuffer.wrap(payload) + .order(ByteOrder.LITTLE_ENDIAN) + + val rejectedCommand = + readRejectVarString(buffer) + + val code = + if (buffer.hasRemaining()) { + buffer.get().toInt() and 0xff + } else { + -1 + } + + val reason = + if (buffer.hasRemaining()) { + readRejectVarString(buffer) + } else { + "unknown reason" + } + + "Peer rejected $rejectedCommand " + + "(code $code): $reason" + } catch (_: Exception) { + "Peer rejected transaction" + } + } + + private fun readRejectVarString( + buffer: ByteBuffer + ): String { + val length = readRejectCompactSize(buffer) + + require( + length >= 0L && + length <= buffer.remaining().toLong() && + length <= 10_000L + ) { + "Invalid reject message" + } + + val bytes = ByteArray(length.toInt()) + buffer.get(bytes) + return bytes.toString(Charsets.UTF_8) + } + + private fun readRejectCompactSize( + buffer: ByteBuffer + ): Long { + val first = buffer.get().toInt() and 0xff + + return when (first) { + 253 -> buffer.short.toInt().and(0xffff).toLong() + 254 -> buffer.int.toLong().and(0xffffffffL) + 255 -> buffer.long + else -> first.toLong() + } + } + + private fun createVersionPayload( + peerHost: String + ): ByteArray { + return ByteArrayOutputStream().apply { + writeInt32LE(this, protocolVersion) + writeInt64LE(this, 0) + writeInt64LE( + this, + System.currentTimeMillis() / 1000 + ) + writeNetworkAddress(this, peerHost, port) + writeNetworkAddress(this, "0.0.0.0", 0) + writeInt64LE(this, Random.nextLong()) + writeVarString( + this, + "/VextaAndroidWallet:0.4.3/" + ) + writeInt32LE(this, 0) + write(0) + }.toByteArray() + } + + private fun sendMessage( + output: OutputStream, + command: String, + payload: ByteArray + ) { + val message = ByteArrayOutputStream() + message.write(magic) + + val commandBytes = ByteArray(12) + command.toByteArray(Charsets.US_ASCII).copyInto( + commandBytes, + endIndex = minOf(command.length, 12) + ) + + message.write(commandBytes) + writeInt32LE(message, payload.size) + message.write( + doubleSha256(payload).copyOfRange(0, 4) + ) + message.write(payload) + + output.write(message.toByteArray()) + output.flush() + } + + private fun readMessage( + input: DataInputStream + ): Pair { + val header = ByteArray(24) + input.readFully(header) + + require( + header.copyOfRange(0, 4) + .contentEquals(magic) + ) { + "Invalid Vexta network message" + } + + val command = header.copyOfRange(4, 16) + .takeWhile { it.toInt() != 0 } + .toByteArray() + .toString(Charsets.US_ASCII) + + val payloadLength = ByteBuffer + .wrap(header, 16, 4) + .order(ByteOrder.LITTLE_ENDIAN) + .int + + require( + payloadLength in 0..4_000_000 + ) { + "Invalid P2P payload length" + } + + val payload = ByteArray(payloadLength) + input.readFully(payload) + + val checksum = header.copyOfRange(20, 24) + + require( + doubleSha256(payload) + .copyOfRange(0, 4) + .contentEquals(checksum) + ) { + "Invalid P2P checksum" + } + + return command to payload + } + + private fun writeNetworkAddress( + output: ByteArrayOutputStream, + host: String, + targetPort: Int + ) { + writeInt64LE(output, 0) + + val address = InetAddress.getByName(host).address + val ipv6 = ByteArray(16) + + if (address.size == 4) { + ipv6[10] = 0xff.toByte() + ipv6[11] = 0xff.toByte() + address.copyInto(ipv6, 12) + } else { + address.copyInto(ipv6) + } + + output.write(ipv6) + output.write((targetPort shr 8) and 0xff) + output.write(targetPort and 0xff) + } + + private fun writeVarString( + output: ByteArrayOutputStream, + value: String + ) { + val bytes = value.toByteArray(Charsets.UTF_8) + writeCompactSize(output, bytes.size.toLong()) + output.write(bytes) + } + + private fun writeCompactSize( + output: ByteArrayOutputStream, + value: Long + ) { + when { + value < 253 -> output.write(value.toInt()) + + value <= 0xffff -> { + output.write(253) + output.write((value and 0xff).toInt()) + output.write( + ((value shr 8) and 0xff).toInt() + ) + } + + value <= 0xffffffffL -> { + output.write(254) + repeat(4) { index -> + output.write( + ((value shr (8 * index)) and 0xff) + .toInt() + ) + } + } + + else -> { + output.write(255) + repeat(8) { index -> + output.write( + ((value shr (8 * index)) and 0xff) + .toInt() + ) + } + } + } + } + + private fun writeInt32LE( + output: ByteArrayOutputStream, + value: Int + ) { + output.write( + ByteBuffer.allocate(4) + .order(ByteOrder.LITTLE_ENDIAN) + .putInt(value) + .array() + ) + } + + private fun writeUInt32LE( + output: ByteArrayOutputStream, + value: Long + ) { + repeat(4) { index -> + output.write( + ((value shr (8 * index)) and 0xff) + .toInt() + ) + } + } + + private fun writeInt64LE( + output: ByteArrayOutputStream, + value: Long + ) { + output.write( + ByteBuffer.allocate(8) + .order(ByteOrder.LITTLE_ENDIAN) + .putLong(value) + .array() + ) + } + + private fun hashDisplayToWire( + hash: String + ): ByteArray { + require(hash.length == 64) { + "Invalid transaction ID" + } + + return hash.chunked(2) + .map { it.toInt(16).toByte() } + .toByteArray() + .reversedArray() + } + + private fun doubleSha256( + data: ByteArray + ): ByteArray { + val digest = MessageDigest.getInstance("SHA-256") + return digest.digest(digest.digest(data)) + } + + private fun ByteArray.toHex(): String = + joinToString("") { + "%02x".format(it.toInt() and 0xff) + } + + private data class TransactionOutputData( + val value: Long, + val script: ByteArray + ) +} diff --git a/app/src/main/java/org/vextaproject/wallet/WalletActivity.kt b/app/src/main/java/org/vextaproject/wallet/WalletActivity.kt new file mode 100644 index 0000000..ab86743 --- /dev/null +++ b/app/src/main/java/org/vextaproject/wallet/WalletActivity.kt @@ -0,0 +1,2911 @@ +package org.vextaproject.wallet + +import android.app.Activity +import android.app.PendingIntent +import android.app.NotificationManager +import android.app.NotificationChannel +import android.app.Notification +import android.Manifest +import android.app.DownloadManager +import android.app.AlertDialog +import android.content.ClipData +import android.content.BroadcastReceiver +import android.content.ClipboardManager +import android.content.Context +import android.content.Intent +import android.content.IntentFilter +import android.content.pm.PackageManager +import android.graphics.Bitmap +import android.graphics.Color +import android.graphics.Typeface +import android.graphics.drawable.GradientDrawable +import android.net.Uri +import android.os.Build +import android.os.Bundle +import android.os.Environment +import android.os.Handler +import android.os.Looper +import android.provider.Settings +import android.security.keystore.KeyGenParameterSpec +import android.security.keystore.KeyProperties +import android.text.InputType +import android.view.Gravity +import android.view.View +import android.view.ViewGroup +import android.view.WindowManager +import android.widget.Button +import android.widget.EditText +import android.widget.ImageView +import android.widget.LinearLayout +import android.widget.ScrollView +import android.widget.TextView +import android.widget.Toast +import com.google.zxing.BarcodeFormat +import com.google.zxing.MultiFormatWriter +import com.google.mlkit.vision.barcode.common.Barcode +import com.google.mlkit.vision.codescanner.GmsBarcodeScannerOptions +import com.google.mlkit.vision.codescanner.GmsBarcodeScanning +import org.bitcoinj.core.Base58 +import org.json.JSONObject +import org.bitcoinj.core.ECKey +import org.bitcoinj.core.Sha256Hash +import org.bitcoinj.core.Utils +import org.bitcoinj.crypto.ChildNumber +import org.bitcoinj.crypto.DeterministicHierarchy +import org.bitcoinj.crypto.HDKeyDerivation +import org.bitcoinj.crypto.MnemonicCode +import java.security.KeyStore +import java.security.MessageDigest +import java.math.BigDecimal +import java.math.RoundingMode +import java.net.HttpURLConnection +import java.net.URL +import java.security.SecureRandom +import javax.crypto.Cipher +import javax.crypto.KeyGenerator +import javax.crypto.SecretKey +import javax.crypto.spec.GCMParameterSpec + +class WalletActivity : Activity() { + + companion object { + private const val PREFS = "vexta_wallet" + private const val KEY_ALIAS = "vexta_wallet_seed_key" + private const val PREF_CIPHERTEXT = "seed_ciphertext" + private const val PREF_IV = "seed_iv" + private const val PREF_BACKUP_CONFIRMED = "backup_confirmed" + private const val UPDATE_URL = + "https://vexta-pool.co.uk/vexta-wallet-version.json" + private const val REQUEST_HEADER_SYNC = 4101 + private const val REQUEST_NOTIFICATIONS = 4102 + private const val PAYMENT_CHANNEL_ID = + "vexta_incoming_payments" + private const val PREF_LAST_CONFIRMED_BALANCE = + "last_confirmed_balance" + private const val PREF_BALANCE_INITIALIZED = + "balance_notification_initialized" + private const val PREF_RECEIVE_ADDRESS_INDEX = + "receive_address_index" + private const val PREF_RESTORE_ADDRESS_DISCOVERY = + "restore_address_discovery" + private const val RESTORE_ADDRESS_LOOKAHEAD = 20 + } + + private val backgroundColor = Color.rgb(2, 8, 23) + private val surfaceColor = Color.rgb(8, 22, 45) + private val surfaceColorAlt = Color.rgb(13, 38, 67) + private val accentColor = Color.rgb(0, 210, 255) + private val accentDark = Color.rgb(0, 119, 255) + private val neonPurple = Color.rgb(127, 90, 240) + private val successColor = Color.rgb(36, 220, 151) + private val textPrimary = Color.rgb(242, 248, 255) + private val textSecondary = Color.rgb(143, 168, 200) + private val dangerColor = Color.rgb(255, 73, 106) + private var sendRecipientInput: EditText? = null + private var blockchainScanStatus: TextView? = null + private var walletBalanceView: TextView? = null + private var walletHistoryView: TextView? = null + private var latestWalletTransactions = + emptyList() + private var transactionHistoryFilter = "ALL" + private var transactionHistoryLimit = 50 + private var transactionHistoryVisible = false + private var mainWalletVisible = false + private var automaticScanStarted = false + private var blockchainScanRunning = false + private var sendInProgress = false + private var latestSpendableUtxos = + emptyList() + + private val refreshHandler = Handler(Looper.getMainLooper()) + + private val refreshRunnable = object : Runnable { + override fun run() { + if ( + !isFinishing && + !isDestroyed && + hasWindowFocus() && + walletExists() && + walletBalanceView != null + ) { + startHeaderSyncAndScan() + } + + refreshHandler.postDelayed(this, 60_000L) + } + } + private var updateDownloadId = -1L + private var pendingUpdateUri: Uri? = null + private var pendingUpdateSha256: String? = null + + private val updateReceiver = object : BroadcastReceiver() { + override fun onReceive(context: Context?, intent: Intent?) { + if ( + intent?.action != DownloadManager.ACTION_DOWNLOAD_COMPLETE + ) { + return + } + + val completedId = intent.getLongExtra( + DownloadManager.EXTRA_DOWNLOAD_ID, + -1L + ) + + if (completedId != updateDownloadId) { + return + } + + val manager = getSystemService( + DOWNLOAD_SERVICE + ) as DownloadManager + + val query = DownloadManager.Query() + .setFilterById(completedId) + + manager.query(query)?.use { cursor -> + if (!cursor.moveToFirst()) { + Toast.makeText( + this@WalletActivity, + "Downloaded update could not be found", + Toast.LENGTH_LONG + ).show() + return + } + + val statusIndex = cursor.getColumnIndex( + DownloadManager.COLUMN_STATUS + ) + + val status = cursor.getInt(statusIndex) + + if (status != DownloadManager.STATUS_SUCCESSFUL) { + Toast.makeText( + this@WalletActivity, + "Update download failed", + Toast.LENGTH_LONG + ).show() + return + } + + val downloadedUri = + manager.getUriForDownloadedFile(completedId) + + if (downloadedUri == null) { + Toast.makeText( + this@WalletActivity, + "Downloaded update could not be opened", + Toast.LENGTH_LONG + ).show() + return + } + + val expectedSha256 = + pendingUpdateSha256?.trim()?.lowercase() + + if ( + expectedSha256.isNullOrBlank() || + !verifyDownloadedUpdate( + downloadedUri, + expectedSha256 + ) + ) { + manager.remove(completedId) + pendingUpdateUri = null + pendingUpdateSha256 = null + + AlertDialog.Builder(this@WalletActivity) + .setTitle("Update verification failed") + .setMessage( + "The downloaded APK does not match the " + + "official SHA256 checksum and was deleted. " + + "The update will not be installed." + ) + .setPositiveButton("Close", null) + .show() + + return + } + + pendingUpdateUri = downloadedUri + openDownloadedUpdate() + } + } + } + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + + createPaymentNotificationChannel() + requestNotificationPermission() + + val filter = IntentFilter( + DownloadManager.ACTION_DOWNLOAD_COMPLETE + ) + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) { + registerReceiver( + updateReceiver, + filter, + Context.RECEIVER_NOT_EXPORTED + ) + } else { + @Suppress("DEPRECATION") + registerReceiver(updateReceiver, filter) + } + + if (walletExists()) { + showMainWallet() + } else { + showWelcome() + } + + checkForUpdates() + } + + override fun onResume() { + super.onResume() + + if ( + Build.VERSION.SDK_INT < Build.VERSION_CODES.O || + packageManager.canRequestPackageInstalls() + ) { + if (pendingUpdateUri != null) { + openDownloadedUpdate() + } + } + + if ( + walletExists() && + mainWalletVisible && + !blockchainScanRunning + ) { + window.decorView.postDelayed({ + if ( + !isFinishing && + !isDestroyed && + mainWalletVisible && + !blockchainScanRunning + ) { + startHeaderSyncAndScan() + } + }, 400L) + } + } + + override fun onDestroy() { + refreshHandler.removeCallbacks(refreshRunnable) + + try { + unregisterReceiver(updateReceiver) + } catch (_: IllegalArgumentException) { + } + + super.onDestroy() + } + + private fun createPaymentNotificationChannel() { + val manager = + getSystemService( + Context.NOTIFICATION_SERVICE + ) as NotificationManager + + val channel = NotificationChannel( + PAYMENT_CHANNEL_ID, + "Incoming VTX payments", + NotificationManager.IMPORTANCE_HIGH + ).apply { + description = + "Notifications when new confirmed VTX payments arrive" + enableVibration(true) + } + + manager.createNotificationChannel(channel) + } + + private fun requestNotificationPermission() { + if ( + Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && + checkSelfPermission( + Manifest.permission.POST_NOTIFICATIONS + ) != PackageManager.PERMISSION_GRANTED + ) { + requestPermissions( + arrayOf(Manifest.permission.POST_NOTIFICATIONS), + REQUEST_NOTIFICATIONS + ) + } + } + + private fun updateBalanceAndNotify( + confirmedBalanceSatoshis: Long + ) { + val preferences = + getSharedPreferences(PREFS, Context.MODE_PRIVATE) + + val initialized = preferences.getBoolean( + PREF_BALANCE_INITIALIZED, + false + ) + + val previousBalance = preferences.getLong( + PREF_LAST_CONFIRMED_BALANCE, + confirmedBalanceSatoshis + ) + + preferences.edit() + .putBoolean(PREF_BALANCE_INITIALIZED, true) + .putLong( + PREF_LAST_CONFIRMED_BALANCE, + confirmedBalanceSatoshis + ) + .apply() + + if ( + !initialized || + confirmedBalanceSatoshis <= previousBalance + ) { + return + } + + val receivedSatoshis = + confirmedBalanceSatoshis - previousBalance + + showIncomingPaymentNotification(receivedSatoshis) + } + + private fun showIncomingPaymentNotification( + receivedSatoshis: Long + ) { + if ( + Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && + checkSelfPermission( + Manifest.permission.POST_NOTIFICATIONS + ) != PackageManager.PERMISSION_GRANTED + ) { + return + } + + val amount = String.format( + "%.8f", + receivedSatoshis.toDouble() / 100_000_000.0 + ) + + val openWalletIntent = Intent( + this, + WalletActivity::class.java + ).apply { + flags = + Intent.FLAG_ACTIVITY_CLEAR_TOP or + Intent.FLAG_ACTIVITY_SINGLE_TOP + } + + val pendingIntent = PendingIntent.getActivity( + this, + 0, + openWalletIntent, + PendingIntent.FLAG_UPDATE_CURRENT or + PendingIntent.FLAG_IMMUTABLE + ) + + val notification = Notification.Builder( + this, + PAYMENT_CHANNEL_ID + ) + .setSmallIcon(android.R.drawable.stat_notify_more) + .setContentTitle("VTX payment received") + .setContentText("$amount VTX has been confirmed") + .setStyle( + Notification.BigTextStyle().bigText( + "A payment of $amount VTX was received " + + "and confirmed in your Vexta Wallet." + ) + ) + .setContentIntent(pendingIntent) + .setAutoCancel(true) + .setCategory(Notification.CATEGORY_MESSAGE) + .build() + + val manager = + getSystemService( + Context.NOTIFICATION_SERVICE + ) as NotificationManager + + manager.notify( + (System.currentTimeMillis() and 0x7fffffff).toInt(), + notification + ) + } + + private fun checkForUpdates() { + Thread { + try { + val connection = ( + URL(UPDATE_URL).openConnection() + as HttpURLConnection + ).apply { + connectTimeout = 8000 + readTimeout = 8000 + requestMethod = "GET" + useCaches = false + } + + val responseCode = connection.responseCode + + if (responseCode !in 200..299) { + connection.disconnect() + return@Thread + } + + val response = connection.inputStream + .bufferedReader() + .use { it.readText() } + + connection.disconnect() + + val json = JSONObject(response) + val latestCode = json.getLong("versionCode") + val latestName = json.optString( + "versionName", + latestCode.toString() + ) + val apkUrl = json.optString( + "apkUrl", + json.optString("downloadUrl") + ) + + require(apkUrl.isNotBlank()) { + "Missing update download URL" + } + val sha256 = json.getString("sha256") + .trim() + .lowercase() + + require( + sha256.matches(Regex("^[0-9a-f]{64}$")) + ) { + "Invalid update SHA256" + } + + val notes = json.optString( + "notes", + json.optString( + "releaseNotes", + "A new Vexta Wallet version is available." + ) + ) + + val currentCode = if ( + Build.VERSION.SDK_INT >= Build.VERSION_CODES.P + ) { + packageManager.getPackageInfo( + packageName, + 0 + ).longVersionCode + } else { + @Suppress("DEPRECATION") + packageManager.getPackageInfo( + packageName, + 0 + ).versionCode.toLong() + } + + if (latestCode <= currentCode) { + return@Thread + } + + runOnUiThread { + if (isFinishing || isDestroyed) { + return@runOnUiThread + } + + AlertDialog.Builder(this) + .setTitle("Wallet update available") + .setMessage( + "Version $latestName is available.\n\n" + + notes + ) + .setNegativeButton("Later", null) + .setPositiveButton("Update") { _, _ -> + downloadUpdate( + apkUrl, + latestName, + sha256 + ) + } + .show() + } + } catch (_: Exception) { + // Update checks must never prevent wallet startup. + } + }.start() + } + + private fun downloadUpdate( + apkUrl: String, + versionName: String, + expectedSha256: String + ) { + try { + val manager = getSystemService( + DOWNLOAD_SERVICE + ) as DownloadManager + + val request = DownloadManager.Request( + Uri.parse(apkUrl) + ).apply { + setTitle("Vexta Wallet $versionName") + setDescription("Downloading wallet update") + setMimeType( + "application/vnd.android.package-archive" + ) + setNotificationVisibility( + DownloadManager.Request + .VISIBILITY_VISIBLE_NOTIFY_COMPLETED + ) + setAllowedOverMetered(true) + setAllowedOverRoaming(false) + setDestinationInExternalFilesDir( + this@WalletActivity, + Environment.DIRECTORY_DOWNLOADS, + "vexta-wallet-update.apk" + ) + } + + pendingUpdateSha256 = + expectedSha256.trim().lowercase() + pendingUpdateUri = null + + updateDownloadId = manager.enqueue(request) + + Toast.makeText( + this, + "Downloading wallet update", + Toast.LENGTH_LONG + ).show() + } catch (error: Exception) { + Toast.makeText( + this, + "Could not start update: ${error.message}", + Toast.LENGTH_LONG + ).show() + } + } + + private fun verifyDownloadedUpdate( + apkUri: Uri, + expectedSha256: String + ): Boolean { + return try { + val digest = MessageDigest.getInstance("SHA-256") + + contentResolver.openInputStream(apkUri)?.use { input -> + val buffer = ByteArray(64 * 1024) + + while (true) { + val count = input.read(buffer) + + if (count < 0) { + break + } + + if (count > 0) { + digest.update(buffer, 0, count) + } + } + } ?: return false + + val actualSha256 = digest.digest() + .joinToString("") { + "%02x".format(it.toInt() and 0xff) + } + + actualSha256.equals( + expectedSha256, + ignoreCase = true + ) + } catch (_: Exception) { + false + } + } + + private fun openDownloadedUpdate() { + val apkUri = pendingUpdateUri ?: return + + if ( + Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && + !packageManager.canRequestPackageInstalls() + ) { + AlertDialog.Builder(this) + .setTitle("Allow wallet updates") + .setMessage( + "Android must allow Vexta Wallet to install " + + "updates. Enable “Allow from this source”, " + + "then return to the wallet." + ) + .setNegativeButton("Cancel", null) + .setPositiveButton("Open settings") { _, _ -> + startActivity( + Intent( + Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES, + Uri.parse("package:$packageName") + ) + ) + } + .show() + + return + } + + val installIntent = Intent( + Intent.ACTION_VIEW + ).apply { + setDataAndType( + apkUri, + "application/vnd.android.package-archive" + ) + addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) + addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + } + + try { + startActivity(installIntent) + pendingUpdateUri = null + pendingUpdateSha256 = null + } catch (error: Exception) { + Toast.makeText( + this, + "Could not open update installer: ${error.message}", + Toast.LENGTH_LONG + ).show() + } + } + + private fun startHeaderSyncAndScan() { + if (blockchainScanRunning) { + return + } + + blockchainScanRunning = true + + blockchainScanStatus?.text = + "Synchronizing block headers..." + + startActivityForResult( + Intent( + this, + MainActivity::class.java + ).putExtra("sync_only", true), + REQUEST_HEADER_SYNC + ) + + overridePendingTransition(0, 0) + } + + override fun onActivityResult( + requestCode: Int, + resultCode: Int, + data: Intent? + ) { + if (requestCode == REQUEST_HEADER_SYNC) { + overridePendingTransition(0, 0) + + if (resultCode == RESULT_OK) { + val height = data?.getIntExtra( + "verified_height", + -1 + ) ?: -1 + + blockchainScanStatus?.text = if (height >= 0) { + "Headers synchronized to block $height.\n" + + "Scanning compact filters..." + } else { + "Headers synchronized.\n" + + "Scanning compact filters..." + } + + runBlockchainScan() + } else { + blockchainScanRunning = false + blockchainScanStatus?.text = + "Block-header synchronization failed." + } + + return + } + + super.onActivityResult(requestCode, resultCode, data) + } + + private fun currentReceiveAddressIndex(): Int { + return getSharedPreferences(PREFS, MODE_PRIVATE) + .getInt(PREF_RECEIVE_ADDRESS_INDEX, 0) + .coerceAtLeast(0) + } + + private fun setCurrentReceiveAddressIndex(index: Int) { + getSharedPreferences(PREFS, MODE_PRIVATE) + .edit() + .putInt(PREF_RECEIVE_ADDRESS_INDEX, index.coerceAtLeast(0)) + .apply() + } + + private fun runBlockchainScan() { + Thread { + try { + val words = loadMnemonic() + .trim() + .split(Regex("\\s+")) + + val preferences = + getSharedPreferences(PREFS, MODE_PRIVATE) + val restoreAddressDiscovery = + preferences.getBoolean( + PREF_RESTORE_ADDRESS_DISCOVERY, + false + ) + val highestAddressIndex = + if (restoreAddressDiscovery) { + maxOf( + currentReceiveAddressIndex(), + RESTORE_ADDRESS_LOOKAHEAD + ) + } else { + currentReceiveAddressIndex() + } + + var highestUsedAddressIndex = -1 + + val allUtxos = + mutableListOf() + val allTransactions = + mutableListOf() + + var totalFiltersScanned = 0 + var totalRelevantBlocks = 0 + var totalReceivedTransactions = 0 + var totalSpentTransactions = 0 + + for (addressIndex in 0..highestAddressIndex) { + val scriptPubKey = + deriveWitnessScript(words, addressIndex) + + runOnUiThread { + blockchainScanStatus?.text = + "Scanning address " + + "${addressIndex + 1} of " + + "${highestAddressIndex + 1}..." + } + + val filterResult = CompactFilterClient.scan( + this@WalletActivity, + "87.106.99.23", + scriptPubKey + ) { scanned, total -> + runOnUiThread { + blockchainScanStatus?.text = + "Address ${addressIndex + 1}/" + + "${highestAddressIndex + 1}\n" + + "Scanning compact filters: " + + "$scanned / $total" + } + } + + totalFiltersScanned += + filterResult.scannedFilters + + val blockResult = BlockScanner.scan( + this@WalletActivity, + "87.106.99.23", + filterResult.matchingHeights, + scriptPubKey, + addressIndex + ) { downloaded, total -> + runOnUiThread { + blockchainScanStatus?.text = + "Address ${addressIndex + 1}/" + + "${highestAddressIndex + 1}\n" + + "Relevant blocks downloaded: " + + "$downloaded / $total" + } + } + + allUtxos.addAll(blockResult.utxos) + allTransactions.addAll( + blockResult.transactions + ) + + if ( + blockResult.receivedTransactions > 0 || + blockResult.spentTransactions > 0 || + blockResult.transactions.isNotEmpty() + ) { + highestUsedAddressIndex = addressIndex + } + + totalRelevantBlocks += + blockResult.downloadedBlocks + totalReceivedTransactions += + blockResult.receivedTransactions + totalSpentTransactions += + blockResult.spentTransactions + } + + val mergedTransactions = + allTransactions + .groupBy { it.txid } + .map { (_, transactions) -> + BlockScanner.WalletTransaction( + txid = transactions.first().txid, + height = transactions.maxOf { + it.height + }, + netSatoshis = transactions.sumOf { + it.netSatoshis + } + ) + } + .filter { it.netSatoshis != 0L } + .sortedWith( + compareByDescending< + BlockScanner.WalletTransaction + > { + it.height + }.thenByDescending { + it.txid + } + ) + + val mergedUtxos = + allUtxos + .distinctBy { + "${it.txid}:${it.outputIndex}" + } + .sortedWith( + compareBy { + it.height + }.thenBy { + it.txid + }.thenBy { + it.outputIndex + } + ) + + val balanceSatoshis = + mergedUtxos.sumOf { it.value } + + val balanceText = String.format( + "%.8f VTX", + balanceSatoshis.toDouble() / + 100_000_000.0 + ) + + updateBalanceAndNotify(balanceSatoshis) + + if (restoreAddressDiscovery) { + setCurrentReceiveAddressIndex( + highestUsedAddressIndex.coerceAtLeast(0) + ) + preferences.edit() + .putBoolean( + PREF_RESTORE_ADDRESS_DISCOVERY, + false + ) + .apply() + } + + runOnUiThread { + latestSpendableUtxos = mergedUtxos + latestWalletTransactions = + mergedTransactions + + walletBalanceView?.text = balanceText + walletHistoryView?.text = + formatTransactionHistory( + mergedTransactions, + limit = 3, + showFullTxid = false + ) + + if (transactionHistoryVisible) { + showTransactionHistory() + } + + blockchainScanStatus?.text = + "Addresses scanned: " + + "${highestAddressIndex + 1}\n" + + "Filters scanned: $totalFiltersScanned\n" + + "Relevant blocks: $totalRelevantBlocks\n" + + "Received transactions: " + + "$totalReceivedTransactions\n" + + "Spent transactions: " + + "$totalSpentTransactions\n" + + "Unspent outputs: " + + "${mergedUtxos.size}\n" + + "Verified balance: $balanceText" + } + } catch (e: Exception) { + runOnUiThread { + blockchainScanStatus?.text = + "Blockchain scan failed:\n" + + (e.message ?: e.javaClass.simpleName) + } + } finally { + runOnUiThread { + blockchainScanRunning = false + } + } + }.start() + } + + private fun formatTransactionHistory( + transactions: List, + limit: Int, + showFullTxid: Boolean + ): String { + if (transactions.isEmpty()) { + return "No confirmed transactions yet" + } + + return transactions + .take(limit) + .joinToString("\n\n") { transaction -> + val received = transaction.netSatoshis > 0L + val amount = String.format( + "%.8f", + kotlin.math.abs( + transaction.netSatoshis + ).toDouble() / 100_000_000.0 + ) + + val direction = + if (received) "Received" else "Sent" + + val sign = + if (received) "+" else "-" + + val txidText = + if (showFullTxid) { + transaction.txid + } else { + transaction.txid.take(12) + + "..." + + transaction.txid.takeLast(12) + } + + "$direction $sign$amount VTX\n" + + "Block ${transaction.height}\n" + + txidText + } + } + + private fun showTransactionHistory() { + mainWalletVisible = false + transactionHistoryVisible = true + + val filteredTransactions = + when (transactionHistoryFilter) { + "RECEIVED" -> latestWalletTransactions.filter { + it.netSatoshis > 0L + } + + "SENT" -> latestWalletTransactions.filter { + it.netSatoshis < 0L + } + + else -> latestWalletTransactions + } + + val displayedTransactions = + filteredTransactions.take(transactionHistoryLimit) + + val content = baseLayout() + + content.addView(space(10)) + content.addView(centeredLogo(64)) + content.addView(space(14)) + content.addView(title("Transaction history")) + content.addView( + subtitle( + "Confirmed received and sent VTX payments" + ) + ) + content.addView(space(20)) + + content.addView( + card { + addView(sectionTitle("Filter")) + addView(space(12)) + + val filterRow = LinearLayout( + this@WalletActivity + ).apply { + orientation = LinearLayout.HORIZONTAL + gravity = Gravity.CENTER + layoutParams = LinearLayout.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT + ) + } + + fun filterButton( + label: String, + filter: String + ): Button { + val selected = + transactionHistoryFilter == filter + + return Button( + this@WalletActivity + ).apply { + text = label + isAllCaps = false + textSize = 14f + typeface = Typeface.DEFAULT_BOLD + setTextColor(Color.WHITE) + setPadding( + dp(8), + dp(10), + dp(8), + dp(10) + ) + background = roundedDrawable( + if (selected) { + accentColor + } else { + surfaceColorAlt + }, + 14 + ) + setOnClickListener { + transactionHistoryFilter = filter + transactionHistoryLimit = 50 + showTransactionHistory() + } + layoutParams = + LinearLayout.LayoutParams( + 0, + ViewGroup.LayoutParams.WRAP_CONTENT, + 1f + ).apply { + marginEnd = dp(5) + } + } + } + + filterRow.addView( + filterButton("All", "ALL") + ) + filterRow.addView( + filterButton("Received", "RECEIVED") + ) + filterRow.addView( + filterButton("Sent", "SENT") + ) + + addView(filterRow) + } + ) + + content.addView(space(16)) + + content.addView( + card { + addView( + sectionTitle( + when (transactionHistoryFilter) { + "RECEIVED" -> "Received payments" + "SENT" -> "Sent payments" + else -> "All transactions" + } + ) + ) + addView(space(10)) + + addView( + smallStatus( + formatTransactionHistory( + displayedTransactions, + limit = displayedTransactions.size, + showFullTxid = true + ) + ).apply { + gravity = Gravity.START + setTextIsSelectable(true) + } + ) + + if ( + filteredTransactions.size > + displayedTransactions.size + ) { + addView(space(16)) + addView( + secondaryButton("Load more") { + transactionHistoryLimit += 50 + showTransactionHistory() + } + ) + addView(space(8)) + addView( + helpText( + "Showing ${displayedTransactions.size} of " + + "${filteredTransactions.size}" + ) + ) + } else if (filteredTransactions.isNotEmpty()) { + addView(space(10)) + addView( + helpText( + "${filteredTransactions.size} transaction" + + if ( + filteredTransactions.size == 1 + ) { + "" + } else { + "s" + } + ) + ) + } + } + ) + + content.addView(space(20)) + content.addView( + primaryButton("Back to wallet") { + showMainWallet() + } + ) + + setContentView(scroll(content)) + } + + private fun currentVersionName(): String { + return try { + packageManager.getPackageInfo( + packageName, + 0 + ).versionName ?: "unknown" + } catch (_: Exception) { + "unknown" + } + } + + private fun showAboutDialog() { + val message = + "Vexta Wallet\n" + + "Version ${currentVersionName()}\n\n" + + "Developed for the Vexta Project\n" + + "© 2026 Vexta Project\n\n" + + "Website: vextaproject.org\n" + + "Support: discord.gg/zzpm7ghN3e\n\n" + + "Vexta Wallet is a non-custodial wallet. " + + "Your recovery phrase is stored locally and encrypted " + + "using Android Keystore. Keep your recovery phrase secure. " + + "Lost recovery phrases cannot be recovered.\n\n" + + "Open-source components:\n" + + "• bitcoinj — Apache License 2.0\n" + + "• ZXing — Apache License 2.0\n" + + "• Google ML Kit Code Scanner — Google API terms" + + AlertDialog.Builder(this) + .setTitle("About & Licences") + .setMessage(message) + .setPositiveButton("Close", null) + .show() + } + + private fun showWelcome() { + window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE) + + val content = baseLayout() + + content.addView(space(12)) + content.addView(centeredLogo(86)) + content.addView(space(18)) + content.addView(title("Vexta Wallet")) + content.addView( + subtitle( + "Lightweight Android wallet for Vexta mainnet\n" + + "SPV headers, compact filters and secure local seed storage" + ) + ) + content.addView(space(24)) + + content.addView( + card { + addView(sectionTitle("Get started")) + addView(space(10)) + addView(primaryButton("Create new wallet") { + createNewWallet() + }) + addView(space(12)) + addView(secondaryButton("Restore from 12 words") { + showRestoreDialog() + }) + } + ) + + setContentView(scroll(content)) + } + + private fun createNewWallet() { + val entropy = ByteArray(16) + SecureRandom().nextBytes(entropy) + + val words = MnemonicCode.INSTANCE.toMnemonic(entropy) + saveMnemonic(words.joinToString(" ")) + + getSharedPreferences(PREFS, MODE_PRIVATE) + .edit() + .putBoolean(PREF_BACKUP_CONFIRMED, false) + .apply() + + showSeedBackup(words) + } + + private fun showSeedBackup(words: List) { + window.addFlags(WindowManager.LayoutParams.FLAG_SECURE) + + val content = baseLayout() + content.addView(space(12)) + content.addView(centeredLogo(72)) + content.addView(space(16)) + content.addView(title("Recovery phrase")) + content.addView( + subtitle( + "Write these 12 words down in the correct order.\n" + + "Anyone with these words can control your VTX." + ) + ) + content.addView(space(22)) + + content.addView( + card { + addView(sectionTitle("Your 12 words")) + addView(space(14)) + + addView( + infoBox( + words.mapIndexed { index, word -> + "${index + 1}. $word" + }.joinToString("\n"), + 19f, + Gravity.START + ) + ) + } + ) + + content.addView(space(20)) + content.addView( + primaryButton("I have written it down") { + getSharedPreferences(PREFS, MODE_PRIVATE) + .edit() + .putBoolean(PREF_BACKUP_CONFIRMED, true) + .apply() + + window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE) + showMainWallet() + } + ) + + setContentView(scroll(content)) + } + + private fun showMainWallet() { + transactionHistoryVisible = false + mainWalletVisible = true + window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE) + + val mnemonic = try { + loadMnemonic() + } catch (e: Exception) { + showFatalError("Unable to decrypt wallet: ${e.message}") + return + } + + if (mnemonic.isBlank()) { + showWelcome() + return + } + + val words = mnemonic.split(" ") + val addressIndex = currentReceiveAddressIndex() + val address = deriveAddress(words, addressIndex) + + val content = baseLayout() + val balanceView = headlineValue("0.00000000 VTX") + walletBalanceView = balanceView + val compactFilterStatus = smallStatus("Compact filters: checking peers...") + val scanStatus = smallStatus("Wallet scan: not started") + val historyView = smallStatus("No confirmed transactions yet") + + blockchainScanStatus = scanStatus + walletHistoryView = historyView + + content.addView(space(4)) + content.addView(centeredLogo(76)) + content.addView(space(10)) + content.addView(title("Vexta Wallet")) + content.addView( + subtitle("Your gateway to the Vexta network") + ) + content.addView(space(20)) + + content.addView( + balanceCard { + addView( + TextView(this@WalletActivity).apply { + text = "TOTAL BALANCE" + textSize = 12f + letterSpacing = 0.18f + setTextColor(textSecondary) + typeface = Typeface.DEFAULT_BOLD + gravity = Gravity.CENTER + } + ) + addView(space(12)) + addView(balanceView) + addView(space(8)) + addView( + TextView(this@WalletActivity).apply { + text = "VEXTA MAINNET" + textSize = 11f + letterSpacing = 0.12f + setTextColor(accentColor) + gravity = Gravity.CENTER + typeface = Typeface.DEFAULT_BOLD + } + ) + addView(space(12)) + addView( + helpText( + "Verified through compact filters and relevant blocks" + ) + ) + } + ) + + content.addView(space(16)) + + content.addView( + card { + addView(sectionTitle("Quick actions")) + addView(space(14)) + + val actionRow = LinearLayout( + this@WalletActivity + ).apply { + orientation = LinearLayout.HORIZONTAL + gravity = Gravity.CENTER + layoutParams = LinearLayout.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT + ) + } + + actionRow.addView( + compactActionButton( + symbol = "↑", + label = "Send" + ) { + showSend(address) + } + ) + + actionRow.addView( + compactActionButton( + symbol = "↓", + label = "Receive" + ) { + showReceive() + } + ) + + actionRow.addView( + compactActionButton( + symbol = "↻", + label = "Scan" + ) { + startHeaderSyncAndScan() + } + ) + + addView(actionRow) + } + ) + + content.addView(space(16)) + + content.addView( + card { + addView(sectionTitle("Recent transactions")) + addView(space(10)) + addView(historyView) + addView(space(12)) + addView(secondaryButton("View all transactions") { + showTransactionHistory() + }) + addView(space(8)) + addView( + helpText( + "The three most recent confirmed transactions" + ) + ) + } + ) + + content.addView(space(16)) + + content.addView( + card { + addView(sectionTitle("Status")) + addView(space(10)) + addView(compactFilterStatus) + addView(space(12)) + addView(scanStatus) + addView(space(12)) + addView(helpText("Wallet data is encrypted with Android Keystore")) + } + ) + + content.addView(space(16)) + + content.addView( + card { + addView(sectionTitle("Security")) + addView(space(12)) + addView(secondaryButton("Show recovery phrase") { + confirmShowSeed() + }) + addView(space(10)) + addView(secondaryButton("About & Licences") { + showAboutDialog() + }) + addView(space(10)) + addView(dangerButton("Delete wallet") { + confirmDeleteWallet() + }) + } + ) + + content.addView(space(22)) + content.addView( + smallStatus( + "Vexta Wallet v${currentVersionName()}\n" + + "© 2026 Vexta Project\n" + + "Non-custodial wallet" + ).apply { + gravity = Gravity.CENTER + } + ) + content.addView(space(12)) + + setContentView(scroll(content)) + + refreshHandler.removeCallbacks(refreshRunnable) + refreshHandler.postDelayed(refreshRunnable, 60_000L) + + automaticScanStarted = true + + window.decorView.postDelayed({ + if ( + !isFinishing && + !isDestroyed && + mainWalletVisible && + !blockchainScanRunning + ) { + startHeaderSyncAndScan() + } + }, 500L) + + + Thread { + val peers = listOf("87.106.99.23", "74.208.53.160") + val results = peers.map { peer -> + try { + CompactFilterClient.check(peer) + } catch (_: Exception) { + null + } + } + + runOnUiThread { + val successful = results.filterNotNull() + val supported = successful.count { + it.servicesCompactFilters && it.filterHashesReceived > 0 + } + + compactFilterStatus.text = + "Compact filters: $supported/${peers.size} peers ready" + + if (supported == peers.size) { + "\nBIP157 connection test: successful" + } else { + "\nBIP157 connection test: incomplete" + } + } + }.start() + } + + private fun showReceive() { + mainWalletVisible = false + window.clearFlags( + WindowManager.LayoutParams.FLAG_SECURE + ) + + val words = try { + loadMnemonic() + .trim() + .split(Regex("\\s+")) + } catch (error: Exception) { + showFatalError( + "Unable to load wallet: " + + (error.message ?: error.javaClass.simpleName) + ) + return + } + + val addressIndex = currentReceiveAddressIndex() + val address = deriveAddress(words, addressIndex) + + val content = baseLayout() + content.addView(space(10)) + content.addView(centeredLogo(72)) + content.addView(space(14)) + content.addView(title("Receive VTX")) + content.addView( + subtitle( + "Share this address or QR code to receive coins" + ) + ) + content.addView(space(20)) + + content.addView( + card { + addView( + sectionTitle( + "Receive address ${addressIndex + 1}" + ) + ) + addView(space(14)) + + addView( + ImageView(this@WalletActivity).apply { + setImageBitmap( + createQrBitmap( + "vexta:$address", + 720 + ) + ) + adjustViewBounds = true + setPadding( + dp(16), + dp(16), + dp(16), + dp(16) + ) + background = + roundedDrawable(Color.WHITE, 24) + layoutParams = + LinearLayout.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT + ) + } + ) + + addView(space(16)) + + val addressView = infoBox( + address, + 16f, + Gravity.CENTER + ).apply { + isClickable = true + isFocusable = true + + setOnClickListener { + val clipboard = getSystemService( + Context.CLIPBOARD_SERVICE + ) as ClipboardManager + + clipboard.setPrimaryClip( + ClipData.newPlainText( + "Vexta address", + address + ) + ) + + Toast.makeText( + this@WalletActivity, + "Address copied", + Toast.LENGTH_SHORT + ).show() + } + } + + addView(addressView) + addView(space(10)) + addView( + helpText( + "Tap the address to copy it" + ) + ) + } + ) + + content.addView(space(16)) + + content.addView( + card { + addView(sectionTitle("Address management")) + addView(space(12)) + addView( + secondaryButton("Generate new address") { + AlertDialog.Builder( + this@WalletActivity + ) + .setTitle("Generate new address?") + .setMessage( + "The current address will remain " + + "valid and the wallet will continue " + + "scanning it. A new address will be " + + "generated from the same recovery phrase." + ) + .setNegativeButton("Cancel", null) + .setPositiveButton("Generate") { + _, _ -> + setCurrentReceiveAddressIndex( + addressIndex + 1 + ) + showReceive() + } + .show() + } + ) + addView(space(10)) + addView( + helpText( + "All previously generated addresses remain " + + "part of this wallet." + ) + ) + } + ) + + content.addView(space(20)) + content.addView( + primaryButton("Back to wallet") { + showMainWallet() + } + ) + + setContentView(scroll(content)) + } + + private fun waitForTransactionAcceptance( + txid: String, + attempts: Int = 20, + delayMilliseconds: Long = 1_000L + ): Boolean { + repeat(attempts) { attempt -> + var connection: java.net.HttpURLConnection? = null + + try { + val encodedTxid = + java.net.URLEncoder.encode(txid, "UTF-8") + + connection = + java.net.URL( + "https://vextaproject.org/explorer/api/tx/$encodedTxid" + ).openConnection() as java.net.HttpURLConnection + + connection.requestMethod = "GET" + connection.connectTimeout = 5_000 + connection.readTimeout = 5_000 + connection.useCaches = false + + if (connection.responseCode == 200) { + return true + } + } catch (_: Exception) { + } finally { + connection?.disconnect() + } + + if (attempt + 1 < attempts) { + Thread.sleep(delayMilliseconds) + } + } + + return false + } + + private fun showSend(fromAddress: String) { + mainWalletVisible = false + window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE) + + val recipientInput = inputField( + hint = "Recipient address (vtx1... or legacy V...)", + singleLine = false + ) + + sendRecipientInput = recipientInput + + val amountInput = inputField( + hint = "Amount in VTX", + singleLine = true, + inputType = InputType.TYPE_CLASS_NUMBER or + InputType.TYPE_NUMBER_FLAG_DECIMAL + ) + + val noteView = smallStatus( + "Payments are signed locally on this device and broadcast " + + "directly to the Vexta network." + ) + + val content = baseLayout() + content.addView(space(10)) + content.addView(centeredLogo(72)) + content.addView(space(14)) + content.addView(title("Send VTX")) + content.addView(subtitle("Create and broadcast a Vexta payment")) + content.addView(space(20)) + + content.addView( + card { + addView(sectionTitle("From")) + addView(space(10)) + addView(infoBox(fromAddress, 15f, Gravity.CENTER)) + } + ) + + content.addView(space(16)) + + content.addView( + card { + addView(sectionTitle("Payment details")) + addView(space(12)) + addView(recipientInput) + addView(space(10)) + + addView(secondaryButton("Scan QR code") { + val options = GmsBarcodeScannerOptions.Builder() + .setBarcodeFormats(Barcode.FORMAT_QR_CODE) + .enableAutoZoom() + .build() + + GmsBarcodeScanning + .getClient(this@WalletActivity, options) + .startScan() + .addOnSuccessListener { barcode -> + insertScannedAddress(barcode.rawValue) + } + .addOnCanceledListener { + Toast.makeText( + this@WalletActivity, + "QR scan cancelled", + Toast.LENGTH_SHORT + ).show() + } + .addOnFailureListener { error -> + Toast.makeText( + this@WalletActivity, + "QR scanner failed: ${error.message}", + Toast.LENGTH_LONG + ).show() + } + }) + + addView(space(12)) + addView(amountInput) + addView(space(14)) + addView(primaryButton("Review payment") { + if (sendInProgress) { + Toast.makeText( + this@WalletActivity, + "A transaction is already being sent", + Toast.LENGTH_LONG + ).show() + return@primaryButton + } + + val recipient = + recipientInput.text.toString().trim() + val amountText = + amountInput.text.toString().trim() + + if (recipient.isBlank()) { + Toast.makeText( + this@WalletActivity, + "Enter a Vexta recipient address", + Toast.LENGTH_LONG + ).show() + return@primaryButton + } + + val amountSatoshis = try { + BigDecimal(amountText) + .setScale(8, RoundingMode.UNNECESSARY) + .movePointRight(8) + .longValueExact() + } catch (_: Exception) { + Toast.makeText( + this@WalletActivity, + "Enter a valid amount with no more than 8 decimals", + Toast.LENGTH_LONG + ).show() + return@primaryButton + } + + if (amountSatoshis <= 0L) { + Toast.makeText( + this@WalletActivity, + "Amount must be greater than zero", + Toast.LENGTH_LONG + ).show() + return@primaryButton + } + + if (latestSpendableUtxos.isEmpty()) { + Toast.makeText( + this@WalletActivity, + "No verified spendable outputs are loaded. " + + "Return to the wallet and scan the blockchain.", + Toast.LENGTH_LONG + ).show() + return@primaryButton + } + + try { + val words = loadMnemonic() + .trim() + .split(Regex("\\s+")) + + val privateKeysByIndex = + latestSpendableUtxos + .map { it.addressIndex } + .distinct() + .associateWith { index -> + deriveWalletPrivateKey( + words, + index + ) + } + + val changePrivateKey = + deriveWalletPrivateKey( + words, + currentReceiveAddressIndex() + ) + + val changePubKeyHash = + Utils.sha256hash160( + changePrivateKey.pubKey + ) + + val transaction = + VextaTransactionSender.createAndSign( + spendableUtxos = + latestSpendableUtxos, + recipientAddress = recipient, + amountSatoshis = amountSatoshis, + privateKeysByIndex = + privateKeysByIndex, + changePubKeyHash = + changePubKeyHash + ) + + val amountDisplay = String.format( + "%.8f", + transaction.amount.toDouble() / + 100_000_000.0 + ) + + val feeDisplay = String.format( + "%.8f", + transaction.fee.toDouble() / + 100_000_000.0 + ) + + val changeDisplay = String.format( + "%.8f", + transaction.change.toDouble() / + 100_000_000.0 + ) + + AlertDialog.Builder(this@WalletActivity) + .setTitle("Confirm VTX payment") + .setMessage( + "Recipient:\n$recipient\n\n" + + "Amount: $amountDisplay VTX\n" + + "Network fee: $feeDisplay VTX\n" + + "Change: $changeDisplay VTX\n" + + "Inputs: ${transaction.inputCount}\n\n" + + "Check the recipient address carefully. " + + "Blockchain transactions cannot be reversed." + ) + .setNegativeButton("Cancel", null) + .setPositiveButton("Send") { _, _ -> + sendInProgress = true + noteView.text = + "Broadcasting transaction..." + + Thread { + try { + if ( + waitForTransactionAcceptance( + transaction.txid, + attempts = 1, + delayMilliseconds = 0L + ) + ) { + throw IllegalStateException( + "This transaction already exists. " + + "Wait for confirmation and refresh " + + "the wallet before sending again." + ) + } + + val peers = + VextaTransactionSender.broadcast( + transaction, + listOf( + "87.106.99.23", + "74.208.53.160" + ) + ) + + val accepted = + waitForTransactionAcceptance( + transaction.txid + ) + + runOnUiThread { + sendInProgress = false + latestSpendableUtxos = + latestSpendableUtxos.filterNot { + "${it.txid}:${it.outputIndex}" in + transaction.spentOutpoints + } + + noteView.text = + if (accepted) { + "Transaction accepted by the " + + "Vexta network.\nTXID:\n" + + transaction.txid + } else { + "Transaction submitted to " + + "$peers peer(s), but network " + + "acceptance could not yet be " + + "confirmed.\nTXID:\n" + + transaction.txid + } + + recipientInput.text.clear() + amountInput.text.clear() + + val rawTransactionHex = + transaction.rawTransaction + .joinToString("") { + "%02x".format( + it.toInt() and 0xff + ) + } + + AlertDialog.Builder( + this@WalletActivity + ) + .setTitle( + if (accepted) { + "Transaction accepted" + } else { + "Transaction broadcast" + } + ) + .setMessage( + "TXID:\n" + + transaction.txid + + if (accepted) { + "\n\nThe transaction was " + + "accepted by the Vexta " + + "network. Its inputs are now " + + "locked in this wallet until " + + "the next blockchain scan." + } else { + "\n\nThe transaction was sent " + + "to peers, but network " + + "acceptance could not yet " + + "be confirmed." + } + ) + .setNeutralButton( + "Copy raw TX" + ) { _, _ -> + val clipboard = + getSystemService( + Context + .CLIPBOARD_SERVICE + ) as ClipboardManager + + clipboard.setPrimaryClip( + ClipData.newPlainText( + "Vexta raw transaction", + rawTransactionHex + ) + ) + + Toast.makeText( + this@WalletActivity, + "Raw transaction copied", + Toast.LENGTH_LONG + ).show() + } + .setPositiveButton( + "OK", + null + ) + .show() + } + } catch (error: Exception) { + runOnUiThread { + sendInProgress = false + noteView.text = + "Transaction broadcast failed:\n" + + ( + error.message + ?: error.javaClass + .simpleName + ) + } + } + }.start() + } + .show() + } catch (error: Exception) { + Toast.makeText( + this@WalletActivity, + "Payment could not be prepared: " + + ( + error.message + ?: error.javaClass.simpleName + ), + Toast.LENGTH_LONG + ).show() + } + }) + } + ) + + content.addView(space(16)) + + content.addView( + card { + addView(sectionTitle("Status")) + addView(space(10)) + addView(noteView) + } + ) + + content.addView(space(20)) + content.addView(secondaryButton("Back to wallet") { + showMainWallet() + }) + + setContentView(scroll(content)) + } + + private fun insertScannedAddress(rawValue: String?) { + if (rawValue.isNullOrBlank()) { + Toast.makeText( + this, + "QR code is empty", + Toast.LENGTH_LONG + ).show() + return + } + + val value = rawValue.trim() + val extractedAddress = when { + value.startsWith("vexta:", true) -> { + value.substringAfter(":") + .substringBefore("?") + .trim() + } + else -> value + } + + val address = if ( + extractedAddress.startsWith("vtx1", true) + ) { + extractedAddress.lowercase() + } else { + extractedAddress + } + + if ( + address.startsWith("vtx1") || + address.startsWith("V") + ) { + sendRecipientInput?.setText(address) + + Toast.makeText( + this, + "Address inserted", + Toast.LENGTH_SHORT + ).show() + } else { + Toast.makeText( + this, + "QR code does not contain a Vexta address", + Toast.LENGTH_LONG + ).show() + } + } + + private fun showRestoreDialog() { + val input = EditText(this).apply { + hint = "Enter the 12 recovery words" + minLines = 5 + gravity = Gravity.TOP + setTextColor(textPrimary) + setHintTextColor(textSecondary) + setPadding(dp(16), dp(16), dp(16), dp(16)) + background = roundedDrawable(surfaceColor, 18) + inputType = + InputType.TYPE_CLASS_TEXT or + InputType.TYPE_TEXT_FLAG_MULTI_LINE or + InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS + } + + AlertDialog.Builder(this) + .setTitle("Restore Vexta Wallet") + .setMessage("Enter all 12 words separated by spaces.") + .setView(input) + .setNegativeButton("Cancel", null) + .setPositiveButton("Restore") { _, _ -> + restoreWallet(input.text.toString()) + } + .show() + } + + private fun restoreWallet(input: String) { + try { + val words = input + .trim() + .lowercase() + .split(Regex("\\s+")) + .filter { it.isNotBlank() } + + if (words.size != 12) { + throw IllegalArgumentException("Exactly 12 words are required") + } + + MnemonicCode.INSTANCE.check(words) + saveMnemonic(words.joinToString(" ")) + + getSharedPreferences(PREFS, MODE_PRIVATE) + .edit() + .putBoolean(PREF_BACKUP_CONFIRMED, true) + .putInt(PREF_RECEIVE_ADDRESS_INDEX, 0) + .putBoolean( + PREF_RESTORE_ADDRESS_DISCOVERY, + true + ) + .apply() + + Toast.makeText(this, "Wallet restored", Toast.LENGTH_LONG).show() + showMainWallet() + } catch (e: Exception) { + Toast.makeText( + this, + "Invalid recovery phrase: ${e.message}", + Toast.LENGTH_LONG + ).show() + } + } + + private fun confirmShowSeed() { + AlertDialog.Builder(this) + .setTitle("Security warning") + .setMessage( + "Never show your recovery phrase to anyone. " + + "Make sure nobody can see your screen." + ) + .setNegativeButton("Cancel", null) + .setPositiveButton("Show") { _, _ -> + val words = loadMnemonic().split(" ") + showSeedBackup(words) + } + .show() + } + + private fun confirmDeleteWallet() { + AlertDialog.Builder(this) + .setTitle("Delete wallet?") + .setMessage( + "This removes the encrypted seed from this phone. " + + "The wallet can only be recovered with its 12 words." + ) + .setNegativeButton("Cancel", null) + .setPositiveButton("Delete") { _, _ -> + getSharedPreferences(PREFS, MODE_PRIVATE) + .edit() + .clear() + .apply() + + showWelcome() + } + .show() + } + + private fun walletExists(): Boolean { + return getSharedPreferences(PREFS, MODE_PRIVATE) + .contains(PREF_CIPHERTEXT) + } + + private fun saveMnemonic(mnemonic: String) { + val cipher = Cipher.getInstance("AES/GCM/NoPadding") + cipher.init(Cipher.ENCRYPT_MODE, getOrCreateSecretKey()) + + val ciphertext = cipher.doFinal(mnemonic.toByteArray(Charsets.UTF_8)) + val prefs = getSharedPreferences(PREFS, MODE_PRIVATE) + + prefs.edit() + .putString( + PREF_CIPHERTEXT, + android.util.Base64.encodeToString( + ciphertext, + android.util.Base64.NO_WRAP + ) + ) + .putString( + PREF_IV, + android.util.Base64.encodeToString( + cipher.iv, + android.util.Base64.NO_WRAP + ) + ) + .apply() + } + + private fun loadMnemonic(): String { + val prefs = getSharedPreferences(PREFS, MODE_PRIVATE) + + val ciphertext = android.util.Base64.decode( + prefs.getString(PREF_CIPHERTEXT, "") ?: "", + android.util.Base64.NO_WRAP + ) + + val iv = android.util.Base64.decode( + prefs.getString(PREF_IV, "") ?: "", + android.util.Base64.NO_WRAP + ) + + val cipher = Cipher.getInstance("AES/GCM/NoPadding") + cipher.init( + Cipher.DECRYPT_MODE, + getOrCreateSecretKey(), + GCMParameterSpec(128, iv) + ) + + return cipher.doFinal(ciphertext).toString(Charsets.UTF_8) + } + + private fun getOrCreateSecretKey(): SecretKey { + val keyStore = KeyStore.getInstance("AndroidKeyStore").apply { + load(null) + } + + val existing = keyStore.getKey(KEY_ALIAS, null) + + if (existing is SecretKey) { + return existing + } + + val generator = KeyGenerator.getInstance( + KeyProperties.KEY_ALGORITHM_AES, + "AndroidKeyStore" + ) + + val specification = KeyGenParameterSpec.Builder( + KEY_ALIAS, + KeyProperties.PURPOSE_ENCRYPT or + KeyProperties.PURPOSE_DECRYPT + ) + .setBlockModes(KeyProperties.BLOCK_MODE_GCM) + .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE) + .setRandomizedEncryptionRequired(true) + .build() + + generator.init(specification) + return generator.generateKey() + } + + private fun deriveWalletPrivateKey( + words: List, + addressIndex: Int + ): ECKey { + MnemonicCode.INSTANCE.check(words) + + val seedBytes = MnemonicCode.toSeed(words, "") + val masterKey = + HDKeyDerivation.createMasterPrivateKey(seedBytes) + val hierarchy = DeterministicHierarchy(masterKey) + + val path = listOf( + ChildNumber(84, true), + ChildNumber(0, true), + ChildNumber(0, true), + ChildNumber.ZERO, + ChildNumber(addressIndex, false) + ) + + val deterministicKey = + hierarchy.get(path, true, true) + + return ECKey.fromPrivate( + deterministicKey.privKeyBytes, + true + ) + } + + private fun deriveWitnessScript( + words: List, + addressIndex: Int + ): ByteArray { + MnemonicCode.INSTANCE.check(words) + + val seedBytes = MnemonicCode.toSeed(words, "") + val masterKey = HDKeyDerivation.createMasterPrivateKey(seedBytes) + val hierarchy = DeterministicHierarchy(masterKey) + + val path = listOf( + ChildNumber(84, true), + ChildNumber(0, true), + ChildNumber(0, true), + ChildNumber.ZERO, + ChildNumber(addressIndex, false) + ) + + val deterministicKey = hierarchy.get(path, true, true) + val ecKey = ECKey.fromPrivate( + deterministicKey.privKeyBytes, + true + ) + + val pubKeyHash = Utils.sha256hash160(ecKey.pubKey) + return byteArrayOf(0x00, 0x14) + pubKeyHash + } + + private fun deriveAddress( + words: List, + addressIndex: Int + ): String { + MnemonicCode.INSTANCE.check(words) + + val seedBytes = MnemonicCode.toSeed(words, "") + val masterKey = HDKeyDerivation.createMasterPrivateKey(seedBytes) + val hierarchy = DeterministicHierarchy(masterKey) + + val path = listOf( + ChildNumber(84, true), + ChildNumber(0, true), + ChildNumber(0, true), + ChildNumber.ZERO, + ChildNumber(addressIndex, false) + ) + + val deterministicKey = hierarchy.get(path, true, true) + val ecKey = ECKey.fromPrivate( + deterministicKey.privKeyBytes, + true + ) + + val pubKeyHash = Utils.sha256hash160(ecKey.pubKey) + return encodeSegwitAddress("vtx", 0, pubKeyHash) + } + + private fun encodeSegwitAddress( + hrp: String, + witnessVersion: Int, + witnessProgram: ByteArray + ): String { + val data = mutableListOf() + data.add(witnessVersion) + data.addAll(convertBits(witnessProgram, 8, 5, true)) + + val checksum = createBech32Checksum(hrp, data) + val charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l" + + return hrp + "1" + + (data + checksum).joinToString("") { charset[it].toString() } + } + + private fun convertBits( + input: ByteArray, + fromBits: Int, + toBits: Int, + pad: Boolean + ): List { + var accumulator = 0 + var bits = 0 + val result = mutableListOf() + val maxValue = (1 shl toBits) - 1 + val maxAccumulator = (1 shl (fromBits + toBits - 1)) - 1 + + for (byte in input) { + val value = byte.toInt() and 0xff + accumulator = ((accumulator shl fromBits) or value) and maxAccumulator + bits += fromBits + + while (bits >= toBits) { + bits -= toBits + result.add((accumulator shr bits) and maxValue) + } + } + + if (pad && bits > 0) { + result.add((accumulator shl (toBits - bits)) and maxValue) + } + + return result + } + + private fun createBech32Checksum( + hrp: String, + data: List + ): List { + val values = expandBech32Hrp(hrp) + data + List(6) { 0 } + val polymod = bech32Polymod(values) xor 1 + + return (0 until 6).map { index -> + (polymod shr (5 * (5 - index))) and 31 + } + } + + private fun expandBech32Hrp(hrp: String): List { + return hrp.map { it.code shr 5 } + + listOf(0) + + hrp.map { it.code and 31 } + } + + private fun bech32Polymod(values: List): Int { + val generators = intArrayOf( + 0x3b6a57b2, + 0x26508e6d, + 0x1ea119fa, + 0x3d4233dd, + 0x2a1462b3 + ) + + var checksum = 1 + + for (value in values) { + val top = checksum ushr 25 + checksum = ((checksum and 0x1ffffff) shl 5) xor value + + for (index in 0..4) { + if (((top shr index) and 1) != 0) { + checksum = checksum xor generators[index] + } + } + } + + return checksum + } + + private fun createQrBitmap(value: String, size: Int): Bitmap { + val matrix = MultiFormatWriter().encode( + value, + BarcodeFormat.QR_CODE, + size, + size + ) + + val bitmap = Bitmap.createBitmap( + size, + size, + Bitmap.Config.RGB_565 + ) + + for (x in 0 until size) { + for (y in 0 until size) { + bitmap.setPixel( + x, + y, + if (matrix[x, y]) Color.BLACK else Color.WHITE + ) + } + } + + return bitmap + } + + private fun baseLayout(): LinearLayout { + return LinearLayout(this).apply { + orientation = LinearLayout.VERTICAL + gravity = Gravity.CENTER_HORIZONTAL + setPadding(dp(18), dp(52), dp(18), dp(28)) + setBackgroundColor(backgroundColor) + } + } + + private fun scroll(content: View): ScrollView { + return ScrollView(this).apply { + setBackgroundColor(backgroundColor) + addView(content) + } + } + + private fun centeredLogo(sizeDp: Int): ImageView { + return ImageView(this).apply { + setImageResource(R.drawable.vexta_logo) + adjustViewBounds = true + scaleType = ImageView.ScaleType.FIT_CENTER + layoutParams = LinearLayout.LayoutParams(dp(sizeDp), dp(sizeDp)).apply { + gravity = Gravity.CENTER_HORIZONTAL + } + } + } + + private fun card(build: LinearLayout.() -> Unit): LinearLayout { + return LinearLayout(this).apply { + orientation = LinearLayout.VERTICAL + setPadding(dp(18), dp(18), dp(18), dp(18)) + background = glassDrawable( + surfaceColor, + 24, + adjustAlpha(accentColor, 0.28f) + ) + elevation = dp(2).toFloat() + layoutParams = LinearLayout.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT + ) + build() + } + } + + private fun balanceCard( + build: LinearLayout.() -> Unit + ): LinearLayout { + return LinearLayout(this).apply { + orientation = LinearLayout.VERTICAL + gravity = Gravity.CENTER + setPadding(dp(22), dp(26), dp(22), dp(24)) + background = GradientDrawable( + GradientDrawable.Orientation.TL_BR, + intArrayOf( + Color.rgb(12, 47, 87), + Color.rgb(10, 27, 60), + Color.rgb(35, 20, 82) + ) + ).apply { + cornerRadius = dp(28).toFloat() + setStroke( + dp(1), + adjustAlpha(accentColor, 0.55f) + ) + } + elevation = dp(5).toFloat() + layoutParams = LinearLayout.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT + ) + build() + } + } + + private fun compactActionButton( + symbol: String, + label: String, + action: () -> Unit + ): LinearLayout { + return LinearLayout(this).apply { + orientation = LinearLayout.VERTICAL + gravity = Gravity.CENTER + setPadding(dp(8), dp(12), dp(8), dp(12)) + background = glassDrawable( + surfaceColorAlt, + 18, + adjustAlpha(accentColor, 0.35f) + ) + isClickable = true + isFocusable = true + setOnClickListener { action() } + + addView( + TextView(this@WalletActivity).apply { + text = symbol + textSize = 27f + setTextColor(accentColor) + gravity = Gravity.CENTER + typeface = Typeface.DEFAULT_BOLD + } + ) + + addView(space(5)) + + addView( + TextView(this@WalletActivity).apply { + text = label + textSize = 13f + setTextColor(textPrimary) + gravity = Gravity.CENTER + typeface = Typeface.DEFAULT_BOLD + } + ) + + layoutParams = LinearLayout.LayoutParams( + 0, + ViewGroup.LayoutParams.WRAP_CONTENT, + 1f + ).apply { + marginStart = dp(4) + marginEnd = dp(4) + } + } + } + + private fun title(value: String): TextView { + return TextView(this).apply { + text = value + textSize = 30f + letterSpacing = 0.02f + setTextColor(textPrimary) + gravity = Gravity.CENTER + typeface = Typeface.DEFAULT_BOLD + } + } + + private fun subtitle(value: String): TextView { + return TextView(this).apply { + text = value + textSize = 15f + setTextColor(textSecondary) + gravity = Gravity.CENTER + } + } + + private fun sectionTitle(value: String): TextView { + return TextView(this).apply { + text = value.uppercase() + textSize = 13f + letterSpacing = 0.12f + setTextColor(accentColor) + typeface = Typeface.DEFAULT_BOLD + gravity = Gravity.START + } + } + + private fun headlineValue(value: String): TextView { + return TextView(this).apply { + text = value + textSize = 36f + letterSpacing = 0.015f + setTextColor(textPrimary) + typeface = Typeface.DEFAULT_BOLD + gravity = Gravity.CENTER + } + } + + private fun helpText(value: String): TextView { + return TextView(this).apply { + text = value + textSize = 13f + setTextColor(textSecondary) + gravity = Gravity.CENTER + } + } + + private fun smallStatus(value: String): TextView { + return TextView(this).apply { + text = value + textSize = 15f + setTextColor(textPrimary) + gravity = Gravity.CENTER + } + } + + private fun infoBox( + value: String, + textSizeValue: Float, + gravityValue: Int + ): TextView { + return TextView(this).apply { + text = value + textSize = textSizeValue + setTextColor(textPrimary) + gravity = gravityValue + setPadding(dp(16), dp(16), dp(16), dp(16)) + background = roundedDrawable(surfaceColorAlt, 18) + setTextIsSelectable(true) + layoutParams = LinearLayout.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT + ) + } + } + + private fun inputField( + hint: String, + singleLine: Boolean, + inputType: Int = InputType.TYPE_CLASS_TEXT + ): EditText { + return EditText(this).apply { + this.hint = hint + this.inputType = inputType + this.isSingleLine = singleLine + setTextColor(textPrimary) + setHintTextColor(textSecondary) + setPadding(dp(16), dp(16), dp(16), dp(16)) + background = roundedDrawable(surfaceColorAlt, 18) + layoutParams = LinearLayout.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT + ) + } + } + + private fun primaryButton( + label: String, + action: () -> Unit + ): Button { + return styledButton( + label = label, + background = accentColor, + textColor = Color.WHITE, + action = action + ) + } + + private fun secondaryButton( + label: String, + action: () -> Unit + ): Button { + return styledButton( + label = label, + background = surfaceColorAlt, + textColor = Color.WHITE, + action = action + ) + } + + private fun dangerButton( + label: String, + action: () -> Unit + ): Button { + return styledButton( + label = label, + background = dangerColor, + textColor = Color.WHITE, + action = action + ) + } + + private fun styledButton( + label: String, + background: Int, + textColor: Int, + action: () -> Unit + ): Button { + return Button(this).apply { + text = label + isAllCaps = false + textSize = 16f + letterSpacing = 0.04f + typeface = Typeface.DEFAULT_BOLD + setTextColor(textColor) + setPadding(dp(16), dp(15), dp(16), dp(15)) + this.background = glassDrawable( + background, + 20, + adjustAlpha(Color.WHITE, 0.18f) + ) + elevation = dp(2).toFloat() + setOnClickListener { action() } + layoutParams = LinearLayout.LayoutParams( + ViewGroup.LayoutParams.MATCH_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT + ) + } + } + + private fun glassDrawable( + color: Int, + radiusDp: Int, + strokeColor: Int + ): GradientDrawable { + return GradientDrawable().apply { + shape = GradientDrawable.RECTANGLE + cornerRadius = dp(radiusDp).toFloat() + setColor(color) + setStroke(dp(1), strokeColor) + } + } + + private fun roundedDrawable( + color: Int, + radiusDp: Int + ): GradientDrawable { + return GradientDrawable().apply { + shape = GradientDrawable.RECTANGLE + cornerRadius = dp(radiusDp).toFloat() + setColor(color) + setStroke(dp(1), adjustAlpha(Color.WHITE, 0.08f)) + } + } + + private fun space(heightDp: Int): View { + return View(this).apply { + layoutParams = LinearLayout.LayoutParams( + 1, + dp(heightDp) + ) + } + } + + private fun dp(value: Int): Int { + return (value * resources.displayMetrics.density).toInt() + } + + private fun adjustAlpha(color: Int, factor: Float): Int { + val alpha = (Color.alpha(color) * factor).toInt() + return Color.argb(alpha, Color.red(color), Color.green(color), Color.blue(color)) + } + + private fun showFatalError(message: String) { + val content = baseLayout() + content.addView(space(20)) + content.addView(centeredLogo(72)) + content.addView(space(14)) + content.addView(title("Vexta Wallet")) + content.addView(space(20)) + content.addView( + card { + addView(sectionTitle("Error")) + addView(space(12)) + addView( + TextView(this@WalletActivity).apply { + text = message + textSize = 16f + setTextColor(Color.RED) + gravity = Gravity.CENTER + } + ) + addView(space(14)) + addView(dangerButton("Delete wallet data") { + getSharedPreferences(PREFS, MODE_PRIVATE) + .edit() + .clear() + .apply() + + showWelcome() + }) + } + ) + setContentView(scroll(content)) + } +} diff --git a/app/src/main/res/drawable-nodpi/vexta_logo.png b/app/src/main/res/drawable-nodpi/vexta_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..1f7f8045f48141a0560ed596ef19734f21cf0d00 GIT binary patch literal 124217 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

e$m0@->* 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 ik9o{v9`pE1$NvG{5y?@EG2I^k0000yLF literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable/vexta_icon_foreground.png b/app/src/main/res/drawable/vexta_icon_foreground.png new file mode 100644 index 0000000000000000000000000000000000000000..c69b0709597d761b300bcfed56b4aaf7fe2ccf3b GIT binary patch literal 126679 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%0ArX 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 + + + + diff --git a/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml new file mode 100644 index 0000000..bb89852 --- /dev/null +++ b/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.png b/app/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..04754fc1da531fc8c519bf3404399e2a5096e0c7 GIT binary patch literal 10310 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 YHxCOztf}qcSpWb407*qoM6N<$f`uWgrvLx| literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher_round.png b/app/src/main/res/mipmap-hdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..04754fc1da531fc8c519bf3404399e2a5096e0c7 GIT binary patch literal 10310 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 YHxCOztf}qcSpWb407*qoM6N<$f`uWgrvLx| literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher.png b/app/src/main/res/mipmap-mdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..3ebbd387a5633eaddf4d28396201338b81e83eba GIT binary patch literal 4961 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 U?Z-6LkN^Mx07*qoM6N<$f~qwdv;Y7A literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..bb80ea8b7d6a101a18bc28bc4bdd5a9615712328 GIT binary patch literal 17685 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 U?Z-6LkN^Mx07*qoM6N<$f~qwdv;Y7A literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/app/src/main/res/mipmap-xxhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..e382360d2abd271924b648a020cc2dd132df4635 GIT binary patch literal 37291 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 bw}k&6>IG9k%OYvi00000NkvXXu0mjfLs}C9 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..e382360d2abd271924b648a020cc2dd132df4635 GIT binary patch literal 37291 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 bw}k&6>IG9k%OYvi00000NkvXXu0mjfLs}C9 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..073325d43cbbe63086392d7b76a21817da0010bf GIT binary patch literal 63622 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..073325d43cbbe63086392d7b76a21817da0010bf GIT binary patch literal 63622 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/values/icon_colors.xml b/app/src/main/res/values/icon_colors.xml new file mode 100644 index 0000000..a522c20 --- /dev/null +++ b/app/src/main/res/values/icon_colors.xml @@ -0,0 +1,4 @@ + + + #051428 + diff --git a/app/src/main/res/values/styles.xml b/app/src/main/res/values/styles.xml new file mode 100644 index 0000000..a1fb1b5 --- /dev/null +++ b/app/src/main/res/values/styles.xml @@ -0,0 +1,22 @@ + + + + + + diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 index 0000000..cf37549 --- /dev/null +++ b/build.gradle.kts @@ -0,0 +1,3 @@ +plugins { + id("com.android.application") version "9.3.0" apply false +} diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..b1b8ef56b44f16b14dc800fa8103a6d89abb526f GIT binary patch literal 48462 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 R2np~f1o-$>Q}y+){|A@R9n$~+ literal 0 HcmV?d00001 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..a9db115 --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,9 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-9.6.1-bin.zip +networkTimeout=10000 +retries=0 +retryBackOffMs=500 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/gradlew b/gradlew new file mode 100755 index 0000000..249efbb --- /dev/null +++ b/gradlew @@ -0,0 +1,248 @@ +#!/bin/sh + +# +# Copyright © 2015 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# + +############################################################################## +# +# gradlew start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh gradlew +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..8508ef6 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,82 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem gradlew startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables, and ensure extensions are enabled +setlocal EnableExtensions + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +"%COMSPEC%" /c exit 1 + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +"%COMSPEC%" /c exit 1 + +:execute +@rem Setup the command line + + + +@rem Execute gradlew +@rem endlocal doesn't take effect until after the line is parsed and variables are expanded +@rem which allows us to clear the local environment before executing the java command +endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel + +:exitWithErrorLevel +@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts +"%COMSPEC%" /c exit %ERRORLEVEL% diff --git a/settings.gradle.kts b/settings.gradle.kts new file mode 100644 index 0000000..7af231e --- /dev/null +++ b/settings.gradle.kts @@ -0,0 +1,18 @@ +pluginManagement { + repositories { + google() + mavenCentral() + gradlePluginPortal() + } +} + +dependencyResolutionManagement { + repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) + repositories { + google() + mavenCentral() + } +} + +rootProject.name = "VextaWallet" +include(":app")