feat(swap): fetch swap proposals

Signed-off-by: Brian Sztamfater <[email protected]>

Author: briansztamfater

src/quo/components/banners/alert_banner/schema.cljs

@@ -7,6 +7,7 @@
      [:map {:closed true}
       [:action? {:optional true} [:maybe boolean?]]
       [:text {:optional true} [:maybe string?]]
+      [:container-style {:optional true} [:maybe :map]]
       [:button-text {:optional true} [:maybe string?]]
       [:on-button-press {:optional true} [:maybe fn?]]]]]
    :any])

src/quo/components/banners/alert_banner/style.cljs

@@ -1,12 +1,15 @@
 (ns quo.components.banners.alert-banner.style
   (:require [quo.foundations.colors :as colors]))
 
-(def container
-  {:flex-direction     :row
-   :align-items        :center
-   :height             50
-   :padding-horizontal 20
-   :padding-vertical   12})
+(defn container
+  [container-style]
+  (merge
+   {:flex-direction     :row
+    :align-items        :center
+    :height             50
+    :padding-horizontal 20
+    :padding-vertical   12}
+   container-style))
 
 (defn label
   [theme]

src/quo/components/banners/alert_banner/view.cljs

@@ -11,12 +11,12 @@
             [schema.core :as schema]))
 
 (defn- view-internal
-  [{:keys [action? text button-text on-button-press]}]
+  [{:keys [action? text button-text container-style on-button-press]}]
   (let [theme (quo.theme/use-theme)]
     [rn/view
      {:accessibility-label :alert-banner}
      [linear-gradient/linear-gradient
-      {:style  style/container
+      {:style  (style/container container-style)
        :start  {:x 0 :y 0}
        :end    {:x 0 :y 1}
        :colors [(colors/theme-colors

src/quo/components/settings/data_item/view.cljs

@@ -126,7 +126,7 @@
       [:subtitle-type {:optional true} [:maybe [:enum :default :icon :network :account :editable]]]
       [:size {:optional true} [:maybe [:enum :default :small :large]]]
       [:title :string]
-      [:subtitle {:optional true} [:maybe :string]]
+      [:subtitle {:optional true} [:maybe [:or :string :double]]]
       [:custom-subtitle {:optional true} [:maybe fn?]]
       [:icon {:optional true} [:maybe :keyword]]
       [:emoji {:optional true} [:maybe :string]]

src/quo/components/wallet/swap_input/style.cljs

@@ -1,5 +1,6 @@
 (ns quo.components.wallet.swap-input.style
   (:require [quo.foundations.colors :as colors]
+            [quo.foundations.shadows :as shadows]
             [quo.foundations.typography :as typography]))
 
 (defn- border-color
@@ -11,11 +12,13 @@
   (colors/theme-colors colors/neutral-5 colors/neutral-90 theme))
 
 (defn content
-  [theme]
-  {:border-width     1
-   :border-radius    16
-   :border-color     (border-color theme)
-   :background-color (colors/theme-colors colors/white colors/neutral-95 theme)})
+  [typing? theme]
+  (merge
+   {:border-width     1
+    :border-radius    16
+    :border-color     (border-color theme)
+    :background-color (colors/theme-colors colors/white colors/neutral-95 theme)}
+   (when typing? (shadows/get 1 theme))))
 
 (defn row-1
   [loading?]

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

@@ -19,20 +19,23 @@
     [:props
      [:map {:closed true}
       [:type {:optional true} [:maybe [:enum :pay :receive]]]
-      [:status {:optional true} [:maybe [:enum :default :disabled :loading]]]
+      [:status {:optional true} [:maybe [:enum :default :typing :disabled :loading]]]
       [:token {:optional true} [:maybe :string]]
       [:value {:optional true} [:maybe :string]]
       [:default-value {:optional true} [:maybe :string]]
       [:currency-symbol {:optional true} [:maybe :string]]
       [:fiat-value {:optional true} [:maybe :string]]
       [:show-approval-label? {:optional true} [:maybe :boolean]]
+      [:auto-focus? {:optional true} [:maybe :boolean]]
+      [:input-disabled? {:optional true} [:maybe :boolean]]
       [:error? {:optional true} [:maybe :boolean]]
       [:show-keyboard? {:optional true} [:maybe :boolean]]
       [:approval-label-props {:optional true} [:maybe approval-label.schema/?schema]]
       [:network-tag-props {:optional true} [:maybe :map]]
       [:on-change-text {:optional true} [:maybe fn?]]
       [:enable-swap? {:optional true} [:maybe :boolean]]
       [:on-swap-press {:optional true} [:maybe fn?]]
+      [:on-input-focus {:optional true} [:maybe fn?]]
       [:on-token-press {:optional true} [:maybe fn?]]
       [:on-max-press {:optional true} [:maybe fn?]]
       [:customization-color {:optional true} [:maybe :schema.common/customization-color]]
@@ -41,13 +44,14 @@
 
 (defn view-internal
   [{:keys [type status token value fiat-value show-approval-label? error? network-tag-props
-           approval-label-props default-value enable-swap?
+           approval-label-props default-value auto-focus? input-disabled? enable-swap?
            currency-symbol on-change-text show-keyboard?
-           container-style on-swap-press on-token-press on-max-press]}]
+           container-style on-swap-press on-token-press on-max-press on-input-focus]}]
   (let [theme             (quo.theme/use-theme)
         pay?              (= type :pay)
         disabled?         (= status :disabled)
         loading?          (= status :loading)
+        typing?           (= status :typing)
         controlled-input? (some? value)
         input-ref         (rn/use-ref-atom nil)
         set-input-ref     (rn/use-callback (fn [ref] (reset! input-ref ref)) [])
@@ -58,7 +62,7 @@
     [rn/view
      {:style               container-style
       :accessibility-label :swap-input}
-     [rn/view {:style (style/content theme)}
+     [rn/view {:style (style/content typing? theme)}
       [rn/view
        {:style (style/row-1 loading?)}
        [rn/pressable {:on-press on-token-press}
@@ -78,7 +82,9 @@
                                                                     colors/neutral-50
                                                                     theme)
                      :keyboard-type            :numeric
-                     :auto-focus               true
+                     :editable                 (not input-disabled?)
+                     :auto-focus               auto-focus?
+                     :on-focus                 on-input-focus
                      :on-change-text           on-change-text
                      :show-soft-input-on-focus show-keyboard?
                      :default-value            default-value

src/status_im/constants.cljs

@@ -553,6 +553,7 @@
 (def ^:const send-type-bridge 5)
 (def ^:const send-type-erc-721-transfer 6)
 (def ^:const send-type-erc-1155-transfer 7)
+(def ^:const send-type-swap 8)
 
 (def ^:const multi-transaction-type-send 0)
 (def ^:const multi-transaction-type-approve 1)
@@ -598,3 +599,5 @@
    :color                    :blue
    :contract-address         "0xdef171fe48cf0115b1d80b88dc8eab59176fee57"
    :terms-and-conditions-url "https://files.paraswap.io/tos_v4.pdf"})
+
+(def ^:const token-for-fees-symbol "ETH")

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

@@ -518,23 +518,29 @@
 
 (rf/reg-event-fx
  :wallet/handle-suggested-routes
- (fn [_ [data]]
-   (if-let [{:keys [code details]} (-> data :ErrorResponse)]
-     (let [error-message (if (= code "0") "An error occurred" details)]
-       (log/error "failed to get suggested routes (async)"
-                  {:event :wallet/handle-suggested-routes
-                   :error error-message})
-       {:fx [[:dispatch [:wallet/suggested-routes-error error-message]]]})
-     (let [best-routes-fix (comp ->old-route-paths
-                                 remove-invalid-bonder-fees-routes
-                                 remove-multichain-routes)
-           candidates-fix  (comp ->old-route-paths
-                                 remove-invalid-bonder-fees-routes)
-           routes          (-> data
-                               (data-store/rpc->suggested-routes)
-                               (update :best best-routes-fix)
-                               (update :candidates candidates-fix))]
-       {:fx [[:dispatch [:wallet/suggested-routes-success routes]]]}))))
+ (fn [{:keys [db]} [data]]
+   (let [swap?                                     (get-in db [:wallet :ui :swap])
+         {:keys [code details] :as error-response} (-> data :ErrorResponse)]
+     (if (and (not swap?) error-response)
+       (let [error-message (if (= code "0") "An error occurred" details)]
+         (log/error "failed to get suggested routes (async)"
+                    {:event :wallet/handle-suggested-routes
+                     :error error-message})
+         {:fx [(if swap?
+                 [:dispatch [:wallet/swap-proposal-error error-message]]
+                 [:dispatch [:wallet/suggested-routes-error error-message]])]})
+       (let [best-routes-fix (comp ->old-route-paths
+                                   remove-invalid-bonder-fees-routes
+                                   remove-multichain-routes)
+             candidates-fix  (comp ->old-route-paths
+                                   remove-invalid-bonder-fees-routes)
+             routes          (-> data
+                                 (data-store/rpc->suggested-routes)
+                                 (update :best best-routes-fix)
+                                 (update :candidates candidates-fix))]
+         {:fx [(if swap?
+                 [:dispatch [:wallet/swap-proposal-success routes]]
+                 [:dispatch [:wallet/suggested-routes-success routes]])]})))))
 
 (rf/reg-event-fx :wallet/add-authorized-transaction
  (fn [{:keys [db]} [transaction]]

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

@@ -1,7 +1,9 @@
 (ns status-im.contexts.wallet.swap.events
   (:require [re-frame.core :as rf]
             [status-im.constants :as constants]
+            [status-im.contexts.wallet.send.utils :as send-utils]
             [status-im.contexts.wallet.sheets.network-selection.view :as network-selection]
+            [taoensso.timbre :as log]
             [utils.number]))
 
 (rf/reg-event-fx :wallet.swap/start
@@ -14,7 +16,9 @@
             (assoc-in [:wallet :ui :swap :asset-to-pay] token)
             (assoc-in [:wallet :ui :swap :network] network))
     :fx (if network
-          [[:dispatch [:navigate-to :screen/wallet.swap-propasal]]
+          [[:dispatch
+            [:navigate-to-within-stack
+             [:screen/wallet.setup-swap :screen/wallet.swap-select-asset-to-pay]]]
            [:dispatch [:wallet.swap/set-default-slippage]]]
           [[:dispatch
             [:show-bottom-sheet
@@ -30,10 +34,6 @@
                                                    :stack-id
                                                    :screen/wallet.swap-select-asset-to-pay}]))}])}]]])}))
 
-(rf/reg-event-fx :wallet.swap/clean-asset-to-pay
- (fn [{:keys [db]}]
-   {:db (update-in db [:wallet :ui :swap] dissoc :asset-to-pay)}))
-
 (rf/reg-event-fx :wallet.swap/set-default-slippage
  (fn [{:keys [db]}]
    {:db
@@ -47,18 +47,113 @@
  (fn [{:keys [db]} [{:keys [token]}]]
    {:db (assoc-in db [:wallet :ui :swap :asset-to-receive] token)}))
 
-(rf/reg-event-fx :wallet.swap/set-pay-amount
- (fn [{:keys [db]} [amount]]
-   {:db (assoc-in db [:wallet :ui :swap :pay-amount] amount)}))
+(rf/reg-event-fx :wallet.swap/recalculate-fees
+ (fn [{:keys [db]} [loading-fees?]]
+   {:db (assoc-in db [:wallet :ui :swap :loading-fees?] loading-fees?)}))
+
+(rf/reg-event-fx :wallet/start-get-swap-proposal
+ (fn [{:keys [db]} [{:keys [amount-in amount-out]}]]
+   (let [wallet-address          (get-in db [:wallet :current-viewing-account-address])
+         {:keys [asset-to-pay asset-to-receive
+                 network]}       (get-in db [:wallet :ui :swap])
+         test-networks-enabled?  (get-in db [:profile/profile :test-networks-enabled?])
+         networks                ((if test-networks-enabled? :test :prod)
+                                  (get-in db [:wallet :networks]))
+         network-chain-ids       (map :chain-id networks)
+         pay-token-decimal       (:decimals asset-to-pay)
+         pay-token-id            (:symbol asset-to-pay)
+         receive-token-id        (:symbol asset-to-receive)
+         receive-token-decimals  (:decimals asset-to-receive)
+         gas-rates               constants/gas-rate-medium
+         amount-in-hex           (if amount-in
+                                   (send-utils/amount-in-hex amount-in pay-token-decimal)
+                                   0)
+         amount-out-hex          (when amount-out
+                                   (send-utils/amount-in-hex amount-out receive-token-decimals))
+         to-address              wallet-address
+         from-address            wallet-address
+         swap-chain-id           (:chain-id network)
+         disabled-to-chain-ids   (filter #(not= % swap-chain-id) network-chain-ids)
+         disabled-from-chain-ids (filter #(not= % swap-chain-id) network-chain-ids)
+         from-locked-amount      {}
+         send-type               constants/send-type-swap
+         request-uuid            (str (random-uuid))
+         params                  [(cond->
+                                    {:uuid                 request-uuid
+                                     :sendType             send-type
+                                     :addrFrom             from-address
+                                     :addrTo               to-address
+                                     :tokenID              pay-token-id
+                                     :toTokenID            receive-token-id
+                                     :disabledFromChainIDs disabled-from-chain-ids
+                                     :disabledToChainIDs   disabled-to-chain-ids
+                                     :gasFeeMode           gas-rates
+                                     :fromLockedAmount     from-locked-amount}
+                                    amount-in  (assoc :amountIn amount-in-hex)
+                                    amount-out (assoc :amountOut amount-out-hex))]]
+     (when-let [amount (or amount-in amount-out)]
+       {:db            (update-in db
+                                  [:wallet :ui :swap]
+                                  #(-> %
+                                       (assoc
+                                        :last-request-uuid      request-uuid
+                                        :amount                 amount
+                                        :loading-swap-proposal? true)
+                                       (dissoc :error-response)))
+        :json-rpc/call [{:method   "wallet_getSuggestedRoutesV2Async"
+                         :params   params
+                         :on-error (fn [error]
+                                     (rf/dispatch [:wallet/swap-proposal-error error])
+                                     (log/error "failed to get suggested routes (async)"
+                                                {:event  :wallet/start-get-swap-proposal
+                                                 :error  (:message error)
+                                                 :params params}))}]}))))
 
-(rf/reg-event-fx :wallet.swap/set-swap-proposal
+(rf/reg-event-fx :wallet/swap-proposal-success
  (fn [{:keys [db]} [swap-proposal]]
-   {:db (assoc-in db [:wallet :ui :swap :swap-proposal] swap-proposal)}))
+   (let [last-request-uuid (get-in db [:wallet :ui :swap :last-request-uuid])
+         request-uuid      (:uuid swap-proposal)
+         best-routes       (:best swap-proposal)
+         error-response    (:error-response swap-proposal)]
+     (when (= request-uuid last-request-uuid)
+       {:db (update-in db
+                       [:wallet :ui :swap]
+                       assoc
+                       :swap-proposal          (first best-routes)
+                       :error-response         (when (empty? best-routes) error-response)
+                       :loading-swap-proposal? false)}))))
 
-(rf/reg-event-fx :wallet.swap/set-provider
+(rf/reg-event-fx :wallet/swap-proposal-error
+ (fn [{:keys [db]} [error-message]]
+   {:db (-> db
+            (update-in [:wallet :ui :swap] dissoc :route :swap-proposal)
+            (assoc-in [:wallet :ui :swap :loading-swap-proposal?] false)
+            (assoc-in [:wallet :ui :swap :error-response] error-message))
+    :fx [[:dispatch
+          [:toasts/upsert
+           {:id   :swap-proposal-error
+            :type :negative
+            :text error-message}]]]}))
+
+(rf/reg-event-fx :wallet/stop-get-swap-proposal
+ (fn []
+   {:json-rpc/call [{:method   "wallet_stopSuggestedRoutesV2AsyncCalcualtion"
+                     :params   []
+                     :on-error (fn [error]
+                                 (log/error "failed to stop fetching swap proposals"
+                                            {:event :wallet/stop-get-swap-proposal
+                                             :error error}))}]}))
+
+(rf/reg-event-fx :wallet/clean-swap-proposal
  (fn [{:keys [db]}]
-   {:db (assoc-in db [:wallet :ui :swap :providers] [constants/swap-default-provider])}))
+   {:db (update-in db
+                   [:wallet :ui :swap]
+                   dissoc
+                   :last-request-uuid
+                   :swap-proposal
+                   :error-response
+                   :loading-swap-proposal?)}))
 
-(rf/reg-event-fx :wallet.swap/recalculate-fees
- (fn [{:keys [db]} [loading-fees?]]
-   {:db (assoc-in db [:wallet :ui :swap :loading-fees?] loading-fees?)}))
+(rf/reg-event-fx :wallet/clean-swap
+ (fn [{:keys [db]}]
+   {:db (update-in db [:wallet :ui] dissoc :swap)}))