From dd060e65fedf2d3fdcadcab28f9747c2baa6afb7 Mon Sep 17 00:00:00 2001 From: Airpods69 Date: Sun, 5 Jul 2026 19:00:07 +0530 Subject: [PATCH 1/5] Seed cold-start UI from widget cache to fix 0-balance flash MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit On unlock, WalletViewModel.init now reads last-known balance, unlocked balance, and price from WidgetDataStore (the prefs file already written unconditionally on every kit emission for the home- screen widget) and seeds _walletState and _currentPrice synchronously, before the async kit init runs. Previously isLocked flipped synchronously on verifyPin, MainScreen composed off the default WalletState (balance 0, transactions [], NotSynced), and the real values only arrived once initializeWalletIfNeeded()'s coroutine completed and the kit emitted. Now the first frame shows the cached balance/price with a Connecting sync state (spinner instead of the wrong "No transactions yet" card), and the kit's live emissions overwrite them on reconnect. Transactions are not seeded: the widget cache stores them as dir|amount|timestamp with no hash/confirmations, so reconstructing them would break tx detail navigation. The Connecting seed makes the empty card show the spinner instead. No widget required — the saves were already unconditional; only the reads are new. --- .../moneroone/core/wallet/WalletViewModel.kt | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt b/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt index d921bae..7bea75f 100644 --- a/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt +++ b/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt @@ -119,6 +119,7 @@ class WalletViewModel(application: Application) : AndroidViewModel(application) // Defer price fetch until a wallet exists. Avoids leaking IP to // monero.one before the user has generated/restored a key. if (_walletState.value.hasWallet) { + seedFromWidgetCache() fetchPrice() } checkAndApplyAutoLock() @@ -130,6 +131,26 @@ class WalletViewModel(application: Application) : AndroidViewModel(application) _selectedCurrency.value = Currency.entries.find { it.code == currencyCode } ?: Currency.USD } + // ponytail: seed last-known state from the widget cache to mask the cold-start + // 0-balance flash. Kit's live emissions overwrite these on reconnect. + private fun seedFromWidgetCache() { + _walletState.update { + it.copy( + balance = Balance(WidgetDataStore.getBalance(context), WidgetDataStore.getUnlockedBalance(context)), + // Connecting (not the cached status) so the empty-tx card shows the + // spinner instead of "No transactions yet" while the kit loads. + syncState = SyncState.Connecting(waiting = false) + ) + } + val cachedPrice = WidgetDataStore.getPrice(context) + if (cachedPrice > 0f) { + _currentPrice.value = CurrentPrice( + price = cachedPrice.toDouble(), + change24h = WidgetDataStore.getChange24h(context).toDouble() + ) + } + } + fun checkAndApplyAutoLock() { val prefs = context.getSharedPreferences("monero_wallet", Context.MODE_PRIVATE) val backgroundTimestamp = prefs.getLong("background_timestamp", 0) From f11b91c30a9cf59a6fac177a1e11eaedead3903f Mon Sep 17 00:00:00 2001 From: Airpods69 Date: Mon, 6 Jul 2026 01:00:11 +0530 Subject: [PATCH 2/5] Seed cold-start transaction list from widget cache (KISS path) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Extends the widget tx cache format from dir|amount|timestamp to dir|amount|timestamp|hash and bumps the stored count from 4 to 50 (the widget still reads only 4 via parseTxData.take(4); the extra entries seed the in-app transaction list during cold start). seedFromWidgetCache now parses the cache back into TransactionInfo and seeds _walletState.transactions, so WalletScreen's recent activity and TransactionListScreen show last-known txs immediately on unlock instead of the empty spinner. The kit's live emissions overwrite them on reconnect. confirmations forced to 10 (Confirmed) — cached txs are virtually always old & confirmed; a genuinely pending tx self-corrects when the kit emits. fee/blockheight default to 0, so the detail screen shows "Fee 0 / Pending" briefly if a tx is tapped before the kit loads (the accepted tradeoff for not marshalling every field). Parser extracted to a top-level internal fun parseCachedTxs and covered by TxCacheParserTest (3 cases: 4-field parse + legacy 3-field skip, garbage/blank dropping, empty cache). 3-field legacy entries are skipped, not synthesized — the cache fills with 4-field entries after the next kit emit. --- .../moneroone/core/wallet/WalletViewModel.kt | 43 +++++++++++++++--- .../one/monero/moneroone/TxCacheParserTest.kt | 45 +++++++++++++++++++ 2 files changed, 82 insertions(+), 6 deletions(-) create mode 100644 app/src/test/java/one/monero/moneroone/TxCacheParserTest.kt diff --git a/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt b/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt index 7bea75f..bf63f9c 100644 --- a/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt +++ b/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt @@ -66,6 +66,26 @@ sealed class SendState { data class Error(val message: String) : SendState() } +// ponytail: parse the widget tx cache (dir|amount|timestamp|hash;...) back into +// TransactionInfo for cold-start seeding. confirmations forced to 10 (Confirmed) — cached +// txs are virtually always old & confirmed; a pending tx self-corrects on kit emit. +// fee/blockheight default to 0, so detail screen shows "Fee 0 / Pending" briefly if +// tapped before kit loads. 3-field legacy entries (pre-hash) are skipped, not synthesized. +internal fun parseCachedTxs(cache: String): List = + cache.split(";") + .filter { it.isNotBlank() } + .mapNotNull { entry -> + val parts = entry.split("|") + if (parts.size < 4) return@mapNotNull null + val dir = if (parts[0] == "in") 0 else 1 + val amount = parts[1].toLongOrNull() ?: return@mapNotNull null + val timestamp = parts[2].toLongOrNull() ?: return@mapNotNull null + TransactionInfo( + dir, false, false, amount, 0, 0, parts[3], timestamp, + "", 0, 0, 10, 0, "", null + ) + } + class WalletViewModel(application: Application) : AndroidViewModel(application) { private val context = application.applicationContext @@ -132,13 +152,13 @@ class WalletViewModel(application: Application) : AndroidViewModel(application) } // ponytail: seed last-known state from the widget cache to mask the cold-start - // 0-balance flash. Kit's live emissions overwrite these on reconnect. + // 0-balance / empty-list flash. Kit's live emissions overwrite these on reconnect. private fun seedFromWidgetCache() { _walletState.update { it.copy( balance = Balance(WidgetDataStore.getBalance(context), WidgetDataStore.getUnlockedBalance(context)), - // Connecting (not the cached status) so the empty-tx card shows the - // spinner instead of "No transactions yet" while the kit loads. + // Connecting (not the cached status) so the sync indicator reflects + // a refresh in progress, not a finished sync. syncState = SyncState.Connecting(waiting = false) ) } @@ -149,6 +169,16 @@ class WalletViewModel(application: Application) : AndroidViewModel(application) change24h = WidgetDataStore.getChange24h(context).toDouble() ) } + // ponytail: seed recent txs from the widget cache so the list isn't empty on cold + // start. confirmations forced to 10 (Confirmed) — cached txs are virtually always + // old & confirmed; a genuinely pending tx self-corrects when the kit emits. + // fee/blockheight default to 0, so detail screen shows "Fee 0 / Pending" briefly + // if tapped before kit loads. 3-field legacy entries (pre-hash) are skipped, not + // synthesized — the cache fills with 4-field entries after the next kit emit. + val cachedTxs = parseCachedTxs(WidgetDataStore.getTransactions(context)) + if (cachedTxs.isNotEmpty()) { + _walletState.update { it.copy(transactions = cachedTxs) } + } } fun checkAndApplyAutoLock() { @@ -566,13 +596,14 @@ class WalletViewModel(application: Application) : AndroidViewModel(application) WalletManager.transactionsFlow.collect { transactions -> Timber.d("Transactions updated: count=${transactions.size}") _walletState.update { it.copy(transactions = transactions) } - // Update transactions widget (store last 4 for the iOS-style large layout) + // Cache txs for widget (reads 4) + cold-start UI seed (reads up to 50). + // Format: dir|amount|timestamp|hash — 4th field ignored by widget, used by seed. val txString = transactions .sortedByDescending { it.timestamp } - .take(4) + .take(50) .joinToString(";") { tx -> val dir = if (tx.direction == io.horizontalsystems.monerokit.model.TransactionInfo.Direction.Direction_In) "in" else "out" - "$dir|${tx.amount}|${tx.timestamp}" + "$dir|${tx.amount}|${tx.timestamp}|${tx.hash}" } WidgetDataStore.saveTransactions(context, txString) WalletWidget.updateAll(context) diff --git a/app/src/test/java/one/monero/moneroone/TxCacheParserTest.kt b/app/src/test/java/one/monero/moneroone/TxCacheParserTest.kt new file mode 100644 index 0000000..32552c0 --- /dev/null +++ b/app/src/test/java/one/monero/moneroone/TxCacheParserTest.kt @@ -0,0 +1,45 @@ +package one.monero.moneroone + +import io.horizontalsystems.monerokit.model.TransactionInfo +import one.monero.moneroone.core.wallet.parseCachedTxs +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class TxCacheParserTest { + + @Test + fun parses4FieldEntriesAndSkipsLegacy3Field() { + val cache = "in|1000000000000|1700000000|abc123;out|2000000000000|1700000001|def456;in|99|1700000002" + val parsed = parseCachedTxs(cache) + + assertEquals(2, parsed.size) + + val first = parsed[0] + assertEquals(TransactionInfo.Direction.Direction_In, first.direction) + assertEquals(1_000_000_000_000L, first.amount) + assertEquals(1_700_000_000L, first.timestamp) + assertEquals("abc123", first.hash) + // Seed contract: confirmations forced to 10 so cached txs render as Confirmed. + assertEquals(10L, first.confirmations) + + val second = parsed[1] + assertEquals(TransactionInfo.Direction.Direction_Out, second.direction) + assertEquals("def456", second.hash) + } + + @Test + fun blankAndGarbageEntriesAreDropped() { + val cache = ";in|notanumber|1700000000|hash1;;in|500000000000|1700000001|hash2;" + val parsed = parseCachedTxs(cache) + + // "notanumber" fails toLongOrNull → dropped; blank entries filtered. + assertEquals(1, parsed.size) + assertEquals("hash2", parsed[0].hash) + } + + @Test + fun emptyCacheYieldsEmptyList() { + assertTrue(parseCachedTxs("").isEmpty()) + } +} From 709fd58617450e8b80d73a4063f44908f4cde00e Mon Sep 17 00:00:00 2001 From: Airpods69 Date: Mon, 6 Jul 2026 01:47:03 +0530 Subject: [PATCH 3/5] Auto-provision JVM 21 toolchain via foojay resolver Add foojay-resolver-convention plugin and the generated gradle-daemon-jvm.properties so builds fetch a JDK 21 (JetBrains) toolchain automatically instead of relying on a local install. --- gradle/gradle-daemon-jvm.properties | 13 +++++++++++++ settings.gradle.kts | 3 +++ 2 files changed, 16 insertions(+) create mode 100644 gradle/gradle-daemon-jvm.properties diff --git a/gradle/gradle-daemon-jvm.properties b/gradle/gradle-daemon-jvm.properties new file mode 100644 index 0000000..baa28d1 --- /dev/null +++ b/gradle/gradle-daemon-jvm.properties @@ -0,0 +1,13 @@ +#This file is generated by updateDaemonJvm +toolchainUrl.FREE_BSD.AARCH64=https\://api.foojay.io/disco/v3.0/ids/491f83666ae7f4d6ebb28fee72ebb035/redirect +toolchainUrl.FREE_BSD.X86_64=https\://api.foojay.io/disco/v3.0/ids/0d1a1acdc708062093673f65aa9aba4b/redirect +toolchainUrl.LINUX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/491f83666ae7f4d6ebb28fee72ebb035/redirect +toolchainUrl.LINUX.X86_64=https\://api.foojay.io/disco/v3.0/ids/0d1a1acdc708062093673f65aa9aba4b/redirect +toolchainUrl.MAC_OS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/7083b89563e7ce20943037b8cd2b8cc2/redirect +toolchainUrl.MAC_OS.X86_64=https\://api.foojay.io/disco/v3.0/ids/060bbb778a1f55ea705fdebd2ccfeab9/redirect +toolchainUrl.UNIX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/491f83666ae7f4d6ebb28fee72ebb035/redirect +toolchainUrl.UNIX.X86_64=https\://api.foojay.io/disco/v3.0/ids/0d1a1acdc708062093673f65aa9aba4b/redirect +toolchainUrl.WINDOWS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/d09679dc60fe5aa05ef7d03efdefac20/redirect +toolchainUrl.WINDOWS.X86_64=https\://api.foojay.io/disco/v3.0/ids/ed4e3bf2f5e7c5d9aabc4cbd8acd555e/redirect +toolchainVendor=JETBRAINS +toolchainVersion=21 diff --git a/settings.gradle.kts b/settings.gradle.kts index 9766e5c..a9b8796 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -11,6 +11,9 @@ pluginManagement { gradlePluginPortal() } } +plugins { + id("org.gradle.toolchains.foojay-resolver-convention") version "0.10.0" +} dependencyResolutionManagement { repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) From 944df8fc2eedbdaa28c61e001adeaee66b1f6737 Mon Sep 17 00:00:00 2001 From: Airpods69 Date: Mon, 6 Jul 2026 02:08:49 +0530 Subject: [PATCH 4/5] Pay off ponytail tx-seed debt: cache fee/blockheight/confirmations MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The widget tx-cache previously stored only dir|amount|timestamp|hash, so parseCachedTxs fabricated confirmations=10 (Confirmed), fee=0, blockheight=0 for the cold-start seed. The detail screen then showed status Confirmed next to Block Height "Pending" — a visible contradiction. Extend the cache format to dir|amount|timestamp|hash|fee|blockheight|confirmations and restore all three fields faithfully. blockheight=0 marks a genuinely pending tx (isPending) instead of forcing Confirmed. Legacy 4-field entries are skipped, not fabricated; the list stays empty only until the next kit emit rewrites the cache with all seven fields. Demote the balance/price seed ponytail tag — caching last-known values is correct, not a shortcut. TxCacheParserTest now round-trips the writer format and asserts the pending/confirmed split instead of the old forced-confirmations contract. --- .../moneroone/core/wallet/WalletViewModel.kt | 34 ++++++++----------- .../one/monero/moneroone/TxCacheParserTest.kt | 33 +++++++++++++++--- 2 files changed, 43 insertions(+), 24 deletions(-) diff --git a/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt b/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt index bf63f9c..4424da0 100644 --- a/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt +++ b/app/src/main/java/one/monero/moneroone/core/wallet/WalletViewModel.kt @@ -66,23 +66,25 @@ sealed class SendState { data class Error(val message: String) : SendState() } -// ponytail: parse the widget tx cache (dir|amount|timestamp|hash;...) back into -// TransactionInfo for cold-start seeding. confirmations forced to 10 (Confirmed) — cached -// txs are virtually always old & confirmed; a pending tx self-corrects on kit emit. -// fee/blockheight default to 0, so detail screen shows "Fee 0 / Pending" briefly if -// tapped before kit loads. 3-field legacy entries (pre-hash) are skipped, not synthesized. +// Parse the widget tx cache (dir|amount|timestamp|hash|fee|blockheight|confirmations;...) +// back into TransactionInfo for cold-start seeding. Kit's live emissions overwrite these. +// Legacy entries missing the fee/blockheight/confirmations fields are skipped — the next +// emit rewrites the cache with all seven fields, so the list only stays empty for one boot. internal fun parseCachedTxs(cache: String): List = cache.split(";") .filter { it.isNotBlank() } .mapNotNull { entry -> val parts = entry.split("|") - if (parts.size < 4) return@mapNotNull null + if (parts.size < 7) return@mapNotNull null val dir = if (parts[0] == "in") 0 else 1 val amount = parts[1].toLongOrNull() ?: return@mapNotNull null val timestamp = parts[2].toLongOrNull() ?: return@mapNotNull null + val fee = parts[4].toLongOrNull() ?: 0L + val blockheight = parts[5].toLongOrNull() ?: 0L + val confirmations = parts[6].toLongOrNull() ?: 0L TransactionInfo( - dir, false, false, amount, 0, 0, parts[3], timestamp, - "", 0, 0, 10, 0, "", null + dir, blockheight == 0L, false, amount, fee, blockheight, parts[3], + timestamp, "", 0, 0, confirmations, 0, "", null ) } @@ -151,8 +153,8 @@ class WalletViewModel(application: Application) : AndroidViewModel(application) _selectedCurrency.value = Currency.entries.find { it.code == currencyCode } ?: Currency.USD } - // ponytail: seed last-known state from the widget cache to mask the cold-start - // 0-balance / empty-list flash. Kit's live emissions overwrite these on reconnect. + // Seed last-known state from the widget cache to mask the cold-start 0-balance / + // empty-list flash. Kit's live emissions overwrite these on reconnect. private fun seedFromWidgetCache() { _walletState.update { it.copy( @@ -169,12 +171,6 @@ class WalletViewModel(application: Application) : AndroidViewModel(application) change24h = WidgetDataStore.getChange24h(context).toDouble() ) } - // ponytail: seed recent txs from the widget cache so the list isn't empty on cold - // start. confirmations forced to 10 (Confirmed) — cached txs are virtually always - // old & confirmed; a genuinely pending tx self-corrects when the kit emits. - // fee/blockheight default to 0, so detail screen shows "Fee 0 / Pending" briefly - // if tapped before kit loads. 3-field legacy entries (pre-hash) are skipped, not - // synthesized — the cache fills with 4-field entries after the next kit emit. val cachedTxs = parseCachedTxs(WidgetDataStore.getTransactions(context)) if (cachedTxs.isNotEmpty()) { _walletState.update { it.copy(transactions = cachedTxs) } @@ -596,14 +592,14 @@ class WalletViewModel(application: Application) : AndroidViewModel(application) WalletManager.transactionsFlow.collect { transactions -> Timber.d("Transactions updated: count=${transactions.size}") _walletState.update { it.copy(transactions = transactions) } - // Cache txs for widget (reads 4) + cold-start UI seed (reads up to 50). - // Format: dir|amount|timestamp|hash — 4th field ignored by widget, used by seed. + // Cache txs for widget (reads dir|amount|timestamp) + cold-start UI seed + // (reads all 7). Format: dir|amount|timestamp|hash|fee|blockheight|confirmations val txString = transactions .sortedByDescending { it.timestamp } .take(50) .joinToString(";") { tx -> val dir = if (tx.direction == io.horizontalsystems.monerokit.model.TransactionInfo.Direction.Direction_In) "in" else "out" - "$dir|${tx.amount}|${tx.timestamp}|${tx.hash}" + "$dir|${tx.amount}|${tx.timestamp}|${tx.hash}|${tx.fee}|${tx.blockheight}|${tx.confirmations}" } WidgetDataStore.saveTransactions(context, txString) WalletWidget.updateAll(context) diff --git a/app/src/test/java/one/monero/moneroone/TxCacheParserTest.kt b/app/src/test/java/one/monero/moneroone/TxCacheParserTest.kt index 32552c0..a4ac7aa 100644 --- a/app/src/test/java/one/monero/moneroone/TxCacheParserTest.kt +++ b/app/src/test/java/one/monero/moneroone/TxCacheParserTest.kt @@ -3,14 +3,17 @@ package one.monero.moneroone import io.horizontalsystems.monerokit.model.TransactionInfo import one.monero.moneroone.core.wallet.parseCachedTxs import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue import org.junit.Test class TxCacheParserTest { @Test - fun parses4FieldEntriesAndSkipsLegacy3Field() { - val cache = "in|1000000000000|1700000000|abc123;out|2000000000000|1700000001|def456;in|99|1700000002" + fun roundTripsWriterFormatWithFullFields() { + // Format the writer emits: dir|amount|timestamp|hash|fee|blockheight|confirmations + val cache = "in|1000000000000|1700000000|abc123|0|310000|15;" + + "out|500000000000|1700000001|def456|12000|0|0" val parsed = parseCachedTxs(cache) assertEquals(2, parsed.size) @@ -20,22 +23,42 @@ class TxCacheParserTest { assertEquals(1_000_000_000_000L, first.amount) assertEquals(1_700_000_000L, first.timestamp) assertEquals("abc123", first.hash) - // Seed contract: confirmations forced to 10 so cached txs render as Confirmed. - assertEquals(10L, first.confirmations) + assertEquals(0L, first.fee) + assertEquals(310_000L, first.blockheight) + assertEquals(15L, first.confirmations) + assertFalse(first.isPending) // blockheight > 0 → confirmed + // Pending tx: blockheight 0 → isPending, fee preserved, confirmations 0. val second = parsed[1] assertEquals(TransactionInfo.Direction.Direction_Out, second.direction) assertEquals("def456", second.hash) + assertEquals(12_000L, second.fee) + assertEquals(0L, second.blockheight) + assertEquals(0L, second.confirmations) + assertTrue(second.isPending) + } + + @Test + fun skipsLegacyEntriesMissingTheExtraFields() { + // Pre-upgrade 4-field entries lack fee/blockheight/confirmations → skip, don't + // fabricate a Confirmed status. The next kit emit rewrites the cache with 7 fields. + val cache = "in|1000000000000|1700000000|abc123;" + + "in|500000000000|1700000001|hash2|0|310000|10" + val parsed = parseCachedTxs(cache) + + assertEquals(1, parsed.size) + assertEquals("hash2", parsed[0].hash) } @Test fun blankAndGarbageEntriesAreDropped() { - val cache = ";in|notanumber|1700000000|hash1;;in|500000000000|1700000001|hash2;" + val cache = ";in|notanumber|1700000000|hash1|0|0|0;;in|500000000000|1700000001|hash2|0|0|5;" val parsed = parseCachedTxs(cache) // "notanumber" fails toLongOrNull → dropped; blank entries filtered. assertEquals(1, parsed.size) assertEquals("hash2", parsed[0].hash) + assertEquals(5L, parsed[0].confirmations) } @Test From 314c01221fe339ac95fb89f4305bdc7ad55eb8fb Mon Sep 17 00:00:00 2001 From: Airpods69 Date: Mon, 6 Jul 2026 02:21:34 +0530 Subject: [PATCH 5/5] Remove foojay toolchain auto-provisioning Drop foojay-resolver-convention plugin and gradle-daemon-jvm.properties. Builds now require a locally installed JDK 17+ (AGP requirement). --- gradle/gradle-daemon-jvm.properties | 13 ------------- settings.gradle.kts | 3 --- 2 files changed, 16 deletions(-) delete mode 100644 gradle/gradle-daemon-jvm.properties diff --git a/gradle/gradle-daemon-jvm.properties b/gradle/gradle-daemon-jvm.properties deleted file mode 100644 index baa28d1..0000000 --- a/gradle/gradle-daemon-jvm.properties +++ /dev/null @@ -1,13 +0,0 @@ -#This file is generated by updateDaemonJvm -toolchainUrl.FREE_BSD.AARCH64=https\://api.foojay.io/disco/v3.0/ids/491f83666ae7f4d6ebb28fee72ebb035/redirect -toolchainUrl.FREE_BSD.X86_64=https\://api.foojay.io/disco/v3.0/ids/0d1a1acdc708062093673f65aa9aba4b/redirect -toolchainUrl.LINUX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/491f83666ae7f4d6ebb28fee72ebb035/redirect -toolchainUrl.LINUX.X86_64=https\://api.foojay.io/disco/v3.0/ids/0d1a1acdc708062093673f65aa9aba4b/redirect -toolchainUrl.MAC_OS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/7083b89563e7ce20943037b8cd2b8cc2/redirect -toolchainUrl.MAC_OS.X86_64=https\://api.foojay.io/disco/v3.0/ids/060bbb778a1f55ea705fdebd2ccfeab9/redirect -toolchainUrl.UNIX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/491f83666ae7f4d6ebb28fee72ebb035/redirect -toolchainUrl.UNIX.X86_64=https\://api.foojay.io/disco/v3.0/ids/0d1a1acdc708062093673f65aa9aba4b/redirect -toolchainUrl.WINDOWS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/d09679dc60fe5aa05ef7d03efdefac20/redirect -toolchainUrl.WINDOWS.X86_64=https\://api.foojay.io/disco/v3.0/ids/ed4e3bf2f5e7c5d9aabc4cbd8acd555e/redirect -toolchainVendor=JETBRAINS -toolchainVersion=21 diff --git a/settings.gradle.kts b/settings.gradle.kts index a9b8796..9766e5c 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -11,9 +11,6 @@ pluginManagement { gradlePluginPortal() } } -plugins { - id("org.gradle.toolchains.foojay-resolver-convention") version "0.10.0" -} dependencyResolutionManagement { repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)