flowchart TD
    Start["Consolidate coins"] --> 
    |Select asset id| get_all_coins("Get coins (all pages)") --> 
        more_coins_than_max_inputs(count >= max_inputs?) --> 
            |No| is_base_asset("Consolidating base asset?") -->
                    |No| get_resources_for_less("Call getResourcesToSpend to fund tx with one base input, all non-base inputs, and two outputs") -->
                        fill_up_all("Combine received base asset resources and as many non-base asset coins as possible") -->
                        at_least_two_non_base("There are at least two non-base inputs in the combination?") --> 
                            |Can't consolidate one coin, too many base asset dust coins, consider first consolidating them| throw
                        at_least_two_non_base -->
                            |Yes| verify_resources_can_fund("Verify resources can still fund tx after they have been added") -->
                                |No| refund_tx("Call getResourcesToSpend to fund this updated tx") -->
                                    fill_up_all
                            verify_resources_can_fund -->
                                |Yes| prepare_script_tx("Prepare tx with coins, check validity (amount > maxFee)")
                is_base_asset -->
                    |Yes| select_all_coins("Select all coins") -->
                    prepare_script_tx
        more_coins_than_max_inputs --> 
        |   Yes| is_base_asset_2("Consolidating base asset?") -->
                |No| get_resources_two_outputs("Call getResourcesToSpend to fund tx that has max fake inputs and two outputs") -->
                    fill_up_max("Combine funding resources and consolidation coins until max_inputs reached")
                is_base_asset_2 -->
                |Yes| get_resources_one_output("Call getResourcesToSpend to fund tx that has max fake inputs and one output") --> 
                    fill_up_max("Combine resources for funding and consolidation coins until max_inputs reached") --> 
                    prepare_script_tx
        prepare_script_tx --> 
            |Invalid| throw
        prepare_script_tx -->
            |Valid| send_tx("Send transaction and await")
        send_tx --> |Success| coins_remaining{"Remaining unconsolidated coins > 1?"}
        send_tx --> |Failure| throw("Throw, put results of previous transactions on error")
        send_tx --> |SqueezedOut| throw
        coins_remaining --> |Yes| more_coins_than_max_inputs
        coins_remaining --> |No| return_to_user(Return transactions and coins to user)

flowchart TD
    Start(Start) -->
    select_asset[\Select asset id/] -->
    get_all_coins{"get all coins (paginated)"} -->
    has_coins([Has more than one unconsolidated coin?]) ---> |No| return@{shape: docs, label: "Return transactions <br>(and all coins?)<br>to user"}
    has_coins --> |Yes| consolidating_base_asset([Consolidating base asset?])
    consolidating_base_asset -->
    |No| consolidate_base_asset((("Consolidate all base asset UTXOs into one"))) -->
    |Continue| combine_non_base@{shape: procs, label: "Select one base and <br>(max. inputs - 1) non-base coins"} -->
        build_tx((("Build tx and check validity <br>(amount > max fee)")))

    consolidating_base_asset --> 
    |Yes| more_than_max_inputs([coins > max. inputs?]) -->
        |No| select_all@{shape: procs, label: "Select all base coins"} --> build_tx
        more_than_max_inputs -->
        |Yes| get_resources{"Call getResourcesToSpend to fund tx with max inputs"} --> 
            combine_base@{shape: procs, label: "Combine resources and unconsolidated coins until max. inputs"} --> 
            build_tx
    
    build_tx -->
    |Invalid| throw@{shape: docs, label: "Throw, put results of previous transactions on error"}
    build_tx -->
    |Valid| submit{"Submit"}

    submit -.-> |Success| has_coins
    submit --> |Failure| throw
    submit --> |SqueezedOut| throw


style consolidate_base_asset fill:none;
style return stroke:green, fill:none, color:green;
style throw stroke:red, fill:none, color:red;

classDef HTTPReq stroke:blue, fill:none, color:blue;
class get_all_coins HTTPReq;
class get_resources HTTPReq;
class submit HTTPReq;

flowchart TD;
    start[Start] --> getOptimal("Get optimal <sup>(1)</sup> base coins")
    getOptimal --> amountGteFee1(["amount >= maxFee"])
    amountGteFee1 --> agf1Yes(((yes)))
    amountGteFee1 --> agf1No(((no)))

    agf1Yes --> selectConsolidationCoins("Select consolidation coins <sup>(3)</sup>")
    selectConsolidationCoins --> return@{ shape: docs, label: "return — base + consolidation coins"}
    agf1No --> getMax("Get least satisfactory <sup>(2)</sup> base coins")
    getMax ----> amountGteFee2(["amount >= maxFee"])
    amountGteFee2 --> agf2Yes(((yes)))
    amountGteFee2 --> agf2No(((no)))

    agf2Yes --> selectConsolidationCoins
    agf2No --> throw([INSUFFICIENT_FUNDS_OR_MAX_COINS])

    getOptimal <-.-> |zooming in| optimalCoinsRoot(((—)))
    getMax <-.-> |zooming in| maxCoinsRoot(((—)))

    %% Optimal coins selection
    optimalCoinsRoot --> sortCoinsAsc(["sort coins (asc)"])
    sortCoinsAsc --> iterateOpt["Iterate"]
    iterateOpt --> addCoinOpt([add coin]) --> reachedOptimalLength(["selectedCoins.length == optimalCount"])
    reachedOptimalLength --> rolYes(((yes)))
    reachedOptimalLength --> rolNo(((no)))
    rolNo --> addCoinOpt

    rolYes --> amountGteFeeOptimal(["amount >= maxFee"])
    amountGteFeeOptimal --> agfoYes(((yes)))
    amountGteFeeOptimal --> agfoNo(((no)))

    agfoYes --> returnOptimal{{return coins}}

    agfoNo --> coinsRemaining([coins remaining?])
    coinsRemaining --> crNo(((no)))
    coinsRemaining --> crYes(((yes)))

    crYes --> shiftCoins([shift selectedCoins]) --> addCoinOpt
    crNo --> returnOptimal

    %% Max coins selection
    maxCoinsRoot --> sortCoinsDesc(["sort coins (desc)"])
    sortCoinsDesc --> iterateMax[Iterate]
    iterateMax --> addCoinMax([add coin]) --> amountGteFeeMax(["amount >= maxFee"])
    amountGteFeeMax --> agfmYes(((yes)))
    amountGteFeeMax --> agfmNo(((no)))

    agfmYes ---> returnMax{{return coins}}

    agfmNo --> reachedMaxLength(["selectedCoins.length == maxInputs - 2"])
    reachedMaxLength --> rmlYes(((yes)))
    reachedMaxLength --> rmlNo(((no)))

    rmlYes --> returnMax
    rmlNo --> addCoinMax

classDef Error stroke:red, fill:none, color:red;
class throw Error;

classDef ReturnCoins stroke:#00d5ff, fill:none, color:#00d5ff;
class return ReturnCoins;
class returnOptimal ReturnCoins;
class returnMax ReturnCoins;