From 4a3a1cfed6f597155fc3b75d22ef73cdda91d081 Mon Sep 17 00:00:00 2001
From: ginesdt <ginesdt@gmail.com>
Date: Fri, 9 Dec 2022 13:35:33 +0100
Subject: [PATCH 1/2] Implement backoff retry

---
 src/district/server/smart_contracts.cljs | 38 +++++++++++++++++++-----
 1 file changed, 30 insertions(+), 8 deletions(-)

diff --git a/src/district/server/smart_contracts.cljs b/src/district/server/smart_contracts.cljs
index ed4d226..ec10897 100644
--- a/src/district/server/smart_contracts.cljs
+++ b/src/district/server/smart_contracts.cljs
@@ -261,20 +261,42 @@
                              identity)]
     (transform-fn (remove-log-indexes sorted-logs))))
 
+(defn get-events-with-retry [contract-instance contract event from to ch-logs retry-count]
+  (web3-eth/get-past-events contract-instance
+                          event
+                          {:from-block from
+                           :to-block to}
+                          (fn [error events]
+                            (if (and error (< retry-count 10))
+                              (do
+                                (let [wait-time (int (* 500 (inc retry-count) (inc (rand))))]
+                                  (log/info "Error fetching events. Retrying" {:retry-count retry-count
+                                                                               :contract contract
+                                                                               :event event
+                                                                               :from from
+                                                                               :to to
+                                                                               :error error
+                                                                               :wait-time wait-time})
+                                  (js/setTimeout
+                                    (fn []
+                                      (get-events-with-retry contract-instance contract event from to ch-logs (inc retry-count)))
+                                    wait-time)))
+                              (let [logs (->> events
+                                              web3-helpers/js->cljkk
+                                              (map (partial enrich-event-log contract contract-instance)))]
+                                (async/put! ch-logs (if error [(with-meta {:err error} {:error? true})] logs)))))))
+
 (defn chunk->logs [transform-fn from-block skip-log-indexes events ignore-forward? [from to] ch-output]
   ">! to ch-output for chunk [from to]: final sorted, skipped and transformed logs as async/ch."
   (let [sort-and-skip-logs' (partial sort-and-skip-logs transform-fn from-block skip-log-indexes)
         ch-logs (async/chan 1)
         event->logs (fn [[k [contract event]] ch-logs-output]
                       (let [contract-instance (instance-from-arg contract {:ignore-forward? ignore-forward?})]
-                        (web3-eth/get-past-events contract-instance
-                                                  event
-                                                  {:from-block from
-                                                   :to-block to}
-                                                  (fn [error events]
-                                                    (let [logs (map (partial enrich-event-log contract contract-instance)
-                                                                    (web3-helpers/js->cljkk events))]
-                                                      (async/put! ch-logs-output (or logs [(with-meta {:err error} {:error? true})])))))))]
+                        (log/debug "Processing chunk of blocks" {:contract contract
+                                                                 :event event
+                                                                 :from from
+                                                                 :to to})
+                        (get-events-with-retry contract-instance contract event from to ch-logs-output 0)))]
     (go-loop [all-logs []
               [event & rest-events] events]
       (if event

From d3b5e30fdc071ada1fcb0111d40effad904459fe Mon Sep 17 00:00:00 2001
From: ginesdt <ginesdt@gmail.com>
Date: Fri, 9 Dec 2022 13:49:04 +0100
Subject: [PATCH 2/2] Add sequential vs parallel test

---
 lib_version.clj     |  2 +-
 test/tests/all.cljs | 12 ++++++++++--
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/lib_version.clj b/lib_version.clj
index 799e932..7029b8a 100644
--- a/lib_version.clj
+++ b/lib_version.clj
@@ -1,4 +1,4 @@
 (ns lib-version)
 
 (def lib 'district0x/district-server-smart-contracts) ; ends up as <group-id>/<artifact-id> in pom.xml
-(def version "1.4.2-SNAPSHOT")
+(def version "1.4.3-SNAPSHOT")
diff --git a/test/tests/all.cljs b/test/tests/all.cljs
index b7c6139..b053f3c 100644
--- a/test/tests/all.cljs
+++ b/test/tests/all.cljs
@@ -108,7 +108,8 @@
              (.unsubscribe event-emitter (fn []))
              (done)))))
 
-(deftest test-replay-past-events-in-order
+(defn test-replay-past-events-in-order
+  [chunks-parallelism]
   (async done
          (go
            (let [events {:my-contract/on-counter-incremented [:my-contract :onCounterIncremented]}
@@ -129,13 +130,20 @@
                                                                                            (->> (map (juxt :block-number :transaction-index :log-index) chunk-logs)
                                                                                                 (swap! on-chunk-test concat)))
                                                                                :on-finish (fn []
-                                                                                            (log/debug "Finished replaying past events"))}))
+                                                                                            (log/debug "Finished replaying past events"))
+                                                                               :chunks-parallelism chunks-parallelism}))
                  cleanup-tx (<! (smart-contracts/contract-send :my-contract :set-counter [1] {:gas 5000000}))]
              (is (= @captured-events @on-chunk-test [[(+ block-number 1) 0 1] [(+ block-number 2) 0 0] [(+ block-number 2) 0 1]])
                  "It should filter by from-block and from-tx-lidx")
 
              (done)))))
 
+(deftest test-replay-past-events-in-order-parallel
+  (test-replay-past-events-in-order 10))
+
+(deftest test-replay-past-events-in-order-sequential
+  (test-replay-past-events-in-order 1))
+
 (deftest test-contract-send-output-interface
   (async done
          (go