fix(legacy-refunds): support going the spending path on refund #2280

mariocynicys · 2024-11-25T07:56:02Z

This PR attempts to follow a more robust recovery process by attempting both refunding OR spending if the swap goes the ugly way.
This is done by replacing the refund-only logic with refund-or-spend-logic (recovery, recover_funds).

Also recover_funds has been adapted to return more structured error types for information about retrials and such. Also removing some pre-checks that makes us fail early based on local data (e.g. is_swap_finished), as we should still query the rpc to make sure our recovery tx isn't lost or something.

modularize these funcs and introdcue a new error type to filter errors and possible retrys. tests are not yet adapted.

not finished and on successful checking swaps are removed. these tests were used to check that we error on recover funds when: - swap is not finished yet: there is not reason not to try recover funds still - swap was successful (determined the existance of taker/maker payment spend): we should still attempt to recover funds in this case as the tx might be re-orged or some weird thing happned. there is no downside of retrying. also test_recover_funds_maker_swap_maker_payment_refunded was used to test that we check local data to determine that the swap failed. again this isn't the followed approach here. even if we store maker_payment_refund tx locally (so we should have sent it when the swap was running) we will still attempt to run recover funds and look for the tx on-chain. this test could have been adapted but then it looks exactly like test_recover_funds_maker_payment_refund_already_refunded, so there is no point of that.

namely, we do try to refund (maker payment) or spend (taker payment), which ever is possible. we might want to change refund_maker_payment name to recover or something

same as what's done with the maker. thought much more useful here because on the maker side we can't really miss spending the taker's payment while getting our own payment spent :p

borngraced

Thanks for the PR, looks cleaner. My only note is regarding error handling.

mm2src/mm2_main/src/lp_swap/maker_swap.rs

mm2src/mm2_main/src/lp_swap/taker_swap.rs

laruh · 2024-11-25T11:40:32Z

@mariocynicys could you please fix PR lint

laruh

Thanks for this fix, here my notes

mm2src/mm2_main/src/lp_swap/maker_swap.rs

mm2src/mm2_main/src/lp_swap/taker_swap.rs

mm2src/mm2_main/src/lp_swap/maker_swap.rs

sorry, but amending this would break the links i just shared :). thanks for your undertanding, reader.

shamardy

Thanks for the PR. First review iteration!

A few suggestions/discussion points:

Maybe we should add start/stop swap rpc for @cipig to use to stop endlessly failing swaps until we fix the bugs that lead to this.
We will need this for TPU, please add it to an issue checklist.

shamardy · 2024-12-04T23:33:05Z

mm2src/mm2_main/src/lp_swap/maker_swap.rs

+                    .maker_coin
+                    .can_refund_htlc(maker_payment_lock)
+                    .await
+                    .map_err(RecoverSwapError::Irrecoverable)?;


can_refund_htlc can sometimes return a recoverable error, please check utxo implementation for this ref.

komodo-defi-framework/mm2src/coins/utxo/utxo_common.rs

Line 4641 in 0a94102

let mtp = coin.get_current_mtp().await?;

mm2src/mm2_main/src/lp_swap.rs

shamardy · 2024-12-05T00:39:26Z

mm2src/mm2_main/src/lp_swap/taker_swap.rs

+                        // Roll back to confirming the maker payment spend.
+                        RecoveredSwapAction::SpentOtherPayment => {
+                            info!("Refund canceled. Maker payment spend tx {:02x}", tx_ident.tx_hash);
+                            // TODO: We prepared for refund but didn't finalize refund. This must be breaking something for lightning.


Will we ever hit this code in lightning? I guess it can happen for taker swap code but it's not a big problem anyways since the finalize refund is just to allow the maker get his payment back instantly instead of waiting for the timelock to expire, and if we spend it, it means it can't be failed backwards. For maker swap code it's a different case, maker fails the htlc backwards before this step, so we will never hit this code.
Usually such things in code is a cue for a needed refactor but not in this PR of course.

looks like this is only relevant for lightning receiving maker. and yeah if the maker fails the HTLC then we can't hit SpentOtherPayment.
removed the todo 70afcde

shamardy · 2024-12-05T00:46:44Z

mm2src/mm2_main/src/lp_swap/taker_swap.rs

+                        // FIXME: We should try to `recover_funds` again after locktime. The taker payment might have been
+                        //        spent by the maker at this point and we should go for spending the maker payment instead.


Well, wait_for_htlc_refund for lightning doesn't depend on locktime, but this is a general code and we should handle this case. For the lightning case, if we got payment successful from here

komodo-defi-framework/mm2src/coins/lightning.rs

Lines 824 to 828 in f401497

_ => Ready(MmError::err(RefundError::Internal(ERRL!(

"Payment {} has an invalid status of {} in the db",

payment_hex,

payment.status

)))),

It means that we should be spending the maker payment.

i think that makes sense in the general sense. if the wait_for_htlc_refund fails we can try to recover again.

there is one case that comes to my mind where it would be bad to retry endlessly: if the initial tx was reverted because of too low gas (so basically a misconfiguration from our side)... if you retry that tx, you will spend gas again, but the result will be the same if you haven't increased gas limits... so you loose the txfees every time you try
idk if we want/should account for this case, but thought i mention it

yeah that's a good reason to have a start/stop rpc.

A start/stop rpc doesn't solve this, as too much gas might have been already spent until the user or @cipig is aware of this, this could drain the user's wallet which is really bad. We need to mark swap as failed for this and this is one of the situations where we will still require manual recover funds usage. @cipig are you aware of other situations like this one, we shouldn't release this PR/fix unless we are sure it's completely safe to retry forever and all edge cases are covered.

there is this #1567, but there you don't loose any fees when you retry forever
i guess reverted "out of gas" txes on EVM chains are the only problem where you loose money if you retry forever
there may be other reasons why a EVM chain reverts your tx, but i haven't encountered any other that would always fail
so short answer is "no", just this case :-)

covered here: a28c768

for the gas issue with reverted txs: what about retrying the refund in an exponential backoff manner? this greatly reduces the amount of failed recoveries and doesn't hurt the perf/speed that much.

Strictly speaking, 'reverted' means that tx was cancelled due to errors during the contract execution (for e.g. locktime has not been passed yet), so the tx may be retried yet.
A tx can be cancelled due to out of gas. To prevent retries in this case, I think, we may analyse the tx receipt in eth code and return some unrecoverable error to the swap code.

A tx can be cancelled due to out of gas. To prevent retries in this case, I think, we may analyse the tx receipt in eth code and return some unrecoverable error to the swap code.

gas spikes on Ethereum are typically temporary nope? and a transaction being "out of gas" is not necessarily a permanent failure.
I would suggest to mark swap failed in this case and stop the process, but allow user to retry spend-or-refun process later and start it manually. And also allow to stop if it takes too long time for them. If retry faced "out of gas" again, then mark as failed and stop process.

laruh · 2024-12-05T07:53:41Z

We will need this for TPU, please add it to an issue checklist.

I suppose you're referencing to this issue #1895 ?

We have lots of lists, so I just want to clarify. I also added eth coin todos here.

this field was convereted to a hashmap instead of a vector for easy access to the swap. also we now manually delete the swap from running swaps when the swap is finished/inturepted (memory leak fix). as a consequence to manuallly deleting the swap from running_swaps, we can now store them as arcs instead of weakrefs, which simplifies a lot of .upgrade calls.

This reverts commit 5c1bb6f.

dimxy · 2024-12-19T16:56:19Z

mm2src/mm2_main/src/lp_swap/swap_v2_rpcs.rs

+            )));
+        },
+    };
+    let taker_coin = match swap.taker_coin_ticker() {


Code repetition for finding maker_coin and taker_coin.
(BTW could we just use lp_coinfind_or_err in all such cases?)

thanks. i didn't like it either but needed some assertion xD

This reverts commit 245ea93.

laruh · 2024-12-23T12:15:53Z

mm2src/mm2_main/src/lp_swap.rs

@@ -516,7 +532,7 @@ struct LockedAmountInfo {
 }

 struct SwapsContext {
-    running_swaps: Mutex<Vec<Weak<dyn AtomicSwap>>>,
+    running_swaps: Mutex<Vec<(Weak<dyn AtomicSwap>, AbortOnDropHandle)>>,


Could you tell why do we need this change?

Is it related to some review note? may be I missed smth

nah actually, not discussed in review. @shamardy just told me we need the swaps to be stoppable via rpc (since we now do a run forever recovery), that's why we record their abort handles to be able to stop them mid-recover (or even mid-swap).

mm2src/mm2_main/src/lp_swap/swap_v2_rpcs.rs

dimxy · 2025-01-14T07:01:26Z

mm2src/mm2_main/src/lp_swap/taker_swap.rs

-    };
+    // Run the swap in an abortable task and wait for it to finish.
+    let (swap_ended_notifier, swap_ended_notification) = oneshot::channel();
+    let abortable_swap = spawn_abortable(async move {


Here we create an abortable future to run the swap loop (for using this in the new stop rpc I believe).
But run_taker_swap fn, where we are now, is also wrapped in an abortable future. Could we use this one in the stop rpc?

but how will we grab that abort handle and supply it to run_taker_swap in the first place?
also kickstart_thread_handler uses run_taker_swap inline (without spawning it), well eventually if u follow the usage ofc u will find kickstart_thread_handler is itself being spawned somewhere. but it's hard to propagate these handles all the way down to the swap runner methods.

I think it's a bit odd when we use different futures to stop the same swap in different use cases (abort_all and stop_swap_rpc). Maybe we could get the handle for a future from the abortable_system for stop_swap_rpc, so we would use same abort technique in both cases. Maybe some modification for AbortableQueue is needed for that

dimxy · 2025-01-14T17:12:53Z

test_mm2_stops_immediately seems not working btw. I guess clear_running_swaps() is needed here too?

mariocynicys · 2025-01-14T17:21:24Z

test_mm2_stops_immediately seems not working btw. I guess clear_running_swaps() is needed here too?

yup. I'll just wait till we finish reviewing the mem leak PR and merge it and then merge this with dev.

dimxy · 2025-01-14T17:36:51Z

mm2src/mm2_main/src/lp_swap/taker_swap.rs

-        _touch = touch_loop => unreachable!("Touch loop can not stop!"),
-    };
+    // Run the swap in an abortable task and wait for it to finish.
+    let (swap_ended_notifier, swap_ended_notification) = oneshot::channel();


Could we simplify this code to eliminate oneshot::channel?

- let (swap_ended_notifier, swap_ended_notification) = oneshot::channel(); - let abortable_swap = spawn_abortable(async move { + let fut_with_touch = async move { select! { _swap = swap_fut => (), // swap finished normally _touch = touch_loop => unreachable!("Touch loop can not stop!"), - } - if swap_ended_notifier.send(()).is_err() { - error!("Swap listener stopped listening!"); - } - }); - swap_ctx.running_swaps.lock().unwrap().push((weak_ref, abortable_swap)); - // Halt this function until the swap has finished (or interrupted, i.e. aborted/panic). - swap_ended_notification.await.error_log_with_msg("Swap interrupted!"); + }; + }; + let (abortable, handle) = abortable(fut_with_touch); + swap_ctx.running_swaps.lock().unwrap().push((weak_ref, handle.into())); + if let Err(Aborted) = abortable.await { + info!("Swap uuid={} interrupted!", uuid); + }

laruh · 2025-01-16T09:42:30Z

@mariocynicys pr started to have conflicts

This reverts commit 0ce3c93.

…inline we don't need a oneshot channel this way

mariocynicys · 2025-01-24T10:21:58Z

mm2src/mm2_main/src/lp_swap/maker_swap.rs

+        .fuse()
+    });
+
+    let (abortable, handle) = abortable(async move {
+        select! {
+         _swap = swap_fut => (), // swap finished normally
+         _touch = touch_loop => unreachable!("Touch loop can not stop!"),
+        }
+    });
+    let uuid = running_swap.uuid;
+    swap_ctx
+        .running_swaps
+        .lock()
+        .unwrap()
+        .insert(uuid, (running_swap, handle.into()));
+    // Wait until the swap has finished (or interrupted, i.e. aborted/panic).
+    if abortable.await.is_err() {
+        info!("Swap uuid={} interrupted!", uuid);
+    }
    // Remove the swap from the running swaps map.
    swap_ctx.running_swaps.lock().unwrap().remove(&uuid);


there is a side effect introduced in this PR that i don't like:
if the parent of this func call (run_maker_swap/run_taker_swap) aborts mid-way, the swap will not abort. one could still abort it ofc from the running_swaps map.
but i think it's more intuitive to have the swap aborted when run_maker_swap is aborted without the need to abort it via running_swaps map.

i think what i want is to be able to run the swap in the current abortable system while still be able to shut the swap using the aborthandle. so there is a 2-way shutdown mechanism or something like that.

cc/ @dimxy

Yeah, I think maybe we should create an abortable future (swap_fut+ touch_loop) in run_taker_swap(), add its abort_handle to both the abortable_system and running_swaps.
Then spawn this abortable future and do not await for it.

borngraced

last notes from my side.

borngraced · 2025-01-24T10:24:11Z

mm2src/mm2_main/src/lp_swap/maker_swap.rs

+    if abortable.await.is_err() {
+        info!("Swap uuid={} interrupted!", uuid);
+    }


why is the log level changed to info?

yeah that should be error, thanks.

borngraced · 2025-01-24T10:24:54Z

mm2src/mm2_main/src/lp_swap/taker_swap.rs

+    if abortable.await.is_err() {
+        info!("Swap uuid={} interrupted!", uuid);
+    }


same as above

borngraced · 2025-01-24T10:36:17Z

mm2src/mm2_main/src/lp_swap/swap_v2_rpcs.rs

+    let swap = match SavedSwap::load_my_swap_from_db(&ctx, req.uuid).await {
+        Ok(Some(s)) => s,
+        Ok(None) => {
+            return MmError::err(KickStartSwapErr::NotFound);
+        },
+        Err(e) => {
+            return MmError::err(KickStartSwapErr::Internal(format!(
+                "Error getting the swap from the DB: {e}"
+            )))
+        },
+    };


Suggested change

let swap = match SavedSwap::load_my_swap_from_db(&ctx, req.uuid).await {

Ok(Some(s)) => s,

Ok(None) => {

return MmError::err(KickStartSwapErr::NotFound);

},

Err(e) => {

return MmError::err(KickStartSwapErr::Internal(format!(

"Error getting the swap from the DB: {e}"

)))

},

};

let swap = SavedSwap::load_my_swap_from_db(&ctx, req.uuid)

.await

.mm_err(|e| KickStartSwapErr::Internal(format!("Error getting the swap from the DB: {e}")))?

.or_mm_err(|| KickStartSwapErr::NotFound)?;

borngraced · 2025-01-24T10:51:13Z

mm2src/mm2_main/src/lp_swap/swap_v2_rpcs.rs

+    // Get the maker and taker coins.
+    let find_swap_coin = |ctx: MmArc, maybe_ticker: Result<String, String>, ticker_type: &'static str| async move {
+        match maybe_ticker {
+            Ok(coin) => match lp_coinfind(&ctx, &coin).await {
+                Ok(Some(coin)) => Ok(coin),
+                Ok(None) => MmError::err(KickStartSwapErr::NeedsCoinActivation(format!(
+                    "{ticker_type} coin {} must be activated",
+                    coin
+                ))),
+                Err(e) => MmError::err(KickStartSwapErr::Internal(format!(
+                    "Error trying to find {ticker_type} coin: {e}"
+                ))),
+            },
+            Err(e) => MmError::err(KickStartSwapErr::Internal(format!(
+                "Error getting {ticker_type} ticker of swap: {e}"
+            ))),
+        }
+    };
+    let maker_coin = find_swap_coin(ctx.clone(), swap.maker_coin_ticker(), "maker").await?;
+    let taker_coin = find_swap_coin(ctx.clone(), swap.taker_coin_ticker(), "taker").await?;


I think this is better and this is too minimal to require cloning arc

Suggested change

// Get the maker and taker coins.

let find_swap_coin = |ctx: MmArc, maybe_ticker: Result<String, String>, ticker_type: &'static str| async move {

match maybe_ticker {

Ok(coin) => match lp_coinfind(&ctx, &coin).await {

Ok(Some(coin)) => Ok(coin),

Ok(None) => MmError::err(KickStartSwapErr::NeedsCoinActivation(format!(

"{ticker_type} coin {} must be activated",

coin

))),

Err(e) => MmError::err(KickStartSwapErr::Internal(format!(

"Error trying to find {ticker_type} coin: {e}"

))),

},

Err(e) => MmError::err(KickStartSwapErr::Internal(format!(

"Error getting {ticker_type} ticker of swap: {e}"

))),

}

};

let maker_coin = find_swap_coin(ctx.clone(), swap.maker_coin_ticker(), "maker").await?;

let taker_coin = find_swap_coin(ctx.clone(), swap.taker_coin_ticker(), "taker").await?;

let maker_coin = swap

.maker_coin_ticker()

.map_to_mm(|e| KickStartSwapErr::Internal(format!("Error getting maker ticker for swap: {e}")))?;

let maker_coin = lp_coinfind(&ctx, &maker_coin)

.await

.map_to_mm(|e| KickStartSwapErr::Internal(format!("Error getting maker ticker for swap: {e}")))?

.or_mm_err(|| KickStartSwapErr::NeedsCoinActivation(format!("maker coin {maker_coin} must be activated")))?;

let taker_coin = swap

.taker_coin_ticker()

.map_to_mm(|e| KickStartSwapErr::Internal(format!("Error getting taker ticker for swap: {e}")))?;

let taker_coin = lp_coinfind(&ctx, &taker_coin)

.await

.map_to_mm(|e| KickStartSwapErr::Internal(format!("Error getting taker ticker for swap: {e}")))?

.or_mm_err(|| KickStartSwapErr::NeedsCoinActivation(format!("taker coin {taker_coin} must be activated")))?;

mariocynicys added 4 commits November 23, 2024 23:10

refactor recover_funds for maker & taker

026cd08

modularize these funcs and introdcue a new error type to filter errors and possible retrys. tests are not yet adapted.

make refund_maker_payment more robust

8cadb68

namely, we do try to refund (maker payment) or spend (taker payment), which ever is possible. we might want to change refund_maker_payment name to recover or something

make refund_taker_payment more robust

553d054

same as what's done with the maker. thought much more useful here because on the maker side we can't really miss spending the taker's payment while getting our own payment spent :p

mariocynicys added the under review label Nov 25, 2024

shamardy requested a review from laruh November 25, 2024 09:48

shamardy added the 2.3.0-beta label Nov 25, 2024

shamardy requested a review from borngraced November 25, 2024 10:50

borngraced requested changes Nov 25, 2024

View reviewed changes

mm2src/mm2_main/src/lp_swap/maker_swap.rs Outdated Show resolved Hide resolved

mm2src/mm2_main/src/lp_swap/taker_swap.rs Outdated Show resolved Hide resolved

mariocynicys changed the title ~~optimization(legacy-swap): support going the spending path on refund~~ fix(legacy-refunds): support going the spending path on refund Nov 25, 2024

laruh requested changes Nov 27, 2024

View reviewed changes

mariocynicys commented Nov 27, 2024

View reviewed changes

mm2src/mm2_main/src/lp_swap/taker_swap.rs Outdated Show resolved Hide resolved

laruh requested changes Nov 28, 2024

View reviewed changes

mm2src/mm2_main/src/lp_swap/maker_swap.rs Outdated Show resolved Hide resolved

laruh added in progress and removed under review labels Nov 29, 2024

mariocynicys added under review and removed in progress labels Nov 30, 2024

mariocynicys added 4 commits November 30, 2024 11:10

review(omer): typo - (taker -> maker) payment spend

3aa1811

review(sami): use MmError to track the error origin

df94b09

review(alina): restructure match and optimize tx_hex clone

5e0709d

remove extra line

07f5bed

sorry, but amending this would break the links i just shared :). thanks for your undertanding, reader.

mariocynicys requested review from borngraced, laruh and shamardy December 2, 2024 11:23

borngraced previously approved these changes Dec 2, 2024

View reviewed changes

mariocynicys linked an issue Dec 4, 2024 that may be closed by this pull request

MM2 doesn't retry querying electrums on failed RPC requests #1126

Open

shamardy mentioned this pull request Dec 5, 2024

fix(swaps): retry refund of maker swap v1 payment until successful #2132

Closed

shamardy reviewed Dec 5, 2024

View reviewed changes

onur-ozkan added the status: pending review label Dec 16, 2024

mariocynicys added 3 commits December 16, 2024 18:16

store the swap aborthanle in running_swaps

4a44e16

add stop/kickstart swap rpcs

e5c5f34

mariocynicys force-pushed the robust-swaps branch from 10e4192 to 245ea93 Compare December 16, 2024 19:29

mariocynicys added 2 commits December 16, 2024 20:39

Revert "remove todo"

c3b3b6b

This reverts commit 5c1bb6f.

remove todo regarding refund finalization

70afcde

shamardy mentioned this pull request Dec 16, 2024

fix(tpu-v2): fix tpu-v2 wait for payment spend and extract secret #2261

Open

dimxy reviewed Dec 19, 2024

View reviewed changes

Revert "fix running_swap memory leak"

0ce3c93

This reverts commit 245ea93.

laruh reviewed Dec 23, 2024

View reviewed changes

mariocynicys mentioned this pull request Dec 23, 2024

fix(mem-leak): running_swap never shrinks #2301

Merged

dimxy reviewed Dec 23, 2024

View reviewed changes

mm2src/mm2_main/src/lp_swap/swap_v2_rpcs.rs Outdated Show resolved Hide resolved

dimxy reviewed Dec 25, 2024

View reviewed changes

mm2src/mm2_main/src/lp_swap/swap_v2_rpcs.rs Show resolved Hide resolved

mariocynicys added 2 commits December 29, 2024 14:17

review(dimxy): DRY, use a clourse for finding maker and taker coins

cc0db2e

review(dimxy): issue an info! log when stop rpc is used

997ad63

laruh added the priority: medium Moderately important tasks that should be completed but are not urgent. label Jan 10, 2025

dimxy reviewed Jan 14, 2025

View reviewed changes

laruh added priority: high Important tasks that need attention soon. and removed priority: medium Moderately important tasks that should be completed but are not urgent. labels Jan 16, 2025

mariocynicys added 4 commits January 24, 2025 10:17

Reapply "fix running_swap memory leak"

497c394

This reverts commit 0ce3c93.

merge with origin/dev

caf52dd

review(dimxy): use abortable instead of spawn_abortable and await it …

90263d9

…inline we don't need a oneshot channel this way

cargo fmt

ff636f4

mariocynicys commented Jan 24, 2025

View reviewed changes

borngraced requested changes Jan 24, 2025

View reviewed changes

		// FIXME: We should try to `recover_funds` again after locktime. The taker payment might have been
		// spent by the maker at this point and we should go for spending the maker payment instead.

	_ => Ready(MmError::err(RefundError::Internal(ERRL!(
	"Payment {} has an invalid status of {} in the db",
	payment_hex,
	payment.status
	)))),

fix(legacy-refunds): support going the spending path on refund #2280

Are you sure you want to change the base?

fix(legacy-refunds): support going the spending path on refund #2280

Conversation

mariocynicys commented Nov 25, 2024

borngraced left a comment

Choose a reason for hiding this comment

laruh commented Nov 25, 2024

laruh left a comment

Choose a reason for hiding this comment

shamardy left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mariocynicys Dec 16, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

cipig Dec 5, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

laruh commented Dec 5, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mariocynicys Dec 23, 2024 • edited Loading

Choose a reason for hiding this comment

dimxy Jan 14, 2025 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

dimxy commented Jan 14, 2025

mariocynicys commented Jan 14, 2025

Choose a reason for hiding this comment

laruh commented Jan 16, 2025

Choose a reason for hiding this comment

Choose a reason for hiding this comment

borngraced left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mariocynicys Dec 16, 2024 •

edited

Loading

cipig Dec 5, 2024 •

edited

Loading

laruh commented Dec 5, 2024 •

edited

Loading

mariocynicys Dec 23, 2024 •

edited

Loading

dimxy Jan 14, 2025 •

edited

Loading