first pack of subscriptions moved without losing functionality

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

@@ -13,9 +13,6 @@
     {: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

src/status_im/contexts/wallet/db.cljs

@@ -12,6 +12,6 @@
         ;; tokens already exist in the app-db.
         :tokens-loading nil
         :active-tab     :assets
-        :send           {:input-amount-screen
+        :screens        {:input-amount-screen
                          {:crypto-currency? true
-                          :token-input-value ""}}}})
+                          :input-value      ""}}}})

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

@@ -3,12 +3,12 @@
     [status-im.contexts.wallet.send.input-amount.controlled-input-logic :as controlled-input-logic]
     [utils.re-frame :as rf]))
 
-(def token-input-value-path [:wallet :ui :send :input-amount-screen :token-input-value])
+(def input-value-path [:wallet :ui :screens :input-amount-screen :input-value])
-(def crypto-currency?-path [:layers :ui :send :input-amount-screen :controller :crypto-currency?])
+(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 token-input-value-path 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]]
@@ -18,19 +18,19 @@
 
 (rf/reg-event-fx :send-input-amount-screen/token-input-add-character
  (fn [{:keys [db]} [c max-decimals]]
-   (let [input-value   (get-in db token-input-value-path)
+   (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 token-input-value-path #(controlled-input-logic/add-character % c))}))))
+       {: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 token-input-value-path controlled-input-logic/delete-last)}))
+   {: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 token-input-value-path "")}))
+   {:db (assoc-in db input-value-path "")}))
 
 

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

@@ -6,7 +6,6 @@
     [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]
@@ -63,7 +62,7 @@
           sender-network-values))
 
 (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
@@ -75,7 +74,8 @@
        :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]
@@ -148,15 +148,12 @@
     (rf/sub [:wallet/wallet-send-fee-fiat-formatted native-currency-symbol])))
 
 (defn- insufficient-asset-amount?
-  [{:keys [token-symbol owned-eth-token input-state no-routes-found? limit-exceeded?
+  [{: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)
-        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?
+                          upper-limit-equals-input-value?
                           zero-owned-eth?)]
     (and (or no-routes-found? limit-exceeded?)
          (seq sender-network-values)
@@ -166,61 +163,39 @@
   ;; 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
+    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}]))
+        {:keys [input-value crypto-currency?]} (rf/sub [:send-input-amount-screen/state])
+        enabled-from-chain-ids (rf/sub
+                                [:send-input-amount-screen/enabled-from-chain-ids])
+        from-enabled-networks (rf/sub [:send-input-amount-screen/from-enabled-networks])
         {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]
+        token-by-symbol (rf/sub [:send-input-amount-screen/token-by-symbol])
-         :as   token-by-symbol}          (rf/sub [:wallet/token-by-symbol
+        conversion-rate (rf/sub [:send-input-amount-screen/conversion-rate])
-                                                  (str token-symbol)
+        token-input-converted-value (rf/sub
-                                                  enabled-from-chain-ids])
+                                     [:send-input-amount-screen/token-input-converted-value])
-        token-balance                    (or default-limit-crypto total-balance)
+        token-decimals (rf/sub [:send-input-amount-screen/token-decimals])
-        usd-conversion-rate              (utils/token-usd-price token)
+        max-decimals (rf/sub [:send-input-amount-screen/max-decimals])
-        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?
+        valid-input? (rf/sub [:send-input-amount-screen/valid-input?])
-                                           (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
@@ -234,9 +209,7 @@
                          token-symbol)
         show-select-asset-sheet #(rf/dispatch
                                   [:show-bottom-sheet
-                                            {:content (fn []
+                                   {:content (fn [] [select-asset-bottom-sheet])}])
-                                                        [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])
@@ -257,11 +230,14 @@
         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)
+        value-out-of-limits? (rf/sub [:send-input-amount-screen/value-out-of-limits?])
-        limit-exceeded?                  (controlled-input/upper-limit-exceeded? input-state)
+        limit-exceeded? (rf/sub [:send-input-amount-screen/upper-limit-exceeded?])
+        upper-limit-prettified (rf/sub [:send-input-amount-screen/upper-limit-prettified])
         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?])
+        upper-limit-equals-input-value? (rf/sub
+                                         [:send-input-amount-screen/upper-limit-equals-input-value?])
         owned-eth-token (rf/sub [:wallet/token-by-symbol
                                  (string/upper-case constants/mainnet-short-name)
                                  enabled-from-chain-ids])
@@ -269,7 +245,7 @@
                            {:enough-assets?                  enough-assets?
                             :token-symbol                    token-symbol
                             :owned-eth-token                 owned-eth-token
-                                           :input-state           input-state
+                            :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})
@@ -291,14 +267,7 @@
                                  :bounce-duration-ms     bounce-duration-ms
                                  :token                  token
                                  :reset-amounts-to-zero? (and limit-exceeded?
-                                                                          (some? routes))}))
+                                                              (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?)))]
     (rn/use-effect
      (fn []
        (when active-screen?
@@ -312,17 +281,13 @@
     (hot-reload/use-safe-unmount on-navigate-back)
     (rn/use-effect
      (fn []
-       (set-input-state #(controlled-input/set-upper-limit % max-limit)))
+       (when value-out-of-limits?
-     [max-limit])
-    (rn/use-effect
-     (fn []
-       (when input-error
          (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])
@@ -333,7 +298,7 @@
     [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])
@@ -342,9 +307,10 @@
       {:container-style style/input-container
        :token-symbol    token-symbol
        :value           input-value
-       :on-swap         swap-between-fiat-and-crypto
+       :on-swap         #(rf/dispatch [:send-input-amount-screen/swap-between-fiat-and-crypto
+                                       token-input-converted-value])
        :on-token-press  show-select-asset-sheet
-       :error?          (controlled-input/input-error input-state)
+       :error?          value-out-of-limits?
        :currency-symbol (if crypto-currency? token-symbol fiat-currency)
        :converted-value (if crypto-currency?
                           (utils/prettify-balance
@@ -360,15 +326,8 @@
                          {:networks (seq from-enabled-networks)
                           :title    (i18n/label
                                      :t/send-limit
-                                     {:limit (if crypto-currency?
+                                     {:limit upper-limit-prettified})
-                                               (utils/prettify-crypto-balance
+                          :status   (when value-out-of-limits? :error)}]}]
-                                                (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
@@ -418,19 +377,14 @@
        :left-action          :dot
        :delete-key?          true
        :on-press             (fn [c]
-                               (let [new-text      (str input-value c)
+                               (rf/dispatch [:send-input-amount-screen/token-input-add-character c
-                                     max-decimals  (if crypto-currency? crypto-decimals 2)
+                                             max-decimals]))
-                                     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)))))
        :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/send_amount/view.cljs

@@ -10,8 +10,6 @@
   [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])

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

@@ -1,20 +1,174 @@
 (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-send]
+ :<- [: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/token-input-converted-value
+ :<- [: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))))
+
+
 
 (comment
   (inc 1)
-  (rf/sub [:wallet/wallet-send])
   (rf/sub [:send-input-amount-screen/state])
+  (rf/sub [:send-input-amount-screen/max-decimals])
+  (rf/sub [:send-input-amount-screen/enabled-from-chain-ids])
+  (rf/sub [:send-input-amount-screen/from-enabled-networks])
+  (rf/sub [:send-input-amount-screen/token-by-symbol])
+  (rf/sub [:view-id])
 )

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]