fixed formatting

This commit fixes the icon color in the missing keypair section

Signed-off-by: Mohamed Javid <19339952+smohamedjavid@users.noreply.github.com>

src/quo/components/list_items/missing_keypair/view.cljs

@@ -28,7 +28,6 @@
                   :seed :i/seed
                   :key  :i/password
                   nil)
-       :color   :neutral
        :blur?   true
        :border? true}]
      [rn/view

src/status_im/contexts/wallet/bridge/bridge_to/view.cljs

@@ -15,7 +15,7 @@
 
 (defn- bridge-token-component
   []
-  (fn [{:keys [chain-id network-name]} {:keys [networks] :as token}]
+  (fn [{:keys [chain-id network-name]} {:keys [supported-networks] :as token}]
     (let [network                     (rf/sub [:wallet/network-details-by-chain-id chain-id])
           currency                    (rf/sub [:profile/currency])
           currency-symbol             (rf/sub [:profile/currency-symbol])
@@ -28,7 +28,8 @@
           fiat-formatted              (utils/get-standard-fiat-format crypto-value
                                                                       currency-symbol
                                                                       fiat-value)
-          token-available-on-network? (network-utils/token-available-on-network? networks chain-id)]
+          token-available-on-network? (network-utils/token-available-on-network? supported-networks
+                                                                                 chain-id)]
       [quo/network-list
        {:label         (name network-name)
         :network-image (quo.resources/get-network (:network-name network))
@@ -49,7 +50,10 @@
         mainnet          (first network-details)
         layer-2-networks (rest network-details)
         account-token    (some #(when (= token-symbol (:symbol %)) %) tokens)
-        account-token    (when account-token (assoc account-token :networks (:networks token)))
+        account-token    (when account-token
+                           (assoc account-token
+                                  :networks           (:networks token)
+                                  :supported-networks (:supported-networks token)))
         bridge-to-title  (i18n/label :t/bridge-to
                                      {:name (string/upper-case (str token-symbol))})]
 

src/status_im/contexts/wallet/bridge/input_amount/view.cljs

@@ -10,17 +10,14 @@
   []
   [rn/view {:style style/bridge-send-wrapper}
    [input-amount/view
-    {:current-screen-id      :screen/wallet.bridge-input-amount
-     :button-one-label       (i18n/label :t/review-bridge)
-     :button-one-props       {:icon-left :i/bridge}
-     :enabled-from-chain-ids (rf/sub
-                              [:wallet/bridge-from-chain-ids])
-     :from-enabled-networks  (rf/sub [:wallet/bridge-from-networks])
-     :on-confirm             (fn [amount]
-                               (rf/dispatch [:wallet/set-token-amount-to-bridge
-                                             {:amount   amount
-                                              :stack-id :screen/wallet.bridge-input-amount}]))
-     :on-navigate-back       (fn []
-                               (rf/dispatch-sync [:wallet/stop-and-clean-suggested-routes])
-                               (rf/dispatch [:wallet/clean-disabled-from-networks])
-                               (rf/dispatch [:wallet/clean-send-amount]))}]])
+    {:current-screen-id :screen/wallet.bridge-input-amount
+     :button-one-label  (i18n/label :t/review-bridge)
+     :button-one-props  {:icon-left :i/bridge}
+     :on-confirm        (fn [amount]
+                          (rf/dispatch [:wallet/set-token-amount-to-bridge
+                                        {:amount   amount
+                                         :stack-id :screen/wallet.bridge-input-amount}]))
+     :on-navigate-back  (fn []
+                          (rf/dispatch-sync [:wallet/stop-and-clean-suggested-routes])
+                          (rf/dispatch [:wallet/clean-disabled-from-networks])
+                          (rf/dispatch [:wallet/clean-send-amount]))}]])

src/status_im/contexts/wallet/common/utils.cljs

@@ -27,12 +27,18 @@
   [balance]
   (cut-fiat-balance balance 2))
 
-(defn prettify-balance
-  [currency-symbol balance]
+(defn prepend-curency-symbol-to-fiat-balance
+  [fiat-balance currency-symbol]
   (let [formatted-symbol (if (> (count currency-symbol) 1)
                            (str currency-symbol " ")
                            currency-symbol)]
-    (str formatted-symbol (cut-fiat-balance-to-two-decimals balance))))
+    (str formatted-symbol fiat-balance)))
+
+(defn prettify-balance
+  [currency-symbol fiat-balance]
+  (-> fiat-balance
+      cut-fiat-balance-to-two-decimals
+      (prepend-curency-symbol-to-fiat-balance currency-symbol)))
 
 (defn get-derivation-path
   [number-of-accounts]
@@ -104,11 +110,15 @@
       :else                          (number/remove-trailing-zeroes
                                       (.toFixed token-units standardized-decimals-count)))))
 
+(defn add-token-symbol-to-crypto-balance
+  [crypto-balance token-symbol]
+  (str crypto-balance " " (string/upper-case token-symbol)))
+
 (defn prettify-crypto-balance
   [token-symbol crypto-balance conversion-rate]
-  (str (cut-crypto-decimals-to-fit-usd-cents crypto-balance conversion-rate)
-       " "
-       (string/upper-case token-symbol)))
+  (-> crypto-balance
+      (cut-crypto-decimals-to-fit-usd-cents conversion-rate)
+      (add-token-symbol-to-crypto-balance token-symbol)))
 
 (defn get-standard-crypto-format
   "For full details: https://github.com/status-im/status-mobile/issues/18225"
@@ -522,9 +532,10 @@
   [tokens networks chain-ids]
   (map (fn [token]
          (assoc token
-                :networks          (network-utils/network-list token networks)
-                :available-balance (calculate-total-token-balance token)
-                :total-balance     (calculate-total-token-balance token chain-ids)))
+                :networks           (network-utils/network-list-with-positive-balance token networks)
+                :supported-networks (network-utils/network-list token networks)
+                :available-balance  (calculate-total-token-balance token)
+                :total-balance      (calculate-total-token-balance token chain-ids)))
        tokens))
 
 (defn estimated-time-format

src/status_im/contexts/wallet/data_store.cljs

@@ -72,11 +72,32 @@
       (update :testPreferredChainIds chain-ids-set->string)
       (dissoc :watch-only? :default-account? :operable? :tokens :collectibles)))
 
+(defn add-missing-balance-per-chain-values
+  "Adds any missing chain balance (0) to the balance-per-chain map based on token supported chains as
+   status-go returns balance for that chain only if the balance is positive."
+  [balances-per-chain supported-chains]
+  (let [zero-balance-per-chain (fn [chain-id]
+                                 {:chain-id    chain-id
+                                  :raw-balance (money/->bignumber 0)
+                                  :balance     "0"})]
+    (reduce
+     (fn [result chain-id]
+       (if (contains? result chain-id)
+         result
+         (assoc result chain-id (zero-balance-per-chain chain-id))))
+     balances-per-chain
+     supported-chains)))
+
 (defn- rpc->balances-per-chain
-  [token]
+  [token supported-chains]
   (-> token
       (update :balances-per-chain update-vals #(update % :raw-balance money/bignumber))
-      (update :balances-per-chain update-keys (comp utils.number/parse-int name))))
+      (update :balances-per-chain update-keys (comp utils.number/parse-int name))
+      (update :balances-per-chain #(add-missing-balance-per-chain-values % supported-chains))))
+
+(defn- update-balances-per-chain
+  [tokens supported-chains-by-token-symbol]
+  (mapv #(rpc->balances-per-chain % (get supported-chains-by-token-symbol (:symbol %))) tokens))
 
 (defn- remove-tokens-with-empty-values
   [tokens]
@@ -85,12 +106,12 @@
    tokens))
 
 (defn rpc->tokens
-  [tokens]
+  [tokens supported-chains-by-token-symbol]
   (-> tokens
       (update-keys name)
       (update-vals #(cske/transform-keys transforms/->kebab-case-keyword %))
       (update-vals remove-tokens-with-empty-values)
-      (update-vals #(mapv rpc->balances-per-chain %))))
+      (update-vals #(update-balances-per-chain % supported-chains-by-token-symbol))))
 
 (defn rpc->network
   [network]

src/status_im/contexts/wallet/db.cljs

@@ -11,4 +11,7 @@
         ;; in and the device is offline, versus re-fetching when offline and
         ;; tokens already exist in the app-db.
         :tokens-loading nil
-        :active-tab     :assets}})
+        :active-tab     :assets
+        :screens        {:input-amount-screen
+                         {:crypto-currency? true
+                          :input-value      ""}}}})

src/status_im/contexts/wallet/events.cljs

@@ -229,14 +229,17 @@
 (rf/reg-event-fx
  :wallet/store-wallet-token
  (fn [{:keys [db]} [address raw-tokens-data]]
-   (let [tokens     (data-store/rpc->tokens raw-tokens-data)
-         add-tokens (fn [stored-accounts tokens-per-account]
-                      (reduce-kv (fn [accounts address tokens-data]
-                                   (if (contains? accounts address)
-                                     (update accounts address assoc :tokens tokens-data)
-                                     accounts))
-                                 stored-accounts
-                                 tokens-per-account))]
+   (let [supported-chains-by-token-symbol (get-in db [:wallet :tokens :supported-chains-by-symbol])
+         tokens                           (data-store/rpc->tokens raw-tokens-data
+                                                                  supported-chains-by-token-symbol)
+         add-tokens                       (fn [stored-accounts tokens-per-account]
+                                            (reduce-kv
+                                             (fn [accounts address tokens-data]
+                                               (if (contains? accounts address)
+                                                 (update accounts address assoc :tokens tokens-data)
+                                                 accounts))
+                                             stored-accounts
+                                             tokens-per-account))]
      {:db (-> db
               (update-in [:wallet :accounts] add-tokens tokens)
               (assoc-in [:wallet :ui :tokens-loading address] false))})))

src/status_im/contexts/wallet/send/events.cljs

@@ -53,7 +53,7 @@
            token-decimals                (if collectible 0 (:decimals token))
            native-token?                 (and token (= token-display-name "ETH"))
            routes-available?             (pos? (count chosen-route))
-           token-networks                (:networks token)
+           token-networks                (:supported-networks token)
            token-networks-ids            (when token-networks
                                            (map #(:chain-id %) token-networks))
            from-network-amounts-by-chain (send-utils/network-amounts-by-chain
@@ -190,17 +190,21 @@
    ;; `token` is a map extracted from the sender, but in the wallet home page we don't know the
    ;; sender yet, so we only provide the `token-symbol`, later in
    ;; `:wallet/select-from-account` the `token` key will be set.
-   (let [{:keys [networks]}  token
-         receiver-networks   (get-in db [:wallet :ui :send :receiver-networks])
-         token-networks-ids  (map :chain-id networks)
-         unsupported-token?  (not-any? (set receiver-networks) token-networks-ids)
-         unique-owner        (when (= (count owners) 1)
-                               (first owners))
-         unique-owner-tokens (get-in db [:wallet :accounts unique-owner :tokens])
-         token-data          (or token
-                                 (when (and token-symbol unique-owner)
-                                   (some #(when (= (:symbol %) token-symbol) %)
-                                         unique-owner-tokens)))]
+   (let [{:keys [networks]}     token
+         receiver-networks      (get-in db [:wallet :ui :send :receiver-networks])
+         token-networks-ids     (map :chain-id networks)
+         unsupported-token?     (not-any? (set receiver-networks) token-networks-ids)
+         unique-owner           (when (= (count owners) 1)
+                                  (first owners))
+         unique-owner-tokens    (get-in db [:wallet :accounts unique-owner :tokens])
+         token-data             (or token
+                                    (when (and token-symbol unique-owner)
+                                      (some #(when (= (:symbol %) token-symbol) %)
+                                            unique-owner-tokens)))
+         test-networks-enabled? (get-in db [:profile/profile :test-networks-enabled?])
+         network-details        (-> (get-in db
+                                            [:wallet :networks (if test-networks-enabled? :test :prod)])
+                                    (network-utils/sorted-networks-with-details))]
      (when (or token-data token-symbol)
        {:db (cond-> db
               :always      (update-in [:wallet :ui :send]
@@ -211,7 +215,11 @@
               token-symbol (assoc-in [:wallet :ui :send :token-symbol] token-symbol)
               token-data   (update-in [:wallet :ui :send]
                                       #(assoc %
-                                              :token              token-data
+                                              :token              (assoc token-data
+                                                                         :supported-networks
+                                                                         (network-utils/network-list
+                                                                          token-data
+                                                                          network-details))
                                               :token-display-name (:symbol token-data)))
               unique-owner (assoc-in [:wallet :current-viewing-account-address] unique-owner)
               entry-point  (assoc-in [:wallet :ui :send :entry-point] entry-point))
@@ -230,7 +238,7 @@
 (rf/reg-event-fx
  :wallet/edit-token-to-send
  (fn [{:keys [db]} [token]]
-   (let [{token-networks :networks
+   (let [{token-networks :supported-networks
           token-symbol   :symbol}                  token
          receiver-networks                         (get-in db [:wallet :ui :send :receiver-networks])
          token-networks-ids                        (map :chain-id token-networks)
@@ -426,7 +434,7 @@
             {:balances-per-chain balances-per-chain
              :disabled-chain-ids disabled-from-chain-ids
              :only-with-balance? false}))
-         token-networks-ids (when token (map #(:chain-id %) (:networks token)))
+         token-networks-ids (when token (map #(:chain-id %) (:supported-networks token)))
          sender-network-values (when sender-token-available-networks-for-suggested-routes
                                  (send-utils/loading-network-amounts
                                   {:valid-networks
@@ -708,7 +716,11 @@
                              ;; account, so we extract the token data from the picked account.
                              (let [token (utils/get-token-from-account db token-symbol address)]
                                (assoc token
-                                      :networks      (network-utils/network-list token network-details)
+                                      :networks (network-utils/network-list-with-positive-balance
+                                                 token
+                                                 network-details)
+                                      :supported-networks (network-utils/network-list token
+                                                                                      network-details)
                                       :total-balance (utils/calculate-total-token-balance token))))
          bridge-tx?        (= tx-type :tx/bridge)
          flow-id           (if bridge-tx?

src/status_im/contexts/wallet/send/events_test.cljs

@@ -79,11 +79,14 @@
 (h/deftest-event :wallet/edit-token-to-send
   [event-id dispatch]
   (let [token-symbol      "ETH"
-        token             {:symbol   "ETH"
-                           :name     "Ether"
-                           :networks #{{:chain-id 421614}
-                                       {:chain-id 11155420}
-                                       {:chain-id 11155111}}}
+        token             {:symbol             "ETH"
+                           :name               "Ether"
+                           :networks           #{{:chain-id 421614}
+                                                 {:chain-id 11155420}
+                                                 {:chain-id 11155111}}
+                           :supported-networks #{{:chain-id 421614}
+                                                 {:chain-id 11155420}
+                                                 {:chain-id 11155111}}}
         receiver-networks [421614 11155420]]
     (testing "can be called with :token"
       (let [initial-db  {:wallet {:ui {:send {:receiver-networks receiver-networks

src/status_im/contexts/wallet/send/input_amount/component_spec.cljs

@@ -104,7 +104,7 @@
    :wallet/wallet-send-tx-type                     :tx/send
    :wallet/wallet-send-fee-fiat-formatted          "$5,00"
    :wallet/sending-collectible?                    false
-   :wallet/total-amount                            (money/bignumber "250")})
+   :wallet/total-amount-in-to-chains               (money/bignumber "250")})
 
 (h/describe "Send > input amount screen"
   (h/setup-restorable-re-frame)

src/status_im/contexts/wallet/send/input_amount/controlled_input_logic.cljs

@@ -0,0 +1,75 @@
+(ns status-im.contexts.wallet.send.input-amount.controlled-input-logic
+  (:require
+    [clojure.string :as string]
+    [utils.money :as money]))
+
+(def ^:private default-max-limit 12)
+
+(def ^:private not-digits-or-dot-pattern
+  #"[^0-9+\.]")
+
+(def ^:private dot ".")
+
+(defn- can-add-character?
+  [input-value character max-length]
+  (let [length-overflow?    (>= (count input-value) max-length)
+        extra-dot?          (and (= character dot) (string/includes? input-value dot))
+        extra-leading-zero? (and (= input-value "0") (= "0" (str character)))
+        non-numeric?        (re-find not-digits-or-dot-pattern (str character))]
+    (not (or non-numeric? extra-dot? extra-leading-zero? length-overflow?))))
+
+(defn- normalize-value-as-numeric
+  [value character]
+  (cond
+    (and (string/blank? value) (= character dot))
+    (str "0" character)
+
+    (and (= value "0") (not= character dot))
+    (str character)
+
+    :else
+    (str value character)))
+
+(defn add-character
+  ([input-value character]
+   (add-character input-value character default-max-limit))
+  ([input-value character max-length]
+   (if (can-add-character? input-value character max-length)
+     (normalize-value-as-numeric input-value character)
+     input-value)))
+
+(defn delete-last
+  ([input-value]
+   (delete-last input-value ""))
+  ([input-value default-value]
+   (let [new-value (subs input-value 0 (dec (count input-value)))]
+     (if (string/blank? new-value)
+       default-value
+       new-value))))
+
+(defn upper-limit-exceeded?
+  [input-value upper-limit]
+  (and upper-limit
+       (when (money/bignumber? (money/bignumber input-value))
+         (money/greater-than (money/bignumber input-value) (money/bignumber upper-limit)))))
+
+(defn lower-limit-exceeded?
+  [input-value lower-limit]
+  (and lower-limit
+       (when (money/bignumber? (money/bignumber input-value))
+         (money/less-than (money/bignumber input-value) (money/bignumber lower-limit)))))
+
+(defn value-out-of-limits?
+  [input-value upper-limit lower-limit]
+  (or (upper-limit-exceeded? input-value upper-limit)
+      (lower-limit-exceeded? input-value lower-limit)))
+
+(defn value-numeric
+  [input-value]
+  (or (parse-double input-value) 0))
+
+(defn empty-value?
+  [input-value]
+  (or (string/blank? input-value) (<= (value-numeric input-value) 0)))
+
+

src/status_im/contexts/wallet/send/input_amount/events.cljs

@@ -0,0 +1,36 @@
+(ns status-im.contexts.wallet.send.input-amount.events
+  (:require
+    [status-im.contexts.wallet.send.input-amount.controlled-input-logic :as controlled-input-logic]
+    [utils.re-frame :as rf]))
+
+(def input-value-path [:wallet :ui :screens :input-amount-screen :input-value])
+(def crypto-currency?-path [:wallet :ui :screens :input-amount-screen :crypto-currency?])
+
+(rf/reg-event-fx :send-input-amount-screen/set-token-input-value
+ (fn [{:keys [db]} [v]]
+   {:db (assoc-in db input-value-path v)}))
+
+(rf/reg-event-fx :send-input-amount-screen/swap-between-fiat-and-crypto
+ (fn [{:keys [db]} [token-input-converted-value]]
+   {:db (update-in db crypto-currency?-path not)
+    :fx [[:dispatch
+          [:send-input-amount-screen/set-token-input-value token-input-converted-value]]]}))
+
+(rf/reg-event-fx :send-input-amount-screen/token-input-add-character
+ (fn [{:keys [db]} [c max-decimals]]
+   (let [input-value   (get-in db input-value-path)
+         new-text      (str input-value c)
+         regex-pattern (str "^\\d*\\.?\\d{0," max-decimals "}$")
+         regex         (re-pattern regex-pattern)]
+     (when (re-matches regex new-text)
+       {:db (update-in db input-value-path #(controlled-input-logic/add-character % c))}))))
+
+(rf/reg-event-fx :send-input-amount-screen/token-input-delete-last
+ (fn [{:keys [db]}]
+   {:db (update-in db input-value-path controlled-input-logic/delete-last)}))
+
+(rf/reg-event-fx :send-input-amount-screen/token-input-delete-all
+ (fn [{:keys [db]}]
+   {:db (assoc-in db input-value-path "")}))
+
+

src/status_im/contexts/wallet/send/input_amount/view.cljs

@@ -1,67 +1,56 @@
 (ns status-im.contexts.wallet.send.input-amount.view
   (:require
-    [clojure.string :as string]
     [quo.core :as quo]
     [quo.foundations.colors :as colors]
     [quo.theme]
     [react-native.core :as rn]
     [react-native.safe-area :as safe-area]
-    [status-im.common.controlled-input.utils :as controlled-input]
-    [status-im.constants :as constants]
     [status-im.contexts.wallet.common.account-switcher.view :as account-switcher]
     [status-im.contexts.wallet.common.asset-list.view :as asset-list]
-    [status-im.contexts.wallet.common.utils :as utils]
+    [status-im.contexts.wallet.send.input-amount.events]
     [status-im.contexts.wallet.send.input-amount.style :as style]
     [status-im.contexts.wallet.send.routes.view :as routes]
     [status-im.contexts.wallet.sheets.buy-token.view :as buy-token]
     [status-im.contexts.wallet.sheets.unpreferred-networks-alert.view :as unpreferred-networks-alert]
     [status-im.feature-flags :as ff]
     [status-im.setup.hot-reload :as hot-reload]
+    [status-im.subs.wallet.screens.input-amount]
     [utils.debounce :as debounce]
     [utils.i18n :as i18n]
-    [utils.money :as money]
-    [utils.number :as number]
     [utils.re-frame :as rf]))
 
 (defn- estimated-fees
-  [{:keys [loading-routes? fees amount]}]
-  [rn/view {:style style/estimated-fees-container}
-   (when (ff/enabled? ::ff/wallet.advanced-sending)
-     [rn/view {:style style/estimated-fees-content-container}
-      [quo/button
-       {:icon-only?          true
-        :type                :outline
-        :size                32
-        :inner-style         {:opacity 1}
-        :accessibility-label :advanced-button
-        :disabled?           loading-routes?
-        :on-press            #(js/alert "Not implemented yet")}
-       :i/advanced]])
-   [quo/data-item
-    {:container-style style/fees-data-item
-     :status          (if loading-routes? :loading :default)
-     :size            :small
-     :title           (i18n/label :t/fees)
-     :subtitle        fees}]
-   [quo/data-item
-    {:container-style style/amount-data-item
-     :status          (if loading-routes? :loading :default)
-     :size            :small
-     :title           (i18n/label :t/recipient-gets)
-     :subtitle        amount}]])
-
-(defn- every-network-value-is-zero?
-  [sender-network-values]
-  (every? (fn [{:keys [total-amount]}]
-            (and
-             total-amount
-             (money/bignumber? total-amount)
-             (money/equal-to total-amount
-                             (money/bignumber "0"))))
-          sender-network-values))
+  []
+  (let [loading-routes? (rf/sub [:wallet/wallet-send-loading-suggested-routes?])
+        fees            (rf/sub [:send-input-amount-screen/fee-formatted])
+        amount          (rf/sub [:send-input-amount-screen/recipient-gets-amount])]
+    [rn/view {:style style/estimated-fees-container}
+     (when (ff/enabled? ::ff/wallet.advanced-sending)
+       [rn/view {:style style/estimated-fees-content-container}
+        [quo/button
+         {:icon-only?          true
+          :type                :outline
+          :size                32
+          :inner-style         {:opacity 1}
+          :accessibility-label :advanced-button
+          :disabled?           loading-routes?
+          :on-press            #(js/alert "Not implemented yet")}
+         :i/advanced]])
+     [quo/data-item
+      {:container-style style/fees-data-item
+       :status          (if loading-routes? :loading :default)
+       :size            :small
+       :title           (i18n/label :t/fees)
+       :subtitle        fees}]
+     [quo/data-item
+      {:container-style style/amount-data-item
+       :status          (if loading-routes? :loading :default)
+       :size            :small
+       :title           (i18n/label :t/recipient-gets)
+       :subtitle        amount}]]))
 
 (defn select-asset-bottom-sheet
-  [clear-input!]
+  []
   (let [{preselected-token-symbol :symbol} (rf/sub [:wallet/wallet-send-token])]
     [:<> ;; Need to be a `:<>` to keep `asset-list` scrollable.
      [quo/drawer-top
@@ -73,15 +62,19 @@
        :preselected-token-symbol preselected-token-symbol
        :on-token-press           (fn [token]
                                    (rf/dispatch [:wallet/edit-token-to-send token])
-                                   (clear-input!))}]]))
+                                   (rf/dispatch
+                                    [:send-input-amount-screen/token-input-delete-all]))}]]))
 
 (defn- token-not-available
-  [token-symbol receiver-networks token-networks]
-  (let [theme              (quo.theme/use-theme)
-        add-token-networks (fn []
-                             (let [chain-ids (concat receiver-networks
-                                                     (mapv #(:chain-id %) token-networks))]
-                               (rf/dispatch [:wallet/update-receiver-networks chain-ids])))]
+  []
+  (let [theme                      (quo.theme/use-theme)
+        {token-symbol   :symbol
+         token-networks :networks} (rf/sub [:wallet/wallet-send-token])
+        receiver-networks          (rf/sub [:wallet/wallet-send-receiver-networks])
+        add-token-networks         (fn []
+                                     (let [chain-ids (concat receiver-networks
+                                                             (mapv #(:chain-id %) token-networks))]
+                                       (rf/dispatch [:wallet/update-receiver-networks chain-ids])))]
     [rn/view {:style (style/token-not-available-container theme)}
      [rn/view
       [quo/icon :i/alert
@@ -140,163 +133,117 @@
 
     :else (rf/dispatch [:wallet/stop-and-clean-suggested-routes])))
 
-(defn- get-fee-formatted
-  [route]
-  (when-let [native-currency-symbol (-> route first :from :native-currency-symbol)]
-    (rf/sub [:wallet/wallet-send-fee-fiat-formatted native-currency-symbol])))
+(defn token-input
+  []
+  (let [show-select-asset-sheet                #(rf/dispatch
+                                                 [:show-bottom-sheet
+                                                  {:content (fn [] [select-asset-bottom-sheet])}])
+        {:keys [input-value crypto-currency?]} (rf/sub [:send-input-amount-screen/state])
+        from-enabled-networks                  (rf/sub [:send-input-amount-screen/from-enabled-networks])
+        {fiat-currency :currency}              (rf/sub [:profile/profile])
+        {token-symbol :symbol}                 (rf/sub [:wallet/wallet-send-token])
+        input-value-converted                  (rf/sub [:send-input-amount-screen/input-value-converted])
+        converted-value-prettified             (rf/sub
+                                                [:send-input-amount-screen/converted-value-prettified])
+        value-out-of-limits?                   (rf/sub [:send-input-amount-screen/value-out-of-limits?])
+        upper-limit-prettified                 (rf/sub
+                                                [:send-input-amount-screen/upper-limit-prettified])]
+    [quo/token-input
+     {:container-style style/input-container
+      :token-symbol    token-symbol
+      :value           input-value
+      :on-swap         #(rf/dispatch [:send-input-amount-screen/swap-between-fiat-and-crypto
+                                      input-value-converted])
+      :on-token-press  show-select-asset-sheet
+      :error?          value-out-of-limits?
+      :currency-symbol (if crypto-currency? token-symbol fiat-currency)
+      :converted-value converted-value-prettified
+      :hint-component  [quo/network-tags
+                        {:networks (seq from-enabled-networks)
+                         :title    (i18n/label
+                                    :t/send-limit
+                                    {:limit upper-limit-prettified})
+                         :status   (when value-out-of-limits? :error)}]}]))
+(defn routes-view
+  [current-screen-id]
+  (let [token-by-symbol                (rf/sub [:send-input-amount-screen/token-by-symbol])
+        token                          (rf/sub [:wallet/wallet-send-token])
+        routes                         (rf/sub [:send-input-amount-screen/routes])
+        valid-input?                   (rf/sub [:send-input-amount-screen/valid-input?])
+        amount-in-crypto               (rf/sub [:send-input-amount-screen/amount-in-crypto])
+        limit-exceeded?                (rf/sub [:send-input-amount-screen/upper-limit-exceeded?])
+        unsupported-token-in-receiver? (rf/sub
+                                        [:send-input-amount-screen/unsupported-token-in-receiver?])
+        request-fetch-routes           (fn [bounce-duration-ms]
+                                         (fetch-routes
+                                          {:amount                 amount-in-crypto
+                                           :valid-input?           valid-input?
+                                           :bounce-duration-ms     bounce-duration-ms
+                                           :token                  token
+                                           :reset-amounts-to-zero? (and limit-exceeded?
+                                                                        (some? routes))}))]
+    [routes/view
+     {:token                                     token-by-symbol
+      :send-amount-in-crypto                     amount-in-crypto
+      :valid-input?                              valid-input?
+      :token-not-supported-in-receiver-networks? unsupported-token-in-receiver?
+      :current-screen-id                         current-screen-id
+      :request-fetch-routes                      request-fetch-routes}]))
+
+(defn bottom-actions
+  [button-one-label button-one-props on-confirm]
+  (let [token-by-symbol                  (rf/sub [:send-input-amount-screen/token-by-symbol])
+        loading-routes?                  (rf/sub [:wallet/wallet-send-loading-suggested-routes?])
+        amount-in-crypto                 (rf/sub [:send-input-amount-screen/amount-in-crypto])
+        sending-to-unpreferred-networks? (rf/sub
+                                          [:send-input-amount-screen/sending-to-unpreferred-networks?])
+        current-color                    (rf/sub [:wallet/current-viewing-account-color])
+        not-enough-asset?                (rf/sub [:send-input-amount-screen/not-enough-asset?])
+        should-try-again?                (rf/sub [:send-input-amount-screen/should-try-again?])
+        confirm-disabled?                (rf/sub [:send-input-amount-screen/confirm-disabled?])]
+    [quo/bottom-actions
+     {:actions          :one-action
+      :button-one-label (if should-try-again?
+                          (i18n/label :t/try-again)
+                          button-one-label)
+      :button-one-props (merge (when-not should-try-again?
+                                 button-one-props)
+                               {:disabled?           (or not-enough-asset?
+                                                         loading-routes?
+                                                         (and (not should-try-again?)
+                                                              confirm-disabled?))
+                                :on-press            (cond
+                                                       should-try-again?
+                                                       #(rf/dispatch [:wallet/start-get-suggested-routes
+                                                                      {:amount        amount-in-crypto
+                                                                       :updated-token token-by-symbol}])
+                                                       sending-to-unpreferred-networks?
+                                                       #(show-unpreferred-networks-alert on-confirm)
+                                                       :else
+                                                       #(on-confirm amount-in-crypto))
+                                :customization-color current-color}
+                               (when should-try-again?
+                                 {:type :grey}))}]))
 
-(defn- insufficient-asset-amount?
-  [{:keys [token-symbol owned-eth-token input-state no-routes-found? limit-exceeded?
-           sender-network-values enough-assets?]}]
-  (let [eth-selected?              (= token-symbol (string/upper-case constants/mainnet-short-name))
-        zero-owned-eth?            (money/equal-to (:total-balance owned-eth-token) 0)
-        input-at-max-owned-amount? (money/equal-to
-                                    (controlled-input/value-bn input-state)
-                                    (controlled-input/upper-limit-bn input-state))
-        exceeded-input?            (if eth-selected?
-                                     input-at-max-owned-amount?
-                                     zero-owned-eth?)]
-    (and (or no-routes-found? limit-exceeded?)
-         (seq sender-network-values)
-         (or exceeded-input? (not enough-assets?)))))
 
 (defn view
   ;; crypto-decimals, limit-crypto and initial-crypto-currency? args are needed
   ;; for component tests only
-  [{default-on-confirm       :on-confirm
-    default-limit-crypto     :limit-crypto
-    default-crypto-decimals  :crypto-decimals
-    on-navigate-back         :on-navigate-back
-    button-one-label         :button-one-label
-    button-one-props         :button-one-props
-    current-screen-id        :current-screen-id
-    initial-crypto-currency? :initial-crypto-currency?
-    enabled-from-chain-ids   :enabled-from-chain-ids
-    from-enabled-networks    :from-enabled-networks
-    :or                      {initial-crypto-currency? true}}]
-  (let [view-id                          (rf/sub [:view-id])
-        active-screen?                   (= view-id current-screen-id)
-        bottom                           (safe-area/get-bottom)
-        [crypto-currency?
-         set-crypto-currency]            (rn/use-state initial-crypto-currency?)
-        handle-on-confirm                (fn [amount]
-                                           (rf/dispatch [:wallet/set-token-amount-to-send
-                                                         {:amount   amount
-                                                          :stack-id current-screen-id}]))
-        {fiat-currency :currency}        (rf/sub [:profile/profile])
-        {token-symbol   :symbol
-         token-networks :networks
-         :as            token}           (rf/sub [:wallet/wallet-send-token])
-        send-from-locked-amounts         (rf/sub [:wallet/wallet-send-from-locked-amounts])
-        {:keys [total-balance]
-         :as   token-by-symbol}          (rf/sub [:wallet/token-by-symbol
-                                                  (str token-symbol)
-                                                  enabled-from-chain-ids])
-        token-balance                    (or default-limit-crypto total-balance)
-        usd-conversion-rate              (utils/token-usd-price token)
-        currency                         (rf/sub [:profile/currency])
-        conversion-rate                  (-> token
-                                             :market-values-per-currency
-                                             currency
-                                             :price)
-        token-decimals                   (-> token
-                                             utils/token-usd-price
-                                             utils/one-cent-value
-                                             utils/calc-max-crypto-decimals)
-        [input-state set-input-state]    (rn/use-state controlled-input/init-state)
-        clear-input!                     #(set-input-state controlled-input/delete-all)
-        currency-symbol                  (rf/sub [:profile/currency-symbol])
-        loading-routes?                  (rf/sub [:wallet/wallet-send-loading-suggested-routes?])
-        route                            (rf/sub [:wallet/wallet-send-route])
-        on-confirm                       (or default-on-confirm handle-on-confirm)
-        crypto-decimals                  (or token-decimals default-crypto-decimals)
-        max-limit                        (if crypto-currency?
-                                           (utils/cut-crypto-decimals-to-fit-usd-cents
-                                            token-balance
-                                            usd-conversion-rate)
-                                           (utils/cut-fiat-balance-to-two-decimals
-                                            (money/crypto->fiat token-balance conversion-rate)))
-        input-value                      (controlled-input/input-value input-state)
-        valid-input?                     (not (or (controlled-input/empty-value? input-state)
-                                                  (controlled-input/input-error input-state)))
-        amount-in-crypto                 (if crypto-currency?
-                                           input-value
-                                           (number/remove-trailing-zeroes
-                                            (.toFixed (/ input-value conversion-rate)
-                                                      crypto-decimals)))
-        total-amount-receiver            (rf/sub [:wallet/total-amount true])
-        amount-text                      (str (number/remove-trailing-zeroes
-                                               (.toFixed total-amount-receiver
-                                                         (min token-decimals 6)))
-                                              " "
-                                              token-symbol)
-        show-select-asset-sheet          #(rf/dispatch
-                                           [:show-bottom-sheet
-                                            {:content (fn []
-                                                        [select-asset-bottom-sheet
-                                                         clear-input!])}])
-        sender-network-values            (rf/sub [:wallet/wallet-send-sender-network-values])
-        receiver-network-values          (rf/sub [:wallet/wallet-send-receiver-network-values])
-        tx-type                          (rf/sub [:wallet/wallet-send-tx-type])
-        unsupported-token-in-receiver?   (and (not= tx-type :tx/bridge)
-                                              (->> receiver-network-values
-                                                   (remove #(= (:type %) :add))
-                                                   (every? #(= (:type %) :not-available))))
-        suggested-routes                 (rf/sub [:wallet/wallet-send-suggested-routes])
-        routes                           (when suggested-routes
-                                           (or (:best suggested-routes) []))
-        no-routes-found?                 (and
-                                          (every-network-value-is-zero? sender-network-values)
-                                          (some? routes)
-                                          (not loading-routes?)
-                                          (not unsupported-token-in-receiver?))
-        receiver-networks                (rf/sub [:wallet/wallet-send-receiver-networks])
-        receiver-preferred-networks      (rf/sub [:wallet/wallet-send-receiver-preferred-networks])
-        receiver-preferred-network?      (set receiver-preferred-networks)
-        sending-to-unpreferred-networks? (some (comp not receiver-preferred-network?)
-                                               receiver-networks)
-        input-error                      (controlled-input/input-error input-state)
-        limit-exceeded?                  (controlled-input/upper-limit-exceeded? input-state)
-        current-address                  (rf/sub [:wallet/current-viewing-account-address])
-        current-color                    (rf/sub [:wallet/current-viewing-account-color])
-        enough-assets?                   (rf/sub [:wallet/wallet-send-enough-assets?])
-        owned-eth-token                  (rf/sub [:wallet/token-by-symbol
-                                                  (string/upper-case constants/mainnet-short-name)
-                                                  enabled-from-chain-ids])
-        not-enough-asset?                (insufficient-asset-amount?
-                                          {:enough-assets?        enough-assets?
-                                           :token-symbol          token-symbol
-                                           :owned-eth-token       owned-eth-token
-                                           :input-state           input-state
-                                           :no-routes-found?      no-routes-found?
-                                           :limit-exceeded?       limit-exceeded?
-                                           :sender-network-values sender-network-values})
-        should-try-again?                (and (not limit-exceeded?)
-                                              no-routes-found?
-                                              (not not-enough-asset?))
-        show-no-routes?                  (and (or no-routes-found? limit-exceeded?)
-                                              (not-empty sender-network-values)
-                                              (not not-enough-asset?))
-        confirm-disabled?                (or (nil? route)
-                                             (empty? route)
-                                             (not valid-input?))
-        fee-formatted                    (when (or (not confirm-disabled?) not-enough-asset?)
-                                           (get-fee-formatted route))
-        request-fetch-routes             (fn [bounce-duration-ms]
-                                           (fetch-routes
-                                            {:amount                 amount-in-crypto
-                                             :valid-input?           valid-input?
-                                             :bounce-duration-ms     bounce-duration-ms
-                                             :token                  token
-                                             :reset-amounts-to-zero? (and limit-exceeded?
-                                                                          (some? routes))}))
-        swap-between-fiat-and-crypto     (fn []
-                                           (if crypto-currency?
-                                             (set-input-state
-                                              #(controlled-input/->fiat % conversion-rate))
-                                             (set-input-state
-                                              #(controlled-input/->crypto % conversion-rate)))
-                                           (set-crypto-currency (not crypto-currency?)))]
+  [{on-confirm        :on-confirm
+    on-navigate-back  :on-navigate-back
+    button-one-label  :button-one-label
+    button-one-props  :button-one-props
+    current-screen-id :current-screen-id}]
+  (let [view-id              (rf/sub [:view-id])
+        active-screen?       (= view-id current-screen-id)
+        bottom               (safe-area/get-bottom)
+        max-decimals         (rf/sub [:send-input-amount-screen/max-decimals])
+        value-out-of-limits? (rf/sub [:send-input-amount-screen/value-out-of-limits?])
+        current-address      (rf/sub [:wallet/current-viewing-account-address])
+        not-enough-asset?    (rf/sub [:send-input-amount-screen/not-enough-asset?])
+        show-no-routes?      (rf/sub [:send-input-amount-screen/show-no-routes?])
+        show-estimated-fees? (rf/sub [:send-input-amount-screen/show-estimated-fees?])
+        token-not-available? (rf/sub [:send-input-amount-screen/token-not-available?])]
     (rn/use-effect
      (fn []
        (when active-screen?
@@ -310,125 +257,48 @@
     (hot-reload/use-safe-unmount on-navigate-back)
     (rn/use-effect
      (fn []
-       (set-input-state #(controlled-input/set-upper-limit % max-limit)))
-     [max-limit])
-    (rn/use-effect
-     (fn []
-       (when input-error
+       (when value-out-of-limits?
          (rf/dispatch [:wallet/stop-get-suggested-routes])
          (debounce/clear-all)))
-     [input-error])
+     [value-out-of-limits?])
     (rn/use-effect
      (fn []
-       (clear-input!)
+       (rf/dispatch [:send-input-amount-screen/token-input-delete-all])
        (rf/dispatch [:wallet/stop-and-clean-suggested-routes])
        (rf/dispatch [:wallet/clean-disabled-from-networks]))
      [current-address])
-    (rn/use-effect
-     (fn []
-       (request-fetch-routes 0))
-     [send-from-locked-amounts])
     [rn/view
      {:style               style/screen
       :accessibility-label (str "container"
-                                (when (controlled-input/input-error input-state) "-error"))}
+                                (when value-out-of-limits? "-error"))}
      [account-switcher/view
       {:icon-name     :i/arrow-left
        :on-press      #(rf/dispatch [:navigate-back])
        :switcher-type :select-account}]
-     [quo/token-input
-      {:container-style style/input-container
-       :token-symbol    token-symbol
-       :value           input-value
-       :on-swap         swap-between-fiat-and-crypto
-       :on-token-press  show-select-asset-sheet
-       :error?          (controlled-input/input-error input-state)
-       :currency-symbol (if crypto-currency? token-symbol fiat-currency)
-       :converted-value (if crypto-currency?
-                          (utils/prettify-balance
-                           currency-symbol
-                           (money/crypto->fiat input-value
-                                               conversion-rate))
-                          (utils/prettify-crypto-balance
-                           (or (clj->js token-symbol) "")
-                           (money/fiat->crypto input-value
-                                               conversion-rate)
-                           conversion-rate))
-       :hint-component  [quo/network-tags
-                         {:networks (seq from-enabled-networks)
-                          :title    (i18n/label
-                                     :t/send-limit
-                                     {:limit (if crypto-currency?
-                                               (utils/prettify-crypto-balance
-                                                (or (clj->js token-symbol) "")
-                                                (controlled-input/upper-limit-bn input-state)
-                                                conversion-rate)
-                                               (utils/prettify-balance currency-symbol
-                                                                       (controlled-input/upper-limit-bn
-                                                                        input-state)))})
-                          :status   (when (controlled-input/input-error input-state) :error)}]}]
-     [routes/view
-      {:token                                     token-by-symbol
-       :send-amount-in-crypto                     amount-in-crypto
-       :valid-input?                              valid-input?
-       :token-not-supported-in-receiver-networks? unsupported-token-in-receiver?
-       :current-screen-id                         current-screen-id
-       :request-fetch-routes                      request-fetch-routes}]
-     (when (and (not loading-routes?)
-                sender-network-values
-                unsupported-token-in-receiver?)
-       [token-not-available token-symbol receiver-networks token-networks])
+     [token-input]
+     [routes-view current-screen-id]
+     (when token-not-available?
+       [token-not-available])
      (when not-enough-asset?
        [not-enough-asset])
-     (when (or (and (not no-routes-found?) (or loading-routes? route))
-               not-enough-asset?)
-       [estimated-fees
-        {:loading-routes? loading-routes?
-         :fees            fee-formatted
-         :amount          amount-text}])
+     (when show-estimated-fees?
+       [estimated-fees])
      (when show-no-routes?
        [no-routes-found])
-     [quo/bottom-actions
-      {:actions          :one-action
-       :button-one-label (if should-try-again?
-                           (i18n/label :t/try-again)
-                           button-one-label)
-       :button-one-props (merge (when-not should-try-again?
-                                  button-one-props)
-                                {:disabled?           (or not-enough-asset?
-                                                          loading-routes?
-                                                          (and (not should-try-again?)
-                                                               confirm-disabled?))
-                                 :on-press            (cond
-                                                        should-try-again?
-                                                        #(rf/dispatch [:wallet/start-get-suggested-routes
-                                                                       {:amount        amount-in-crypto
-                                                                        :updated-token token-by-symbol}])
-                                                        sending-to-unpreferred-networks?
-                                                        #(show-unpreferred-networks-alert on-confirm)
-                                                        :else
-                                                        #(on-confirm amount-in-crypto))
-                                 :customization-color current-color}
-                                (when should-try-again?
-                                  {:type :grey}))}]
+     [bottom-actions button-one-label button-one-props on-confirm]
      [quo/numbered-keyboard
       {:container-style      (style/keyboard-container bottom)
        :left-action          :dot
        :delete-key?          true
        :on-press             (fn [c]
-                               (let [new-text      (str input-value c)
-                                     max-decimals  (if crypto-currency? crypto-decimals 2)
-                                     regex-pattern (str "^\\d*\\.?\\d{0," max-decimals "}$")
-                                     regex         (re-pattern regex-pattern)]
-                                 (when (re-matches regex new-text)
-                                   (debounce/clear-all)
-                                   (set-input-state #(controlled-input/add-character % c)))))
+                               (rf/dispatch [:send-input-amount-screen/token-input-add-character c
+                                             max-decimals]))
        :on-delete            (fn []
                                (debounce/clear-all)
-                               (set-input-state controlled-input/delete-last)
+                               (rf/dispatch [:send-input-amount-screen/token-input-delete-last])
                                (rf/dispatch-sync [:wallet/stop-and-clean-suggested-routes]))
        :on-long-press-delete (fn []
                                (debounce/clear-all)
-                               (set-input-state controlled-input/delete-all)
+                               (rf/dispatch [:send-input-amount-screen/token-input-delete-all])
                                (rf/dispatch-sync [:wallet/stop-and-clean-suggested-routes]))}]]))
 

src/status_im/contexts/wallet/send/routes/view.cljs

@@ -27,7 +27,7 @@
              receiver-preferred-networks              (rf/sub
                                                        [:wallet/wallet-send-receiver-preferred-networks])
              {token-symbol   :symbol
-              token-networks :networks}               (rf/sub [:wallet/wallet-send-token])
+              token-networks :supported-networks}     (rf/sub [:wallet/wallet-send-token])
              token-chain-ids-set                      (set (mapv #(:chain-id %) token-networks))
              [selected-receiver-networks
               set-selected-receiver-networks]         (rn/use-state receiver-networks)

src/status_im/contexts/wallet/send/send_amount/view.cljs

@@ -8,12 +8,14 @@
 (defn view
   []
   [input-amount/view
-   {:current-screen-id      :screen/wallet.send-input-amount
-    :button-one-label       (i18n/label :t/review-send)
-    :enabled-from-chain-ids (rf/sub [:wallet/wallet-send-enabled-from-chain-ids])
-    :from-enabled-networks  (rf/sub [:wallet/wallet-send-enabled-networks])
-    :on-navigate-back       (fn []
-                              (rf/dispatch-sync [:wallet/stop-and-clean-suggested-routes])
-                              (rf/dispatch [:wallet/clean-disabled-from-networks])
-                              (rf/dispatch [:wallet/clean-from-locked-amounts])
-                              (rf/dispatch [:wallet/clean-send-amount]))}])
+   {:current-screen-id :screen/wallet.send-input-amount
+    :button-one-label  (i18n/label :t/review-send)
+    :on-confirm        (fn [amount]
+                         (rf/dispatch [:wallet/set-token-amount-to-send
+                                       {:amount   amount
+                                        :stack-id :screen/wallet.send-input-amount}]))
+    :on-navigate-back  (fn []
+                         (rf/dispatch-sync [:wallet/stop-and-clean-suggested-routes])
+                         (rf/dispatch [:wallet/clean-disabled-from-networks])
+                         (rf/dispatch [:wallet/clean-from-locked-amounts])
+                         (rf/dispatch [:wallet/clean-send-amount]))}])

src/status_im/contexts/wallet/send/transaction_confirmation/view.cljs

@@ -223,7 +223,7 @@
                                                  bridge-to-chain-id]))
             loading-suggested-routes? (rf/sub
                                        [:wallet/wallet-send-loading-suggested-routes?])
-            total-amount-receiver     (rf/sub [:wallet/total-amount true])
+            total-amount-receiver     (rf/sub [:wallet/total-amount-in-to-chains])
             from-account-props        {:customization-color account-color
                                        :size                32
                                        :emoji               (:emoji account)

src/status_im/contexts/wallet/swap/utils.cljs

@@ -65,7 +65,11 @@
                       :tokens
                       (filter #(= token-symbol (:symbol %)))
                       first)]
-    (assoc token :networks (network-utils/network-list token networks))))
+    (assoc token
+           :networks
+           (network-utils/network-list-with-positive-balance
+            token
+            networks))))
 
 (defn select-default-asset-to-receive
   "Selects an asset to receive if it was not provided explicitly.

src/status_im/contexts/wallet/tokens/events.cljs

@@ -20,40 +20,50 @@
 
 (defn store-token-list
   [{:keys [db]} [{:keys [data]}]]
-  (let [chain-ids (chain/chain-ids db)
-        tokens    (reduce (fn [{:keys [by-address by-symbol] :as data}
-                               {:keys [name source version tokens]}]
-                            (-> data
-                                (update :sources
-                                        conj
-                                        {:name         name
-                                         :source       source
-                                         :version      version
-                                         :tokens-count (count tokens)})
-                                (update :by-address
-                                        merge
-                                        (tokens-data/tokens-by-address
-                                         {:added-tokens by-address
-                                          :source-name  name
-                                          :tokens       tokens
-                                          :chain-ids    chain-ids}))
-                                (update :by-symbol
-                                        merge
-                                        (tokens-data/tokens-by-symbol
-                                         {:added-tokens by-symbol
-                                          :source-name  name
-                                          :tokens       tokens
-                                          :chain-ids    chain-ids}))))
-                          {:sources    []
-                           :by-address {}
-                           :by-symbol  {}}
-                          data)
-        symbols   (->> tokens
-                       :by-symbol
-                       vals
-                       (map :symbol)
-                       set
-                       vec)]
+  (let [chain-ids                  (chain/chain-ids db)
+        tokens                     (reduce (fn [{:keys [by-address by-symbol] :as data}
+                                                {:keys [name source version tokens]}]
+                                             (-> data
+                                                 (update :sources
+                                                         conj
+                                                         {:name         name
+                                                          :source       source
+                                                          :version      version
+                                                          :tokens-count (count tokens)})
+                                                 (update :by-address
+                                                         merge
+                                                         (tokens-data/tokens-by-address
+                                                          {:added-tokens by-address
+                                                           :source-name  name
+                                                           :tokens       tokens
+                                                           :chain-ids    chain-ids}))
+                                                 (update :by-symbol
+                                                         merge
+                                                         (tokens-data/tokens-by-symbol
+                                                          {:added-tokens by-symbol
+                                                           :source-name  name
+                                                           :tokens       tokens
+                                                           :chain-ids    chain-ids}))))
+                                           {:sources    []
+                                            :by-address {}
+                                            :by-symbol  {}}
+                                           data)
+        symbols                    (->> tokens
+                                        :by-symbol
+                                        vals
+                                        (map :symbol)
+                                        set
+                                        vec)
+        by-symbol-vals             (-> tokens :by-symbol vals)
+        supported-chains-by-symbol (reduce
+                                    (fn [result
+                                         {token-symbol :symbol
+                                          :keys        [chain-id]}]
+                                      (if (contains? result token-symbol)
+                                        (update result token-symbol conj chain-id)
+                                        (assoc result token-symbol #{chain-id})))
+                                    {}
+                                    by-symbol-vals)]
     {:fx [[:effects.wallet.tokens/fetch-market-values
            {:symbols    symbols
             :currency   constants/profile-default-currency
@@ -70,9 +80,10 @@
             :on-error   [:wallet.tokens/fetch-prices-failed]}]]
      :db (-> db
              (assoc-in [:wallet :tokens]
-                       {:sources    (:sources tokens)
-                        :by-address (-> tokens :by-address vals)
-                        :by-symbol  (-> tokens :by-symbol vals)})
+                       {:sources                    (:sources tokens)
+                        :supported-chains-by-symbol supported-chains-by-symbol
+                        :by-address                 (-> tokens :by-address vals)
+                        :by-symbol                  by-symbol-vals})
              (assoc-in [:wallet :ui :loading]
                        {:token-list    false
                         :market-values true

src/status_im/contexts/wallet/tokens/events_test.cljs

@@ -47,10 +47,10 @@
        (match?
         (:db (tokens.events/store-token-list cofx [{:data data}]))
         {:wallet {:networks {:prod [{:chain-id 1}]}
-                  :tokens   {:sources    [{:name         "native"
-                                           :source       "native"
-                                           :version      "1.0.0"
-                                           :tokens-count 2}]
+                  :tokens   {:sources [{:name         "native"
+                                        :source       "native"
+                                        :version      "1.0.0"
+                                        :tokens-count 2}]
                              :by-address '({:address      "0x0000000000000000000000000000000000000000"
                                             :decimals     18
                                             :key          "1-0x0000000000000000000000000000000000000000"
@@ -73,28 +73,29 @@
                                             :verified?    true
                                             :chain-id     1
                                             :image        nil})
-                             :by-symbol  '({:address      "0x0000000000000000000000000000000000000000"
-                                            :decimals     18
-                                            :key          "1-ETH"
-                                            :community-id nil
-                                            :symbol       "ETH"
-                                            :sources      ["native"]
-                                            :name         "Ether"
-                                            :type         :erc20
-                                            :verified?    true
-                                            :chain-id     1
-                                            :image        nil}
-                                           {:address      "0x0000000000000000000000000000000000000001"
-                                            :decimals     18
-                                            :key          "1-SNT"
-                                            :community-id nil
-                                            :symbol       "SNT"
-                                            :sources      ["native"]
-                                            :name         "Status Network Token"
-                                            :type         :erc20
-                                            :verified?    true
-                                            :chain-id     1
-                                            :image        nil})}
+                             :by-symbol '({:address      "0x0000000000000000000000000000000000000000"
+                                           :decimals     18
+                                           :key          "1-ETH"
+                                           :community-id nil
+                                           :symbol       "ETH"
+                                           :sources      ["native"]
+                                           :name         "Ether"
+                                           :type         :erc20
+                                           :verified?    true
+                                           :chain-id     1
+                                           :image        nil}
+                                          {:address      "0x0000000000000000000000000000000000000001"
+                                           :decimals     18
+                                           :key          "1-SNT"
+                                           :community-id nil
+                                           :symbol       "SNT"
+                                           :sources      ["native"]
+                                           :name         "Status Network Token"
+                                           :type         :erc20
+                                           :verified?    true
+                                           :chain-id     1
+                                           :image        nil})
+                             :supported-chains-by-symbol {"ETH" #{1} "SNT" #{1}}}
                   :ui       {:loading {:token-list    false
                                        :market-values true
                                        :details       true
@@ -109,12 +110,13 @@
                       :db
                       :wallet
                       :tokens)
-                  {:sources    [{:name         "native"
-                                 :source       "native"
-                                 :version      "1.0.0"
-                                 :tokens-count 2}]
-                   :by-address nil
-                   :by-symbol  nil}))))
+                  {:sources                    [{:name         "native"
+                                                 :source       "native"
+                                                 :version      "1.0.0"
+                                                 :tokens-count 2}]
+                   :by-address                 nil
+                   :by-symbol                  nil
+                   :supported-chains-by-symbol {}}))))
   (testing "response contains two lists"
     (let [cofx {:db {:wallet {:networks {:prod [{:chain-id 1}]}}}}
           data [{:name    "native"
@@ -131,80 +133,81 @@
             :db
             :wallet
             :tokens)
-        {:sources    [{:name         "native"
-                       :source       "native"
-                       :version      "1.0.0"
-                       :tokens-count 2}
-                      {:name         "second"
-                       :source       "second"
-                       :version      "1.0.0"
-                       :tokens-count 2}]
-         :by-address '({:address      "0x0000000000000000000000000000000000000000"
-                        :decimals     18
-                        :key          "1-0x0000000000000000000000000000000000000000"
-                        :community-id nil
-                        :symbol       "ETH"
-                        :sources      ["native"]
-                        :name         "Ether"
-                        :type         :erc20
-                        :verified?    true
-                        :chain-id     1
-                        :image        nil}
-                       {:address      "0x0000000000000000000000000000000000000001"
-                        :decimals     18
-                        :key          "1-0x0000000000000000000000000000000000000001"
-                        :community-id nil
-                        :symbol       "SNT"
-                        :sources      ["native" "second"]
-                        :name         "Status Network Token"
-                        :type         :erc20
-                        :verified?    true
-                        :chain-id     1
-                        :image        nil}
-                       {:address      "0x0000000000000000000000000000000000000002"
-                        :decimals     18
-                        :key          "1-0x0000000000000000000000000000000000000002"
-                        :community-id nil
-                        :symbol       "ANOTHER1"
-                        :sources      ["second"]
-                        :name         "Another Token 1"
-                        :type         :erc20
-                        :verified?    false
-                        :chain-id     1
-                        :image        nil})
-         :by-symbol  '({:address      "0x0000000000000000000000000000000000000000"
-                        :decimals     18
-                        :key          "1-ETH"
-                        :community-id nil
-                        :symbol       "ETH"
-                        :sources      ["native"]
-                        :name         "Ether"
-                        :type         :erc20
-                        :verified?    true
-                        :chain-id     1
-                        :image        nil}
-                       {:address      "0x0000000000000000000000000000000000000001"
-                        :decimals     18
-                        :key          "1-SNT"
-                        :community-id nil
-                        :symbol       "SNT"
-                        :sources      ["native" "second"]
-                        :name         "Status Network Token"
-                        :type         :erc20
-                        :verified?    true
-                        :chain-id     1
-                        :image        nil}
-                       {:address      "0x0000000000000000000000000000000000000002"
-                        :decimals     18
-                        :key          "1-ANOTHER1"
-                        :community-id nil
-                        :symbol       "ANOTHER1"
-                        :sources      ["second"]
-                        :name         "Another Token 1"
-                        :type         :erc20
-                        :verified?    false
-                        :chain-id     1
-                        :image        nil})}))))
+        {:sources                    [{:name         "native"
+                                       :source       "native"
+                                       :version      "1.0.0"
+                                       :tokens-count 2}
+                                      {:name         "second"
+                                       :source       "second"
+                                       :version      "1.0.0"
+                                       :tokens-count 2}]
+         :by-address                 '({:address      "0x0000000000000000000000000000000000000000"
+                                        :decimals     18
+                                        :key          "1-0x0000000000000000000000000000000000000000"
+                                        :community-id nil
+                                        :symbol       "ETH"
+                                        :sources      ["native"]
+                                        :name         "Ether"
+                                        :type         :erc20
+                                        :verified?    true
+                                        :chain-id     1
+                                        :image        nil}
+                                       {:address      "0x0000000000000000000000000000000000000001"
+                                        :decimals     18
+                                        :key          "1-0x0000000000000000000000000000000000000001"
+                                        :community-id nil
+                                        :symbol       "SNT"
+                                        :sources      ["native" "second"]
+                                        :name         "Status Network Token"
+                                        :type         :erc20
+                                        :verified?    true
+                                        :chain-id     1
+                                        :image        nil}
+                                       {:address      "0x0000000000000000000000000000000000000002"
+                                        :decimals     18
+                                        :key          "1-0x0000000000000000000000000000000000000002"
+                                        :community-id nil
+                                        :symbol       "ANOTHER1"
+                                        :sources      ["second"]
+                                        :name         "Another Token 1"
+                                        :type         :erc20
+                                        :verified?    false
+                                        :chain-id     1
+                                        :image        nil})
+         :by-symbol                  '({:address      "0x0000000000000000000000000000000000000000"
+                                        :decimals     18
+                                        :key          "1-ETH"
+                                        :community-id nil
+                                        :symbol       "ETH"
+                                        :sources      ["native"]
+                                        :name         "Ether"
+                                        :type         :erc20
+                                        :verified?    true
+                                        :chain-id     1
+                                        :image        nil}
+                                       {:address      "0x0000000000000000000000000000000000000001"
+                                        :decimals     18
+                                        :key          "1-SNT"
+                                        :community-id nil
+                                        :symbol       "SNT"
+                                        :sources      ["native" "second"]
+                                        :name         "Status Network Token"
+                                        :type         :erc20
+                                        :verified?    true
+                                        :chain-id     1
+                                        :image        nil}
+                                       {:address      "0x0000000000000000000000000000000000000002"
+                                        :decimals     18
+                                        :key          "1-ANOTHER1"
+                                        :community-id nil
+                                        :symbol       "ANOTHER1"
+                                        :sources      ["second"]
+                                        :name         "Another Token 1"
+                                        :type         :erc20
+                                        :verified?    false
+                                        :chain-id     1
+                                        :image        nil})
+         :supported-chains-by-symbol {"ETH" #{1} "SNT" #{1} "ANOTHER1" #{1}}}))))
   (testing "second list contains a token that replaces the one that was added before"
     (let [cofx {:db {:wallet {:networks {:prod [{:chain-id 1}]}}}}
           data [{:name    "native"
@@ -221,55 +224,56 @@
             :db
             :wallet
             :tokens)
-        {:sources    [{:name         "native"
-                       :source       "native"
-                       :version      "1.0.0"
-                       :tokens-count 2}
-                      {:name         "second"
-                       :source       "second"
-                       :version      "1.0.0"
-                       :tokens-count 1}]
-         :by-address '({:address      "0x0000000000000000000000000000000000000000"
-                        :decimals     18
-                        :key          "1-0x0000000000000000000000000000000000000000"
-                        :community-id nil
-                        :symbol       "ANOTHER1"
-                        :sources      ["native" "second"]
-                        :name         "Another Token 2"
-                        :type         :erc20
-                        :verified?    false
-                        :chain-id     1
-                        :image        nil}
-                       {:address      "0x0000000000000000000000000000000000000002"
-                        :decimals     18
-                        :key          "1-0x0000000000000000000000000000000000000002"
-                        :community-id nil
-                        :symbol       "ANOTHER1"
-                        :sources      ["native"]
-                        :name         "Another Token 1"
-                        :type         :erc20
-                        :verified?    false
-                        :chain-id     1
-                        :image        nil})
-         :by-symbol  '({:address      "0x0000000000000000000000000000000000000000"
-                        :decimals     18
-                        :key          "1-ETH"
-                        :community-id nil
-                        :symbol       "ETH"
-                        :sources      ["native"]
-                        :name         "Ether"
-                        :type         :erc20
-                        :verified?    true
-                        :chain-id     1
-                        :image        nil}
-                       {:address      "0x0000000000000000000000000000000000000000"
-                        :decimals     18
-                        :key          "1-ANOTHER1"
-                        :community-id nil
-                        :symbol       "ANOTHER1"
-                        :sources      ["native" "second"]
-                        :name         "Another Token 2"
-                        :type         :erc20
-                        :verified?    false
-                        :chain-id     1
-                        :image        nil})})))))
+        {:sources                    [{:name         "native"
+                                       :source       "native"
+                                       :version      "1.0.0"
+                                       :tokens-count 2}
+                                      {:name         "second"
+                                       :source       "second"
+                                       :version      "1.0.0"
+                                       :tokens-count 1}]
+         :by-address                 '({:address      "0x0000000000000000000000000000000000000000"
+                                        :decimals     18
+                                        :key          "1-0x0000000000000000000000000000000000000000"
+                                        :community-id nil
+                                        :symbol       "ANOTHER1"
+                                        :sources      ["native" "second"]
+                                        :name         "Another Token 2"
+                                        :type         :erc20
+                                        :verified?    false
+                                        :chain-id     1
+                                        :image        nil}
+                                       {:address      "0x0000000000000000000000000000000000000002"
+                                        :decimals     18
+                                        :key          "1-0x0000000000000000000000000000000000000002"
+                                        :community-id nil
+                                        :symbol       "ANOTHER1"
+                                        :sources      ["native"]
+                                        :name         "Another Token 1"
+                                        :type         :erc20
+                                        :verified?    false
+                                        :chain-id     1
+                                        :image        nil})
+         :by-symbol                  '({:address      "0x0000000000000000000000000000000000000000"
+                                        :decimals     18
+                                        :key          "1-ETH"
+                                        :community-id nil
+                                        :symbol       "ETH"
+                                        :sources      ["native"]
+                                        :name         "Ether"
+                                        :type         :erc20
+                                        :verified?    true
+                                        :chain-id     1
+                                        :image        nil}
+                                       {:address      "0x0000000000000000000000000000000000000000"
+                                        :decimals     18
+                                        :key          "1-ANOTHER1"
+                                        :community-id nil
+                                        :symbol       "ANOTHER1"
+                                        :sources      ["native" "second"]
+                                        :name         "Another Token 2"
+                                        :type         :erc20
+                                        :verified?    false
+                                        :chain-id     1
+                                        :image        nil})
+         :supported-chains-by-symbol {"ETH" #{1} "ANOTHER1" #{1}}})))))

src/status_im/subs/wallet/networks.cljs

@@ -76,14 +76,13 @@
       network-values))))
 
 (re-frame/reg-sub
- :wallet/total-amount
+ :wallet/total-amount-in-to-chains
  :<- [:wallet/wallet-send]
- (fn [{:keys [from-values-by-chain to-values-by-chain]} [_ to-values?]]
-   (let [network-values (if to-values? to-values-by-chain from-values-by-chain)]
-     (reduce
-      (fn [acc amount]
-        (if (money/bignumber? amount)
-          (money/add acc amount)
-          acc))
-      (money/bignumber 0)
-      (vals network-values)))))
+ (fn [{:keys [to-values-by-chain]}]
+   (reduce
+    (fn [acc amount]
+      (if (money/bignumber? amount)
+        (money/add acc amount)
+        acc))
+    (money/bignumber 0)
+    (vals to-values-by-chain))))

src/status_im/subs/wallet/screens/input_amount.cljs

@@ -0,0 +1,360 @@
+(ns status-im.subs.wallet.screens.input-amount
+  (:require
+    [clojure.string :as string]
+    [status-im.constants :as constants]
+    [status-im.contexts.wallet.common.utils :as utils]
+    [status-im.contexts.wallet.send.input-amount.controlled-input-logic :as controlled-input-logic]
+    [utils.money :as money]
+    [utils.number :as number]
+    [utils.re-frame :as rf]))
+
+(rf/reg-sub :send-input-amount-screen/state
+ :<- [:wallet/wallet-screens]
+ :-> :input-amount-screen)
+
+(rf/reg-sub :send-input-amount-screen/enabled-from-chain-ids
+ :<- [:wallet/wallet-send-tx-type]
+ :<- [:wallet/wallet-send-enabled-from-chain-ids]
+ :<- [:wallet/bridge-from-chain-ids]
+ (fn [[tx-type send-chain-ids bridge-chain-ids]]
+   (if (= tx-type :tx/bridge)
+     bridge-chain-ids
+     send-chain-ids)))
+
+(rf/reg-sub :send-input-amount-screen/from-enabled-networks
+ :<- [:wallet/wallet-send-tx-type]
+ :<- [:wallet/wallet-send-enabled-networks]
+ :<- [:wallet/bridge-from-networks]
+ (fn [[tx-type send-enabled-networks bridge-enabled-networks]]
+   (if (= tx-type :tx/bridge)
+     bridge-enabled-networks
+     send-enabled-networks)))
+
+(rf/reg-sub :send-input-amount-screen/token-by-symbol
+ :<- [:send-input-amount-screen/enabled-from-chain-ids]
+ :<- [:wallet/wallet-send-token]
+ (fn [[enabled-from-chain-ids
+       {token-symbol :symbol}]]
+   (rf/sub [:wallet/token-by-symbol
+            (str token-symbol)
+            enabled-from-chain-ids])))
+
+(rf/reg-sub :send-input-amount-screen/total-balance
+ :<- [:send-input-amount-screen/token-by-symbol]
+ (fn [{:keys [total-balance]}]
+   total-balance))
+
+(rf/reg-sub :send-input-amount-screen/conversion-rate
+ :<- [:wallet/wallet-send-token]
+ :<- [:profile/currency]
+ (fn [[token
+       currency]]
+   (-> token
+       :market-values-per-currency
+       currency
+       :price)))
+
+(rf/reg-sub :send-input-amount-screen/usd-conversion-rate
+ :<- [:wallet/wallet-send-token]
+ (fn [token]
+   (utils/token-usd-price token)))
+
+(rf/reg-sub :send-input-amount-screen/token-decimals
+ :<- [:wallet/wallet-send-token]
+ (fn [token]
+   (-> token
+       utils/token-usd-price
+       utils/one-cent-value
+       utils/calc-max-crypto-decimals)))
+
+(rf/reg-sub :send-input-amount-screen/max-decimals
+ :<- [:send-input-amount-screen/state]
+ :<- [:send-input-amount-screen/token-decimals]
+ (fn [[{:keys [crypto-currency?]}
+       token-decimals]]
+   (if crypto-currency? token-decimals 2)))
+
+(rf/reg-sub :send-input-amount-screen/upper-limit
+ :<- [:send-input-amount-screen/state]
+ :<- [:send-input-amount-screen/conversion-rate]
+ :<- [:send-input-amount-screen/usd-conversion-rate]
+ :<- [:send-input-amount-screen/total-balance]
+ (fn [[{:keys [crypto-currency?]}
+       conversion-rate
+       usd-conversion-rate
+       total-balance]]
+   (if crypto-currency?
+     (utils/cut-crypto-decimals-to-fit-usd-cents
+      total-balance
+      usd-conversion-rate)
+     (utils/cut-fiat-balance-to-two-decimals
+      (money/crypto->fiat total-balance conversion-rate)))))
+
+(rf/reg-sub :send-input-amount-screen/upper-limit-prettified
+ :<- [:send-input-amount-screen/state]
+ :<- [:profile/currency-symbol]
+ :<- [:wallet/wallet-send-token]
+ :<- [:send-input-amount-screen/conversion-rate]
+ :<- [:send-input-amount-screen/upper-limit]
+ (fn [[{:keys [crypto-currency?]}
+       currency-symbol
+       {token-symbol :symbol}
+       conversion-rate
+       upper-limit]]
+   (if crypto-currency?
+     (utils/prettify-crypto-balance
+      (or (clj->js token-symbol) "")
+      (money/bignumber upper-limit)
+      conversion-rate)
+     (utils/prettify-balance currency-symbol
+                             (money/bignumber upper-limit)))))
+
+(rf/reg-sub :send-input-amount-screen/upper-limit-exceeded?
+ :<- [:send-input-amount-screen/state]
+ :<- [:send-input-amount-screen/upper-limit]
+ (fn [[{:keys [input-value]}
+       upper-limit]]
+   (controlled-input-logic/upper-limit-exceeded?
+    input-value
+    upper-limit)))
+
+(rf/reg-sub :send-input-amount-screen/value-out-of-limits?
+ :<- [:send-input-amount-screen/state]
+ :<- [:send-input-amount-screen/upper-limit]
+ (fn [[{:keys [input-value]}
+       upper-limit]]
+   (controlled-input-logic/value-out-of-limits? input-value upper-limit 0)))
+
+(rf/reg-sub :send-input-amount-screen/valid-input?
+ :<- [:send-input-amount-screen/state]
+ :<- [:send-input-amount-screen/value-out-of-limits?]
+ (fn [[{:keys [input-value]}
+       value-out-of-limits?]]
+   (not (or (controlled-input-logic/empty-value? input-value) value-out-of-limits?))))
+
+(rf/reg-sub :send-input-amount-screen/upper-limit-equals-input-value?
+ :<- [:send-input-amount-screen/state]
+ :<- [:send-input-amount-screen/upper-limit]
+ (fn [[{:keys [input-value]}
+       upper-limit]]
+   (money/equal-to
+    (money/bignumber input-value)
+    (money/bignumber upper-limit))))
+
+
+(defn- fiat->crypto
+  [value conversion-rate]
+  (-> value
+      (money/fiat->crypto conversion-rate)
+      (utils/cut-crypto-decimals-to-fit-usd-cents conversion-rate)))
+
+(defn- crypto->fiat
+  [value conversion-rate]
+  (-> value
+      (money/crypto->fiat conversion-rate)
+      (utils/cut-fiat-balance-to-two-decimals)))
+
+(rf/reg-sub :send-input-amount-screen/input-value-converted
+ :<- [:send-input-amount-screen/state]
+ :<- [:send-input-amount-screen/conversion-rate]
+ (fn [[{:keys [crypto-currency? input-value]}
+       conversion-rate]]
+   (if crypto-currency?
+     (crypto->fiat input-value conversion-rate)
+     (fiat->crypto input-value conversion-rate))))
+
+(rf/reg-sub :send-input-amount-screen/converted-value-prettified
+ :<- [:send-input-amount-screen/state]
+ :<- [:send-input-amount-screen/input-value-converted]
+ :<- [:profile/currency-symbol]
+ :<- [:wallet/wallet-send-token]
+ (fn [[{:keys [crypto-currency?]}
+       token-input-converted-value
+       currency-symbol
+       {token-symbol :symbol}]]
+   (if crypto-currency?
+     (utils/prepend-curency-symbol-to-fiat-balance token-input-converted-value currency-symbol)
+     (utils/add-token-symbol-to-crypto-balance token-input-converted-value
+                                               (or (clj->js token-symbol) "")))))
+
+(rf/reg-sub :send-input-amount-screen/amount-in-crypto
+ :<- [:send-input-amount-screen/state]
+ :<- [:send-input-amount-screen/conversion-rate]
+ :<- [:send-input-amount-screen/token-decimals]
+ (fn [[{:keys [crypto-currency? input-value]}
+       conversion-rate
+       token-decimals]]
+   (if crypto-currency?
+     input-value
+     (number/remove-trailing-zeroes
+      (.toFixed (/ input-value conversion-rate) token-decimals)))))
+
+(rf/reg-sub :send-input-amount-screen/recipient-gets-amount
+ :<- [:send-input-amount-screen/conversion-rate]
+ :<- [:wallet/total-amount-in-to-chains]
+ :<- [:wallet/wallet-send-token]
+ (fn [[conversion-rate
+       total-amount-receiver
+       {token-symbol :symbol}]]
+   (utils/prettify-crypto-balance
+    token-symbol
+    total-amount-receiver
+    conversion-rate)))
+
+(rf/reg-sub :send-input-amount-screen/routes
+ :<- [:wallet/wallet-send-suggested-routes]
+ (fn [suggested-routes]
+   (when suggested-routes
+     (or (:best suggested-routes) []))))
+
+(defn- every-network-value-is-zero?
+  [sender-network-values]
+  (every? (fn [{:keys [total-amount]}]
+            (and
+             total-amount
+             (money/bignumber? total-amount)
+             (money/equal-to total-amount
+                             (money/bignumber "0"))))
+          sender-network-values))
+
+(rf/reg-sub :send-input-amount-screen/unsupported-token-in-receiver?
+ :<- [:wallet/wallet-send-receiver-network-values]
+ :<- [:wallet/wallet-send-tx-type]
+ (fn [[receiver-network-values
+       tx-type]]
+   (and (not= tx-type :tx/bridge)
+        (->> receiver-network-values
+             (remove #(= (:type %) :add))
+             (every? #(= (:type %) :not-available))))))
+
+(rf/reg-sub :send-input-amount-screen/no-routes-found?
+ :<- [:wallet/wallet-send-sender-network-values]
+ :<- [:send-input-amount-screen/routes]
+ :<- [:wallet/wallet-send-loading-suggested-routes?]
+ :<- [:send-input-amount-screen/unsupported-token-in-receiver?]
+ (fn [[sender-network-values
+       routes
+       loading-routes?
+       unsupported-token-in-receiver?]]
+   (and
+    (every-network-value-is-zero? sender-network-values)
+    (some? routes)
+    (not loading-routes?)
+    (not unsupported-token-in-receiver?))))
+
+(rf/reg-sub :send-input-amount-screen/sending-to-unpreferred-networks?
+ :<- [:wallet/wallet-send-receiver-networks]
+ :<- [:wallet/wallet-send-receiver-preferred-networks]
+ (fn [[receiver-networks
+       receiver-preferred-networks]]
+   (some (comp not (set receiver-preferred-networks)) receiver-networks)))
+
+(defn- insufficient-asset-amount?
+  [{:keys [token-symbol owned-eth-token upper-limit-equals-input-value? no-routes-found? limit-exceeded?
+           sender-network-values enough-assets?]}]
+  (let [eth-selected?   (= token-symbol (string/upper-case constants/mainnet-short-name))
+        zero-owned-eth? (money/equal-to (:total-balance owned-eth-token) 0)
+        exceeded-input? (if eth-selected?
+                          upper-limit-equals-input-value?
+                          zero-owned-eth?)]
+    (and (or no-routes-found? limit-exceeded?)
+         (seq sender-network-values)
+         (or exceeded-input? (not enough-assets?)))))
+
+(rf/reg-sub :send-input-amount-screen/not-enough-asset?
+ :<- [:wallet/wallet-send-sender-network-values]
+ :<- [:wallet/wallet-send-enough-assets?]
+ :<- [:wallet/wallet-send-token]
+ :<- [:send-input-amount-screen/upper-limit-equals-input-value?]
+ :<- [:send-input-amount-screen/no-routes-found?]
+ :<- [:send-input-amount-screen/upper-limit-exceeded?]
+ :<- [:send-input-amount-screen/enabled-from-chain-ids]
+ (fn [[sender-network-values
+       enough-assets?
+       {token-symbol :symbol}
+       upper-limit-equals-input-value?
+       no-routes-found?
+       limit-exceeded?
+       enabled-from-chain-ids]]
+   (let [owned-eth-token (rf/sub [:wallet/token-by-symbol
+                                  (string/upper-case constants/mainnet-short-name)
+                                  enabled-from-chain-ids])]
+     (insufficient-asset-amount?
+      {:enough-assets?                  enough-assets?
+       :token-symbol                    token-symbol
+       :owned-eth-token                 owned-eth-token
+       :upper-limit-equals-input-value? upper-limit-equals-input-value?
+       :no-routes-found?                no-routes-found?
+       :limit-exceeded?                 limit-exceeded?
+       :sender-network-values           sender-network-values}))))
+
+(rf/reg-sub :send-input-amount-screen/should-try-again?
+ :<- [:send-input-amount-screen/upper-limit-exceeded?]
+ :<- [:send-input-amount-screen/no-routes-found?]
+ :<- [:send-input-amount-screen/not-enough-asset?]
+ (fn [[limit-exceeded?
+       no-routes-found?
+       not-enough-asset?]]
+   (and (not limit-exceeded?)
+        no-routes-found?
+        (not not-enough-asset?))))
+
+(rf/reg-sub :send-input-amount-screen/show-no-routes?
+ :<- [:send-input-amount-screen/upper-limit-exceeded?]
+ :<- [:send-input-amount-screen/no-routes-found?]
+ :<- [:send-input-amount-screen/not-enough-asset?]
+ :<- [:wallet/wallet-send-sender-network-values]
+ (fn [[limit-exceeded?
+       no-routes-found?
+       not-enough-asset?
+       sender-network-values]]
+   (and (or no-routes-found? limit-exceeded?)
+        (not-empty sender-network-values)
+        (not not-enough-asset?))))
+
+(rf/reg-sub :send-input-amount-screen/confirm-disabled?
+ :<- [:wallet/wallet-send-route]
+ :<- [:send-input-amount-screen/valid-input?]
+ (fn [[route
+       valid-input?]]
+   (or (nil? route)
+       (empty? route)
+       (not valid-input?))))
+
+(defn- get-fee-formatted
+  [route]
+  (when-let [native-currency-symbol (-> route first :from :native-currency-symbol)]
+    (rf/sub [:wallet/wallet-send-fee-fiat-formatted native-currency-symbol])))
+
+(rf/reg-sub :send-input-amount-screen/fee-formatted
+ :<- [:wallet/wallet-send-route]
+ :<- [:send-input-amount-screen/confirm-disabled?]
+ :<- [:send-input-amount-screen/not-enough-asset?]
+ (fn [[route
+       confirm-disabled?
+       not-enough-asset?]]
+   (when (or (not confirm-disabled?) not-enough-asset?)
+     (get-fee-formatted route))))
+
+(rf/reg-sub :send-input-amount-screen/show-estimated-fees?
+ :<- [:wallet/wallet-send-route]
+ :<- [:send-input-amount-screen/no-routes-found?]
+ :<- [:send-input-amount-screen/not-enough-asset?]
+ :<- [:wallet/wallet-send-loading-suggested-routes?]
+ (fn [[route
+       no-routes-found?
+       not-enough-asset?
+       loading-routes?]]
+   (or (and (not no-routes-found?) (or loading-routes? route))
+       not-enough-asset?)))
+
+(rf/reg-sub :send-input-amount-screen/token-not-available?
+ :<- [:wallet/wallet-send-sender-network-values]
+ :<- [:send-input-amount-screen/unsupported-token-in-receiver?]
+ :<- [:wallet/wallet-send-loading-suggested-routes?]
+ (fn [[sender-network-values unsupported-token-in-receiver?
+       loading-routes?]]
+   (and (not loading-routes?)
+        sender-network-values
+        unsupported-token-in-receiver?)))
+

src/status_im/subs/wallet/send.cljs

@@ -16,6 +16,11 @@
  :<- [:wallet/ui]
  :-> :send)
 
+(rf/reg-sub
+ :wallet/wallet-screens
+ :<- [:wallet/ui]
+ :-> :screens)
+
 (rf/reg-sub
  :wallet/send-recipient
  :<- [:wallet/wallet-send]

src/status_im/subs/wallet/wallet.cljs

@@ -144,11 +144,12 @@
                                        (remove disabled-from-chain-ids?)
                                        set)]
      (some-> token
-             (assoc :networks          (network-utils/network-list token networks)
-                    :available-balance (utils/calculate-total-token-balance token)
-                    :total-balance     (utils/calculate-total-token-balance
-                                        token
-                                        enabled-from-chain-ids))))))
+             (assoc :networks           (network-utils/network-list-with-positive-balance token networks)
+                    :supported-networks (network-utils/network-list token networks)
+                    :available-balance  (utils/calculate-total-token-balance token)
+                    :total-balance      (utils/calculate-total-token-balance
+                                         token
+                                         enabled-from-chain-ids))))))
 
 (rf/reg-sub
  :wallet/wallet-send-token-symbol
@@ -459,6 +460,7 @@
                                                    networks)
                                                   chain-ids
                                                   (filter #(some #{(:chain-id %)} chain-ids)))
+                                      :supported-networks (network-utils/network-list token networks)
                                       :available-balance (utils/calculate-total-token-balance token)
                                       :total-balance (utils/calculate-total-token-balance
                                                       token