Merge pull request #2823 from nervosnetwork/develop

Deploy to testnet

Author: u2

app/jobs/revert_block_job.rb

@@ -162,16 +162,13 @@ def revert_dao_contract_related_operations(local_tip_block)
     dao_transactions_count = local_tip_block.ckb_transactions.where("tags @> array[?]::varchar[]", ["dao"]).count
     dao_contract = DaoContract.default_contract
 
-    withdraw_transactions_count, withdraw_total_deposit = revert_withdraw_from_dao(dao_events)
+    withdraw_total_deposit = revert_withdraw_from_dao(dao_events)
     claimed_compensation = revert_issue_interest(dao_events)
-    deposit_transactions_count, deposit_total_deposit = revert_deposit_to_dao(dao_events)
+    deposit_total_deposit = revert_deposit_to_dao(dao_events)
 
     dao_events.update_all(status: "reverted")
-    dao_contract.update!(deposit_transactions_count: dao_contract.deposit_transactions_count - deposit_transactions_count,
-                         withdraw_transactions_count: dao_contract.withdraw_transactions_count - withdraw_transactions_count,
-                         total_deposit: dao_contract.total_deposit + withdraw_total_deposit - deposit_total_deposit,
+    dao_contract.update!(total_deposit: dao_contract.total_deposit + withdraw_total_deposit - deposit_total_deposit,
                          claimed_compensation: dao_contract.claimed_compensation - claimed_compensation,
-                         ckb_transactions_count: dao_contract.ckb_transactions_count - dao_transactions_count,
                          depositors_count: DaoEvent.depositor.count)
   end
 
@@ -218,7 +215,7 @@ def revert_withdraw_from_dao(dao_events)
     upsert_data = address_attrs.values
     Address.upsert_all(upsert_data, unique_by: :id) if upsert_data.present?
 
-    [withdraw_from_dao_events.size, redundant_total_deposit]
+    redundant_total_deposit
   end
 
   def revert_deposit_to_dao(dao_events)
@@ -242,7 +239,7 @@ def revert_deposit_to_dao(dao_events)
     Address.upsert_all(upsert_data, unique_by: :id) if upsert_data.present?
     Address.where(id: address_ids, dao_deposit: 0).update_all(is_depositor: false)
 
-    [deposit_to_dao_events.size, redundant_total_deposit]
+    redundant_total_deposit
   end
 
   def revert_block_rewards(local_tip_block)

app/models/ckb_sync/new_node_data_processor.rb

@@ -185,12 +185,6 @@ def process_dao_events!(local_tip_block = @local_tip_block)
       process_withdraw_dao_events!(local_block, dao_contract)
       process_interest_dao_events!(local_block, dao_contract)
       dao_contract.update(depositors_count: DaoEvent.depositor.distinct.count(:address_id))
-
-      # update dao contract ckb_transactions_count
-      dao_contract.increment!(:ckb_transactions_count,
-                              local_block.ckb_transactions.where(
-                                "tags @> array[?]::varchar[]", ["dao"]
-                              ).count)
     end
 
     # Process DAO withdraw
@@ -263,8 +257,7 @@ def process_withdraw_dao_events!(local_block, dao_contract)
 
       # update dao contract info
       dao_contract.update!(
-        total_deposit: dao_contract.total_deposit - withdraw_amount,
-        withdraw_transactions_count: dao_contract.withdraw_transactions_count + withdraw_transaction_ids.size,
+        total_deposit: dao_contract.total_deposit - withdraw_amount
       )
       update_addresses_dao_info(addrs_withdraw_info)
     end
@@ -384,8 +377,7 @@ def process_deposit_dao_events!(local_block, dao_contract)
       end
       # update dao contract info
       dao_contract.update!(
-        total_deposit: dao_contract.total_deposit + deposit_amount,
-        deposit_transactions_count: dao_contract.deposit_transactions_count + deposit_transaction_ids.size,
+        total_deposit: dao_contract.total_deposit + deposit_amount
       )
 
       update_addresses_dao_info(addresses_deposit_info)

app/models/dao_contract.rb

@@ -1,5 +1,5 @@
 class DaoContract < ApplicationRecord
-  validates :total_deposit, :claimed_compensation, :deposit_transactions_count, :withdraw_transactions_count, :depositors_count, presence: true, numericality: { greater_than_or_equal_to: 0 }
+  validates :total_deposit, :claimed_compensation, :depositors_count, presence: true, numericality: { greater_than_or_equal_to: 0 }
   CONTRACT_NAME = "nervos_dao".freeze
   GENESIS_ISSUANCE = 336 * 10**8
   ANNUAL_PRIMARY_ISSUANCE_BASE = GENESIS_ISSUANCE / 8
@@ -121,15 +121,11 @@ def secondary_issuance(start_epoch)
 #
 # Table name: dao_contracts
 #
-#  id                          :bigint           not null, primary key
-#  total_deposit               :decimal(30, )    default(0)
-#  claimed_compensation        :decimal(30, )    default(0)
-#  deposit_transactions_count  :bigint           default(0)
-#  withdraw_transactions_count :bigint           default(0)
-#  depositors_count            :integer          default(0)
-#  total_depositors_count      :bigint           default(0)
-#  created_at                  :datetime         not null
-#  updated_at                  :datetime         not null
-#  unclaimed_compensation      :decimal(30, )
-#  ckb_transactions_count      :decimal(30, )    default(0)
+#  id                     :bigint           not null, primary key
+#  total_deposit          :decimal(30, )    default(0)
+#  claimed_compensation   :decimal(30, )    default(0)
+#  depositors_count       :integer          default(0)
+#  created_at             :datetime         not null
+#  updated_at             :datetime         not null
+#  unclaimed_compensation :decimal(30, )
 #

db/migrate/20250930015526_remove_total_depositors_count_from_dao.rb

@@ -0,0 +1,8 @@
+class RemoveTotalDepositorsCountFromDao < ActiveRecord::Migration[7.0]
+  def change
+    remove_columns :dao_contracts, :total_depositors_count, type: :bigint
+    remove_columns :dao_contracts, :deposit_transactions_count, type: :bigint
+    remove_columns :dao_contracts, :withdraw_transactions_count, type: :bigint
+    remove_columns :dao_contracts, :ckb_transactions_count, type: :bigint
+  end
+end

db/structure.sql

@@ -1215,14 +1215,10 @@ CREATE TABLE public.dao_contracts (
     id bigint NOT NULL,
     total_deposit numeric(30,0) DEFAULT 0.0,
     claimed_compensation numeric(30,0) DEFAULT 0.0,
-    deposit_transactions_count bigint DEFAULT 0,
-    withdraw_transactions_count bigint DEFAULT 0,
     depositors_count integer DEFAULT 0,
-    total_depositors_count bigint DEFAULT 0,
     created_at timestamp(6) without time zone NOT NULL,
     updated_at timestamp(6) without time zone NOT NULL,
-    unclaimed_compensation numeric(30,0),
-    ckb_transactions_count numeric(30,0) DEFAULT 0.0
+    unclaimed_compensation numeric(30,0)
 );
 
 
@@ -5940,6 +5936,7 @@ INSERT INTO "schema_migrations" (version) VALUES
 ('20250715035736'),
 ('20250715043211'),
 ('20250826022054'),
-('20250827065749');
+('20250827065749'),
+('20250930015526');
 
 

test/models/ckb_sync/dao_events_test.rb

@@ -64,10 +64,7 @@ class DaoEventsTest < ActiveSupport::TestCase
       create(:block, :with_block_hash, number: node_block.header.number - 1)
       VCR.use_cassette("blocks/#{DEFAULT_NODE_BLOCK_NUMBER}") do
         fake_dao_withdraw_transaction(node_block)
-
-        assert_difference -> { DaoContract.default_contract.withdraw_transactions_count }, 1 do
-          node_data_processor.process_block(node_block)
-        end
+        node_data_processor.process_block(node_block)
 
         deposit_to_dao_events = Block.find_by(number: node_block.header.number).dao_events.where(event_type: "withdraw_from_dao")
         assert_equal ["processed"], deposit_to_dao_events.pluck(:status).uniq
@@ -220,7 +217,6 @@ class DaoEventsTest < ActiveSupport::TestCase
 
       assert_equal ["dao"], tx.tags
       assert_equal ["dao"], tx1.tags
-      assert_equal 2, DaoContract.default_contract.ckb_transactions_count
     end
 
     test "should increase address dao_deposit when block is invalid and previous output is a dao cell" do
@@ -278,7 +274,7 @@ class DaoEventsTest < ActiveSupport::TestCase
       end
     end
 
-    test "should decrease dao contract withdraw_transactions_count when block is invalid and previous output is a dao cell" do
+    test "when block is invalid and previous output is a dao cell" do
       DaoCompensationCalculator.any_instance.stubs(:call).returns(1000)
       DaoContract.default_contract.update(total_deposit: 100000000000000, depositors_count: 1)
       node_block = fake_node_block("0x3307186493c5da8b91917924253a5ffd35231151649d0c7e2941aa8801815063")
@@ -296,10 +292,7 @@ class DaoEventsTest < ActiveSupport::TestCase
       local_block.update(block_hash: "0x419c632366c8eb9635acbb39ea085f7552ae62e1fdd480893375334a0f37d1bx")
 
       VCR.use_cassette("blocks/#{DEFAULT_NODE_BLOCK_NUMBER}", record: :new_episodes) do
-        assert_difference -> { DaoContract.default_contract.reload.withdraw_transactions_count }, -1 do
-          node_data_processor.call
-        end
-
+        node_data_processor.call
         dao_events = local_block.dao_events.where(event_type: "withdraw_from_dao")
         assert_equal ["reverted"], dao_events.pluck(:status).uniq
       end
@@ -426,10 +419,8 @@ class DaoEventsTest < ActiveSupport::TestCase
       init_total_deposit = (10**8) * 10000
       init_depositors_count = 3
       init_interest_granted = (10**8) * 100
-      init_deposit_transactions_count = 2
-      init_withdraw_transactions_count = 1
       dao_contract.update(total_deposit: init_total_deposit, depositors_count: init_depositors_count,
-                          claimed_compensation: init_interest_granted, deposit_transactions_count: init_deposit_transactions_count, withdraw_transactions_count: init_withdraw_transactions_count)
+                          claimed_compensation: init_interest_granted)
       create_list(:dao_event, 3, status: :processed, contract_id: 1, event_type: "deposit_to_dao")
       prepare_node_data(HAS_UNCLES_BLOCK_NUMBER)
       local_block = Block.find_by(number: HAS_UNCLES_BLOCK_NUMBER)
@@ -441,8 +432,6 @@ class DaoEventsTest < ActiveSupport::TestCase
         assert_equal init_total_deposit, dao_contract.total_deposit
         assert_equal init_depositors_count, dao_contract.depositors_count
         assert_equal init_interest_granted, dao_contract.claimed_compensation
-        assert_equal init_deposit_transactions_count, dao_contract.deposit_transactions_count
-        assert_equal init_withdraw_transactions_count, dao_contract.withdraw_transactions_count
       end
     end
 
@@ -525,10 +514,7 @@ class DaoEventsTest < ActiveSupport::TestCase
       local_block.update(block_hash: "0x419c632366c8eb9635acbb39ea085f7552ae62e1fdd480893375334a0f37d1bx")
 
       VCR.use_cassette("blocks/#{DEFAULT_NODE_BLOCK_NUMBER}", record: :new_episodes) do
-        assert_difference -> { dao_contract.reload.deposit_transactions_count }, -1 do
-          node_data_processor.call
-        end
-
+        node_data_processor.call
         deposit_to_dao_events = local_block.dao_events.where(event_type: "deposit_to_dao")
         assert_equal ["reverted"], deposit_to_dao_events.pluck(:status).uniq
       end
@@ -577,19 +563,14 @@ class DaoEventsTest < ActiveSupport::TestCase
       create(:block, :with_block_hash, number: node_block.header.number - 1)
       VCR.use_cassette("blocks/#{DEFAULT_NODE_BLOCK_NUMBER}") do
         fake_dao_deposit_transaction(node_block)
-
-        assert_difference -> { DaoContract.default_contract.deposit_transactions_count }, 1 do
-          node_data_processor.process_block(node_block)
-        end
-
+        node_data_processor.process_block(node_block)
         deposit_to_dao_events = Block.find_by(number: node_block.header.number).dao_events.where(event_type: "deposit_to_dao")
         assert_equal ["processed"], deposit_to_dao_events.pluck(:status).uniq
       end
     end
 
     test "#process_block should not update dao contract total depositors count when depositors is already has been recorded" do
-      DaoContract.default_contract.update(total_deposit: 100000000000000, depositors_count: 1,
-                                          total_depositors_count: 1)
+      DaoContract.default_contract.update(total_deposit: 100000000000000, depositors_count: 1)
       CkbSync::Api.any_instance.stubs(:calculate_dao_maximum_withdraw).returns("0x2faf0be8")
 
       node_block = fake_node_block("0x3307186493c5da8b91917924253a5ffd35231151649d0c7e2941aa8801815063")
@@ -614,10 +595,6 @@ class DaoEventsTest < ActiveSupport::TestCase
       output1.capacity = (10**8) * 1000
       tx1.outputs << output1
       tx1.outputs_data << CKB::Utils.bin_to_hex("\x00" * 8)
-
-      assert_no_changes -> { DaoContract.default_contract.total_depositors_count } do
-        node_data_processor.process_block(node_block)
-      end
     end
 
     test "#process_block should not update dao contract depositors count when depositors is already has been recorded" do
@@ -728,7 +705,6 @@ class DaoEventsTest < ActiveSupport::TestCase
       tx1 = block.ckb_transactions.where(is_cellbase: false).second
       assert_equal ["dao"], tx.tags
       assert_equal ["dao"], tx1.tags
-      assert_equal 2, DaoContract.default_contract.ckb_transactions_count
     end
 
     test "should update tx's tags when output have udt cells and nervos_dao_withdrawing cell" do
@@ -793,7 +769,6 @@ class DaoEventsTest < ActiveSupport::TestCase
 
       tx = block.ckb_transactions.where(is_cellbase: false).first
       assert_equal %w[dao udt], tx.tags
-      assert_equal 1, DaoContract.default_contract.ckb_transactions_count
     end
 
     private

test/models/ckb_sync/node_data_processor_test.rb

@@ -2306,10 +2306,9 @@ class NodeDataProcessorTest < ActiveSupport::TestCase
 
       assert_equal ["dao"], tx.tags
       assert_equal ["dao"], tx1.tags
-      assert_equal 2, DaoContract.default_contract.ckb_transactions_count
     end
 
-    test "should recalculate dao contract ckb_transactions_count when block is invalid and has dao txs" do
+    test "when block is invalid and has dao txs" do
       block1 = create(:block, :with_block_hash,
                       number: DEFAULT_NODE_BLOCK_NUMBER - 2)
       tx1 = create(:ckb_transaction, block: block1)
@@ -2401,16 +2400,6 @@ class NodeDataProcessorTest < ActiveSupport::TestCase
                                          transactions:, header:)
       block = node_data_processor.process_block(node_block)
       CkbSync::Api.any_instance.stubs(:get_tip_block_number).returns(block.number + 1)
-      DaoContract.default_contract.update(deposit_transactions_count: 4)
-
-      VCR.use_cassette("blocks/#{DEFAULT_NODE_BLOCK_NUMBER}",
-                       record: :new_episodes) do
-        assert_changes -> {
-                         DaoContract.default_contract.reload.ckb_transactions_count
-                       }, from: 2, to: 0 do
-          node_data_processor.call
-        end
-      end
     end
 
     test "should update tx's tags when output have udt cells" do
@@ -2565,7 +2554,6 @@ class NodeDataProcessorTest < ActiveSupport::TestCase
       tx = block.ckb_transactions.where(is_cellbase: false).first
 
       assert_equal %w[dao udt], tx.tags
-      assert_equal 1, DaoContract.default_contract.ckb_transactions_count
     end
 
     test "should update tx's tags when input have udt cells" do
@@ -3003,8 +2991,6 @@ class NodeDataProcessorTest < ActiveSupport::TestCase
 
       assert_equal %w[dao udt], tx.tags
       assert_equal %w[dao udt], tx1.tags
-
-      assert_equal 2, DaoContract.default_contract.ckb_transactions_count
     end
 
     test "#process_block should not update tx's tags when there aren't dao cells and udt cells" do
@@ -3372,7 +3358,6 @@ class NodeDataProcessorTest < ActiveSupport::TestCase
       Sidekiq::Testing.inline!
       block = node_data_processor.process_block(node_block)
       CkbSync::Api.any_instance.stubs(:get_tip_block_number).returns(block.number + 1)
-      DaoContract.default_contract.update!(deposit_transactions_count: 4)
       VCR.use_cassette("blocks/#{DEFAULT_NODE_BLOCK_NUMBER}",
                        record: :new_episodes) do
         node_data_processor.call

test/models/dao_contract_test.rb

@@ -8,12 +8,6 @@ class DaoContractTest < ActiveSupport::TestCase
     should validate_presence_of(:claimed_compensation)
     should validate_numericality_of(:claimed_compensation).
       is_greater_than_or_equal_to(0)
-    should validate_presence_of(:deposit_transactions_count)
-    should validate_numericality_of(:deposit_transactions_count).
-      is_greater_than_or_equal_to(0)
-    should validate_presence_of(:withdraw_transactions_count)
-    should validate_numericality_of(:withdraw_transactions_count).
-      is_greater_than_or_equal_to(0)
     should validate_presence_of(:depositors_count)
     should validate_numericality_of(:depositors_count).
       is_greater_than_or_equal_to(0)
@@ -22,8 +16,8 @@ class DaoContractTest < ActiveSupport::TestCase
   test "should have correct columns" do
     dao_contract = create(:dao_contract)
     expected_attributes = %w(
-      created_at deposit_transactions_count depositors_count id claimed_compensation
-      total_deposit total_depositors_count updated_at withdraw_transactions_count unclaimed_compensation ckb_transactions_count
+      created_at depositors_count id claimed_compensation
+      total_deposit updated_at unclaimed_compensation
     )
     assert_equal expected_attributes.sort, dao_contract.attributes.keys.sort
   end

test/test_helper.rb

@@ -394,7 +394,6 @@ def expected_ranking(address1, address2, address3)
 
 def fake_dao_deposit_transaction(dao_cell_count, address)
   block = create(:block, :with_block_hash)
-  DaoContract.default_contract.update(ckb_transactions_count: dao_cell_count)
   address.update(dao_transactions_count: dao_cell_count)
   dao_cell_count.times do |number|
     if number % 2 == 0