Turn off malli

# Conflicts:
#	src/status_im/contexts/wallet/send/events.cljs

src/quo/components/utilities/token/view.cljs

@@ -12,7 +12,7 @@
    [:cat
     [:map {:closed true}
      [:size {:optional true :default 32} [:or keyword? pos-int?]]
-     [:token {:optional true} [:or keyword? string?]]
+     [:token {:optional true} [:maybe keyword? string?]]
      [:style {:optional true} map?]
      ;; Ignores `token` and uses this as parameter to `rn/image`'s source.
      [:image-source {:optional true} [:maybe [:or :schema.common/image-source :string]]]]]

src/quo/components/wallet/token_input/view.cljs

@@ -111,33 +111,32 @@
          :value (if controlled-input? value @value-atom)}]])))
 
 (defn- view-internal
-  [{:keys [on-swap]}]
-  (let [width          (:width (rn/get-window))
-        value-atom     (reagent/atom nil)
-        crypto?        (reagent/atom true)
-        handle-on-swap (fn []
-                         (swap! crypto? not)
-                         (when on-swap
-                           (on-swap @crypto?)))]
-    (fn [{:keys [theme container-style value] :as props}]
-      [rn/view {:style (merge (style/main-container width) container-style)}
-       [rn/view {:style style/amount-container}
-        [input-section
-         (assoc props
-                :value-atom value-atom
-                :crypto?    @crypto?)]
-        [button/button
-         {:icon                true
-          :icon-only?          true
-          :size                32
-          :on-press            handle-on-swap
-          :type                :outline
-          :accessibility-label :reorder}
-         :i/reorder]]
-       [divider-line/view {:container-style (style/divider theme)}]
-       [data-info
-        (assoc props
-               :crypto? @crypto?
-               :amount  (or value @value-atom))]])))
+  []
+  (let [width      (:width (rn/get-window))
+        value-atom (reagent/atom nil)
+        crypto?    (reagent/atom true)]
+    (fn [{:keys [theme container-style value on-swap] :as props}]
+      (let [handle-on-swap (fn []
+                             (swap! crypto? not)
+                             (when on-swap (on-swap @crypto?)))]
+        [rn/view {:style (merge (style/main-container width) container-style)}
+         [rn/view {:style style/amount-container}
+          [input-section
+           (assoc props
+                  :value-atom value-atom
+                  :crypto?    @crypto?)]
+          [button/button
+           {:icon                true
+            :icon-only?          true
+            :size                32
+            :on-press            handle-on-swap
+            :type                :outline
+            :accessibility-label :reorder}
+           :i/reorder]]
+         [divider-line/view {:container-style (style/divider theme)}]
+         [data-info
+          (assoc props
+                 :crypto? @crypto?
+                 :amount  (or value @value-atom))]]))))
 
 (def view (quo.theme/with-theme view-internal))

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

@@ -74,11 +74,13 @@
 (defn get-standard-crypto-format
   "For full details: https://github.com/status-im/status-mobile/issues/18225"
   [{:keys [market-values-per-currency]} token-units]
-  (let [price          (get-in market-values-per-currency [:usd :price])
-        one-cent-value (if (pos? price) (/ 0.01 price) 0)
-        decimals-count (calc-max-crypto-decimals one-cent-value)]
-    (if (money/equal-to token-units 0)
-      "0"
+  (if (or (nil? token-units)
+          (nil? market-values-per-currency)
+          (money/equal-to token-units 0))
+    "0"
+    (let [price          (-> market-values-per-currency :usd :price)
+          one-cent-value (if (pos? price) (/ 0.01 price) 0)
+          decimals-count (calc-max-crypto-decimals one-cent-value)]
       (if (< token-units one-cent-value)
         (str "<" (remove-trailing-zeroes (.toFixed one-cent-value decimals-count)))
         (remove-trailing-zeroes (.toFixed token-units decimals-count))))))

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

@@ -3,10 +3,12 @@
     [camel-snake-kebab.core :as csk]
     [camel-snake-kebab.extras :as cske]
     [clojure.string :as string]
+    [native-module.core :as native-module]
     [status-im.constants :as constants]
     [status-im.contexts.wallet.common.utils :as utils]
     [status-im.contexts.wallet.send.utils :as send-utils]
     [taoensso.timbre :as log]
+    [utils.address :as address]
     [utils.money :as money]
     [utils.number]
     [utils.re-frame :as rf]))
@@ -56,11 +58,14 @@
  (fn [{:keys [db]}]
    {:db (update-in db [:wallet :ui :send] dissoc :recipient :to-address)}))
 
-(rf/reg-event-fx :wallet/select-send-address
+(rf/reg-event-fx
+ :wallet/select-send-address
  (fn [{:keys [db]} [{:keys [address token recipient stack-id]}]]
    (let [[prefix to-address] (utils/split-prefix-and-address address)
          prefix-seq          (string/split prefix #":")
-         selected-networks   (mapv #(utils/short-name->id (keyword %)) prefix-seq)]
+         selected-networks   (->> prefix-seq
+                                  (remove string/blank?)
+                                  (mapv #(utils/short-name->id (keyword %))))]
      {:db (-> db
               (assoc-in [:wallet :ui :send :recipient] (or recipient address))
               (assoc-in [:wallet :ui :send :to-address] to-address)
@@ -71,18 +76,20 @@
               [:wallet-send-input-amount stack-id]
               [:wallet-select-asset stack-id])]]})))
 
-(rf/reg-event-fx :wallet/update-receiver-networks
+(rf/reg-event-fx
+ :wallet/update-receiver-networks
  (fn [{:keys [db]} [selected-networks]]
    {:db (assoc-in db [:wallet :ui :send :selected-networks] selected-networks)}))
 
 (rf/reg-event-fx :wallet/send-select-token
  (fn [{:keys [db]} [{:keys [token stack-id]}]]
-   {:db (assoc-in db [:wallet :ui :send :token] token)
-    :fx [[:dispatch-later
-          {:ms       1
-           :dispatch [:navigate-to-within-stack [:wallet-send-input-amount stack-id]]}]]}))
+   {:db (-> db
+            (update-in [:wallet :ui :send] dissoc :collectible)
+            (assoc-in [:wallet :ui :send :token] token))
+    :fx [[:navigate-to-within-stack [:wallet-send-input-amount stack-id]]]}))
 
-(rf/reg-event-fx :wallet/send-select-token-drawer
+(rf/reg-event-fx
+ :wallet/send-select-token-drawer
  (fn [{:keys [db]} [{:keys [token]}]]
    {:db (assoc-in db [:wallet :ui :send :token] token)}))
 
@@ -90,6 +97,15 @@
  (fn [{:keys [db]}]
    {:db (assoc-in db [:wallet :ui :send :token] nil)}))
 
+(rf/reg-event-fx :wallet/send-select-collectible
+ (fn [{:keys [db]} [{:keys [collectible stack-id]}]]
+   {:db (-> db
+            (update-in [:wallet :ui :send] dissoc :token)
+            (assoc-in [:wallet :ui :send :collectible] collectible)
+            (assoc-in [:wallet :ui :send :amount] 1))
+    :fx [[:dispatch [:wallet/get-suggested-routes 1]]
+         [:navigate-to-within-stack [:wallet-transaction-confirmation stack-id]]]}))
+
 (rf/reg-event-fx :wallet/send-select-amount
  (fn [{:keys [db]} [{:keys [amount stack-id]}]]
    {:db (assoc-in db [:wallet :ui :send :amount] amount)
@@ -99,19 +115,25 @@
  (fn [{:keys [db now]} [amount]]
    (let [wallet-address          (get-in db [:wallet :current-viewing-account-address])
          token                   (get-in db [:wallet :ui :send :token])
-         account-address         (get-in db [:wallet :ui :send :send-account-address])
-         selected-networks       (get-in db [:wallet :ui :send :selected-networks])
-         to-address              (or account-address (get-in db [:wallet :ui :send :to-address]))
-         token-decimal           (:decimals token)
-         token-id                (:symbol token)
-         network-preferences     selected-networks
+         collectible             (get-in db [:wallet :ui :send :collectible])
+         to-address              (get-in db [:wallet :ui :send :to-address])
+         token-decimal           (when token (:decimals token))
+         token-id                (if token
+                                   (:symbol token)
+                                   (str (get-in collectible [:id :contract-id :address])
+                                        ":"
+                                        (get-in collectible [:id :token-id])))
+         network-preferences     (if token [] [(get-in collectible [:id :contract-id :chain-id])])
          gas-rates               constants/gas-rate-medium
-         amount-in               (send-utils/amount-in-hex amount token-decimal)
+         amount-in               (send-utils/amount-in-hex amount (if token token-decimal 0))
          from-address            wallet-address
          disabled-from-chain-ids []
          disabled-to-chain-ids   []
          from-locked-amount      {}
-         request-params          [constants/send-type-transfer
+         transaction-type        (if token
+                                   constants/send-type-transfer
+                                   constants/send-type-erc-721-transfer)
+         request-params          [transaction-type
                                   from-address
                                   to-address
                                   amount-in
@@ -155,21 +177,46 @@
    {:fx [[:dispatch [:dismiss-modal :wallet-transaction-progress]]]}))
 
 (defn- transaction-bridge
-  [{:keys [from-address to-address route]}]
-  (let [{:keys [from bridge-name amount-out gas-amount gas-fees]}           route
-        {:keys [gas-price max-fee-per-gas-medium max-priority-fee-per-gas]} gas-fees]
-    [{:BridgeName bridge-name
-      :ChainID    (:chain-id from)
-      :TransferTx {:From                 from-address
-                   :To                   to-address
-                   :Gas                  (money/to-hex gas-amount)
-                   :GasPrice             (money/to-hex (money/->wei :gwei gas-price))
-                   :Value                amount-out
-                   :Nonce                nil
-                   :MaxFeePerGas         (money/to-hex (money/->wei :gwei max-fee-per-gas-medium))
-                   :MaxPriorityFeePerGas (money/to-hex (money/->wei :gwei max-priority-fee-per-gas))
-                   :Input                ""
-                   :Data                 "0x"}}]))
+  [{:keys [from-address from-chain-id to-address token-id token-address route data eth-transfer?]}]
+  (let [{:keys [bridge-name amount-out gas-amount
+                gas-fees]}                 route
+        eip-1559-enabled?                  (:eip-1559-enabled gas-fees)
+        {:keys [gas-price max-fee-per-gas-medium
+                max-priority-fee-per-gas]} gas-fees
+        transfer-tx                        (cond-> {:From  from-address
+                                                    :To    (or token-address to-address)
+                                                    :Gas   (money/to-hex gas-amount)
+                                                    :Value (when eth-transfer? amount-out)
+                                                    :Nonce nil
+                                                    :Input ""
+                                                    :Data  (or data "0x")}
+                                             eip-1559-enabled?       (assoc :TxType "0x02"
+                                                                            :MaxFeePerGas
+                                                                            (money/to-hex
+                                                                             (money/->wei
+                                                                              :gwei
+                                                                              max-fee-per-gas-medium))
+                                                                            :MaxPriorityFeePerGas
+                                                                            (money/to-hex
+                                                                             (money/->wei
+                                                                              :gwei
+                                                                              max-priority-fee-per-gas)))
+                                             (not eip-1559-enabled?) (assoc :TxType   "0x00"
+                                                                            :GasPrice (money/to-hex
+                                                                                       (money/->wei
+                                                                                        :gwei
+                                                                                        gas-price))))]
+    [(cond-> {:BridgeName bridge-name
+              :ChainID    from-chain-id}
+
+       (= bridge-name constants/bridge-name-erc-721-transfer)
+       (assoc :ERC721TransferTx
+              (assoc transfer-tx
+                     :Recipient to-address
+                     :TokenID   token-id))
+
+       (= bridge-name constants/bridge-name-transfer)
+       (assoc :TransferTx transfer-tx))]))
 
 (defn- multi-transaction-command
   [{:keys [from-address to-address from-asset to-asset amount-out transfer-type]
@@ -183,25 +230,50 @@
 
 (rf/reg-event-fx :wallet/send-transaction
  (fn [{:keys [db]} [sha3-pwd]]
-   (let [route          (get-in db [:wallet :ui :send :route])
-         from-address   (get-in db [:wallet :current-viewing-account-address])
-         to-address     (get-in db [:wallet :ui :send :to-address])
-         token          (get-in db [:wallet :ui :send :token])
-         token-id       (:symbol token)
-         request-params [(multi-transaction-command {:from-address from-address
-                                                     :to-address   to-address
-                                                     :from-asset   token-id
-                                                     :to-asset     token-id
-                                                     :amount-out   (:amount-out route)})
-                         (transaction-bridge {:to-address   to-address
-                                              :from-address from-address
-                                              :route        route})
-                         sha3-pwd]]
+   (let [route           (get-in db [:wallet :ui :send :route])
+         from-address    (get-in db [:wallet :current-viewing-account-address])
+         token           (get-in db [:wallet :ui :send :token])
+         collectible     (get-in db [:wallet :ui :send :collectible])
+         from-chain-id   (get-in route [:from :chain-id])
+         token-id        (if token
+                           (:symbol token)
+                           (get-in collectible [:id :token-id]))
+         erc20-transfer? (and token (not= token-id "ETH"))
+         eth-transfer?   (and token (not erc20-transfer?))
+         token-address   (cond collectible
+                               (get-in collectible
+                                       [:id :contract-id :address])
+                               erc20-transfer?
+                               (get-in token [:balances-per-chain from-chain-id :address]))
+         to-address      (get-in db [:wallet :ui :send :to-address])
+         data            (when erc20-transfer?
+                           (native-module/encode-transfer (address/normalized-hex to-address)
+                                                          (:amount-out route)))
+         request-params  [(multi-transaction-command
+                           {:from-address from-address
+                            :to-address   to-address
+                            :from-asset   token-id
+                            :to-asset     token-id
+                            :amount-out   (if eth-transfer? (:amount-out route) "0x0")})
+                          (transaction-bridge {:to-address    to-address
+                                               :from-address  from-address
+                                               :route         route
+                                               :from-chain-id from-chain-id
+                                               :token-address token-address
+                                               :token-id      (when collectible
+                                                                (money/to-hex (js/parseInt token-id)))
+                                               :data          data
+                                               :eth-transfer? eth-transfer?})
+                          sha3-pwd]]
      {:json-rpc/call [{:method     "wallet_createMultiTransaction"
                        :params     request-params
                        :on-success (fn [result]
                                      (rf/dispatch [:hide-bottom-sheet])
-                                     (rf/dispatch [:wallet/add-authorized-transaction result]))
+                                     (rf/dispatch [:wallet/add-authorized-transaction result])
+                                     (rf/dispatch [:wallet/clean-scanned-address])
+                                     (rf/dispatch [:wallet/clean-local-suggestions])
+                                     (rf/dispatch [:wallet/clean-send-address])
+                                     (rf/dispatch [:wallet/select-address-tab nil]))
                        :on-error   (fn [error]
                                      (log/error "failed to send transaction"
                                                 {:event  :wallet/send-transaction

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

@@ -30,11 +30,11 @@
 (defn valid-input?
   [current v]
   (let [max-length          12
-        length-owerflow?    (>= (count current) max-length)
+        length-overflow?    (>= (count current) max-length)
         extra-dot?          (and (= v dot) (string/includes? current dot))
         extra-leading-zero? (and (= current "0") (= "0" (str v)))
         non-numeric?        (re-find not-digits-or-dot-pattern (str v))]
-    (not (or non-numeric? extra-dot? extra-leading-zero? length-owerflow?))))
+    (not (or non-numeric? extra-dot? extra-leading-zero? length-overflow?))))
 
 (defn- normalize-input
   [current v]
@@ -61,122 +61,131 @@
 
 (defn- f-view-internal
   ;; crypto-decimals and limit-crypto args are needed for component tests only
-  [{:keys [crypto-decimals limit-crypto]}]
-  (let [bottom                    (safe-area/get-bottom)
-        {:keys [currency]}        (rf/sub [:profile/profile])
-        token                     (rf/sub [:wallet/wallet-send-token])
-        loading-suggested-routes? (rf/sub [:wallet/wallet-send-loading-suggested-routes?])
-        token-symbol              (:symbol token)
-        limit-crypto              (or limit-crypto
-                                      (utils/get-standard-crypto-format token (:total-balance token)))
-        conversion-rate           (get-in token [:market-values-per-currency :usd :price])
-        limit-fiat                (.toFixed (* (:total-balance token) conversion-rate) 2)
-        crypto-decimals           (or crypto-decimals (utils/get-crypto-decimals-count token))
-        input-value               (reagent/atom "")
-        input-error               (reagent/atom false)
-        current-limit             (reagent/atom {:amount   limit-crypto
-                                                 :currency token-symbol})
-        handle-swap               (fn [crypto?]
-                                    (let [num-value (parse-double @input-value)]
-                                      (reset! current-limit (if crypto?
-                                                              {:amount   limit-crypto
-                                                               :currency token-symbol}
-                                                              {:amount   limit-fiat
-                                                               :currency currency}))
-                                      (reset-input-error num-value
-                                                         (:amount @current-limit)
-                                                         input-error)))
-        handle-keyboard-press     (fn [v]
-                                    (let [current-value        @input-value
-                                          new-value            (make-new-input current-value v)
-                                          num-value            (or (parse-double new-value) 0)
-                                          current-limit-amount (:amount @current-limit)]
-                                      (when (not loading-suggested-routes?)
-                                        (reset! input-value new-value)
-                                        (reset-input-error num-value current-limit-amount input-error)
-                                        (reagent/flush))))
-        handle-delete             (fn [_]
-                                    (when-not loading-suggested-routes?
-                                      (let [current-limit-amount (:amount @current-limit)]
-                                        (swap! input-value #(subs % 0 (dec (count %))))
-                                        (reset-input-error @input-value current-limit-amount input-error)
-                                        (reagent/flush))))
-        handle-on-change          (fn [v]
-                                    (when (valid-input? @input-value v)
-                                      (let [num-value            (or (parse-double v) 0)
-                                            current-limit-amount (:amount @current-limit)]
-                                        (reset! input-value v)
-                                        (reset-input-error num-value current-limit-amount input-error)
-                                        (reagent/flush))))]
-    (fn [{:keys [on-confirm]
-          :or   {on-confirm #(rf/dispatch [:wallet/send-select-amount
-                                           {:amount   @input-value
-                                            :stack-id :wallet-send-input-amount}])}}]
-      (let [limit-label       (make-limit-label @current-limit)
-            input-num-value   (parse-double @input-value)
-            suggested-routes  (rf/sub [:wallet/wallet-send-suggested-routes])
-            route             (rf/sub [:wallet/wallet-send-route])
-            confirm-disabled? (or
-                               (nil? route)
-                               (empty? @input-value)
-                               (<= input-num-value 0)
-                               (> input-num-value (:amount @current-limit)))
-            amount            (str @input-value " " token-symbol)
-            {:keys [color]}   (rf/sub [:wallet/current-viewing-account])
-            fetch-routes      (fn []
+  [{default-on-confirm      :on-confirm
+    default-limit-crypto    :limit-crypto
+    default-crypto-decimals :crypto-decimals}]
+  (let [_ (rn/dismiss-keyboard!)
+        bottom                (safe-area/get-bottom)
+        input-value           (reagent/atom "")
+        input-error           (reagent/atom false)
+        crypto-currency?      (reagent/atom true)
+        handle-swap           (fn [{:keys [crypto? limit-fiat limit-crypto]}]
+                                (let [num-value     (parse-double @input-value)
+                                      current-limit (if crypto? limit-crypto limit-fiat)]
+                                  (reset! crypto-currency? crypto?)
+                                  (reset-input-error num-value current-limit input-error)))
+        handle-keyboard-press (fn [v loading-routes? current-limit-amount]
+                                (let [current-value @input-value
+                                      new-value     (make-new-input current-value v)
+                                      num-value     (or (parse-double new-value) 0)]
+                                  (when (not loading-routes?)
+                                    (reset! input-value new-value)
+                                    (reset-input-error num-value current-limit-amount input-error)
+                                    (reagent/flush))))
+        handle-delete         (fn [loading-routes? current-limit-amount]
+                                (when-not loading-routes?
+                                  (swap! input-value #(subs % 0 (dec (count %))))
+                                  (reset-input-error @input-value current-limit-amount input-error)
+                                  (reagent/flush)))
+        handle-on-change      (fn [v current-limit-amount]
+                                (when (valid-input? @input-value v)
+                                  (let [num-value (or (parse-double v) 0)]
+                                    (reset! input-value v)
+                                    (reset-input-error num-value current-limit-amount input-error)
+                                    (reagent/flush))))
+        on-navigate-back      (fn []
+                                (rf/dispatch [:wallet/clean-selected-token])
+                                (rf/dispatch [:navigate-back-within-stack :wallet-send-input-amount]))
+        fetch-routes          (fn [input-num-value current-limit-amount]
                                 (rf/dispatch [:wallet/clean-suggested-routes])
-                                (when-not (or
-                                           (empty? @input-value)
-                                           (<= input-num-value 0)
-                                           (> input-num-value (:amount @current-limit)))
-                                  (debounce/debounce-and-dispatch [:wallet/get-suggested-routes
-                                                                   @input-value]
-                                                                  100)))]
+                                (when-not (or (empty? @input-value)
+                                              (<= input-num-value 0)
+                                              (> input-num-value current-limit-amount))
+                                  (debounce/debounce-and-dispatch
+                                   [:wallet/get-suggested-routes @input-value]
+                                   100)))
+        handle-on-confirm     (fn []
+                                (rf/dispatch [:wallet/send-select-amount
+                                              {:amount   @input-value
+                                               :stack-id :wallet-send-input-amount}]))]
+    (fn []
+      (let [{fiat-currency :currency} (rf/sub [:profile/profile])
+            {:keys [color]}           (rf/sub [:wallet/current-viewing-account])
+            {token-balance  :total-balance
+             token-symbol   :symbol
+             token-networks :networks
+             :as            token}    (rf/sub [:wallet/wallet-send-token])
+            conversion-rate           (-> token :market-values-per-currency :usd :price)
+            loading-routes?           (rf/sub [:wallet/wallet-send-loading-suggested-routes?])
+            suggested-routes          (rf/sub [:wallet/wallet-send-suggested-routes])
+            route                     (rf/sub [:wallet/wallet-send-route])
+            on-confirm                (or default-on-confirm handle-on-confirm)
+            crypto-decimals           (or default-crypto-decimals
+                                          (utils/get-crypto-decimals-count token))
+            crypto-limit              (or default-limit-crypto
+                                          (utils/get-standard-crypto-format token token-balance))
+            fiat-limit                (.toFixed (* token-balance conversion-rate) 2)
+            current-limit             (if @crypto-currency? crypto-limit fiat-limit)
+            current-currency          (if @crypto-currency? token-symbol fiat-currency)
+            limit-label               (make-limit-label {:amount   current-limit
+                                                         :currency current-currency})
+            input-num-value           (parse-double @input-value)
+            confirm-disabled?         (or (nil? route)
+                                          (empty? @input-value)
+                                          (<= input-num-value 0)
+                                          (> input-num-value current-limit))
+            amount-text               (str @input-value " " token-symbol)]
         (rn/use-effect
          (fn []
            (let [dismiss-keyboard-fn   #(when (= % "active") (rn/dismiss-keyboard!))
                  app-keyboard-listener (.addEventListener rn/app-state "change" dismiss-keyboard-fn)]
              #(.remove app-keyboard-listener))))
-        (rn/use-effect #(fetch-routes) [@input-value])
+        (rn/use-effect
+         #(fetch-routes input-num-value current-limit)
+         [@input-value])
         [rn/view
          {:style               style/screen
           :accessibility-label (str "container" (when @input-error "-error"))}
          [account-switcher/view
           {:icon-name     :i/arrow-left
-           :on-press      #(rf/dispatch [:navigate-back-within-stack :wallet-send-input-amount])
+           :on-press      on-navigate-back
            :switcher-type :select-account}]
          [quo/token-input
           {:container-style style/input-container
            :token           token-symbol
-           :currency        currency
+           :currency        current-currency
            :crypto-decimals crypto-decimals
            :error?          @input-error
-           :networks        (:networks token)
+           :networks        token-networks
            :title           (i18n/label :t/send-limit {:limit limit-label})
            :conversion      conversion-rate
            :show-keyboard?  false
            :value           @input-value
-           :on-swap         handle-swap
-           :on-change-text  (fn [text]
-                              (handle-on-change text))}]
+           :on-change-text  #(handle-on-change % current-limit)
+           :on-swap         #(handle-swap
+                              {:crypto?      %
+                               :currency     current-currency
+                               :token-symbol token-symbol
+                               :limit-fiat   fiat-limit
+                               :limit-crypto crypto-limit})}]
          [routes/view
-          {:amount       amount
+          {:amount       amount-text
            :routes       suggested-routes
            :token        token
            :input-value  @input-value
-           :fetch-routes fetch-routes}]
+           :fetch-routes #(fetch-routes % current-limit)}]
          [quo/bottom-actions
           {:actions             :1-action
+           :customization-color color
            :button-one-label    (i18n/label :t/confirm)
            :button-one-props    {:disabled? confirm-disabled?
-                                 :on-press  on-confirm}
-           :customization-color color}]
+                                 :on-press  on-confirm}}]
          [quo/numbered-keyboard
           {:container-style (style/keyboard-container bottom)
            :left-action     :dot
            :delete-key?     true
-           :on-press        handle-keyboard-press
-           :on-delete       handle-delete}]]))))
+           :on-press        #(handle-keyboard-press % loading-routes? current-limit)
+           :on-delete       #(handle-delete loading-routes? current-limit)}]]))))
 
 (defn- view-internal
   [props]

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

@@ -17,22 +17,21 @@
    {:id :tab/collectibles :label (i18n/label :t/collectibles) :accessibility-label :collectibles-tab}])
 
 (defn- asset-component
-  []
-  (fn [token _ _ {:keys [currency currency-symbol]}]
-    (let [on-press         #(rf/dispatch [:wallet/send-select-token
-                                          {:token    token
-                                           :stack-id :wallet-select-asset}])
-          token-units      (utils/total-token-units-in-all-chains token)
-          crypto-formatted (utils/get-standard-crypto-format token token-units)
-          fiat-value       (utils/total-token-fiat-value currency token)
-          fiat-formatted   (utils/get-standard-fiat-format crypto-formatted currency-symbol fiat-value)]
-      [quo/token-network
-       {:token       (:symbol token)
-        :label       (:name token)
-        :token-value (str crypto-formatted " " (:symbol token))
-        :fiat-value  fiat-formatted
-        :networks    (:networks token)
-        :on-press    on-press}])))
+  [token _ _ {:keys [currency currency-symbol]}]
+  (let [on-press         #(rf/dispatch [:wallet/send-select-token
+                                        {:token    token
+                                         :stack-id :wallet-select-asset}])
+        token-units      (utils/total-token-units-in-all-chains token)
+        crypto-formatted (utils/get-standard-crypto-format token token-units)
+        fiat-value       (utils/total-token-fiat-value currency token)
+        fiat-formatted   (utils/get-standard-fiat-format crypto-formatted currency-symbol fiat-value)]
+    [quo/token-network
+     {:token       (:symbol token)
+      :label       (:name token)
+      :token-value (str crypto-formatted " " (:symbol token))
+      :fiat-value  fiat-formatted
+      :networks    (:networks token)
+      :on-press    on-press}]))
 
 (defn- asset-list
   [search-text]

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

@@ -74,7 +74,7 @@
      :account-props account-props}]])
 
 (defn- transaction-details
-  [{:keys [estimated-time-min max-fees token amount to-address route theme]}]
+  [{:keys [estimated-time-min max-fees token-symbol amount to-address route theme]}]
   (let [currency-symbol (rf/sub [:profile/currency-symbol])
         route-loaded?   (some? route)]
     [rn/view
@@ -123,7 +123,7 @@
            :status          :default
            :size            :small
            :title           (i18n/label :t/user-gets {:name (utils/get-shortened-address to-address)})
-           :subtitle        (str amount " " (:symbol token))}]]
+           :subtitle        (str amount " " token-symbol)}]]
         [rn/activity-indicator {:style {:align-self :center}}])]]))
 
 (defn- view-internal
@@ -213,7 +213,7 @@
            [transaction-details
             {:estimated-time-min estimated-time-min
              :max-fees           max-fees
-             :token              token
+             :token-symbol       token-symbol
              :amount             amount
              :to-address         to-address
              :theme              theme

src/status_im/setup/schema.cljs

@@ -88,7 +88,8 @@
   manually call `setup!`, otherwise you won't see any changes. It is safe and
   even expected you will call `setup!` multiple times in REPLs."
   []
-  (try
+  nil
+  #_(try
     (schema.registry/init-global-registry)
     (register-schemas)