Merge pull request #2887 from nervosnetwork/testnet

Deploy to mainnet

Author: u2

app/jobs/revert_block_job.rb

@@ -22,7 +22,6 @@ def perform(local_tip_block = nil)
         end
       benchmark :recalculate_udt_transactions_count, local_tip_block
       benchmark :decrease_records_count, local_tip_block
-      benchmark :update_address_balance_and_ckb_transactions_count, local_tip_block
 
       ApplicationRecord.benchmark "invalid! block" do
         local_tip_block.invalid!
@@ -39,79 +38,6 @@ def perform(local_tip_block = nil)
     end
   end
 
-  def update_address_balance_and_ckb_transactions_count(local_tip_block)
-    select_fields = [
-      "address_id",
-      "COUNT(*) AS cells_count",
-      "SUM(capacity) AS total_capacity",
-      "SUM(CASE WHEN type_hash IS NOT NULL OR data_hash IS NOT NULL THEN capacity ELSE 0 END) AS balance_occupied",
-    ]
-    output_addrs =
-      local_tip_block.cell_outputs.live.select(select_fields.join(", ")).group(:address_id)
-    input_addrs =
-      CellOutput.where(consumed_block_timestamp: local_tip_block.timestamp).select(select_fields.join(", ")).group(:address_id)
-    out_hash = output_addrs.each_with_object({}) do |row, h|
-      h[row.address_id] = {
-        cells_count: row.cells_count.to_i,
-        total_capacity: row.total_capacity.to_i,
-        balance_occupied: row.balance_occupied.to_i,
-      }
-    end
-
-    in_hash = input_addrs.each_with_object({}) do |row, h|
-      h[row.address_id] = {
-        cells_count: row.cells_count.to_i,
-        total_capacity: row.total_capacity.to_i,
-        balance_occupied: row.balance_occupied.to_i,
-      }
-    end
-
-    # Merge keys
-    all_ids = in_hash.keys | out_hash.keys
-
-    # 计算差值
-    address_balance_diff = all_ids.each_with_object({}) do |addr_id, h|
-      input  = in_hash[addr_id]  || { cells_count: 0, total_capacity: 0, balance_occupied: 0 }
-      output = out_hash[addr_id] || { cells_count: 0, total_capacity: 0, balance_occupied: 0 }
-
-      h[addr_id] = {
-        cells_count: input[:cells_count] - output[:cells_count],
-        total_capacity: input[:total_capacity] - output[:total_capacity],
-        balance_occupied: input[:balance_occupied] - output[:balance_occupied],
-      }
-    end
-    # Preload dao transaction counts for all addresses in one query
-    dao_tx_counts = DaoEvent.processed.
-      where(block_id: local_tip_block.id, address_id: all_ids).
-      group(:address_id).
-      distinct.
-      count(:ckb_transaction_id)
-    tx_count_diffs = AccountBook.tx_committed.
-      where(block_number: local_tip_block.number, address_id: all_ids).
-      group(:address_id).
-      count
-
-    changes =
-      address_balance_diff.map do |address_id, changes|
-        tx_count_diff = tx_count_diffs[address_id] || 0
-        dao_tx_count_diff = dao_tx_counts[address_id] || 0
-        { address_id: address_id }.merge(changes).merge({ ckb_transactions_count: tx_count_diff, dao_transactions_count: dao_tx_count_diff })
-      end
-
-    changes.each do |change|
-      addr = Address.find_by_id(change[:address_id])
-      if addr
-        addr.update!(
-          live_cells_count: addr.live_cells_count + change[:cells_count],
-          ckb_transactions_count: addr.ckb_transactions_count - change[:ckb_transactions_count],
-          balance: addr.balance + change[:total_capacity],
-          balance_occupied: addr.balance_occupied + change[:balance_occupied],
-          dao_transactions_count: addr.dao_transactions_count - change[:dao_transactions_count]
-        )
-      end
-    end
-  end
-
   def recalculate_udt_transactions_count(local_tip_block)
     udt_ids = local_tip_block.ckb_transactions.map(&:contained_udt_ids).flatten
     udt_counts = udt_ids.each_with_object(Hash.new(0)) { |udt_id, counts| counts[udt_id] += 1 }
@@ -159,7 +85,6 @@ def revert_mining_info(local_tip_block)
 
   def revert_dao_contract_related_operations(local_tip_block)
     dao_events = DaoEvent.where(block: local_tip_block).processed
-    dao_transactions_count = local_tip_block.ckb_transactions.where("tags @> array[?]::varchar[]", ["dao"]).count
     dao_contract = DaoContract.default_contract
 
     withdraw_total_deposit = revert_withdraw_from_dao(dao_events)

app/models/address.rb

@@ -222,7 +222,6 @@ def unmade_dao_interests
 #  average_deposit_time      :bigint
 #  unclaimed_compensation    :decimal(30, )
 #  is_depositor              :boolean          default(FALSE)
-#  dao_transactions_count    :bigint           default(0)
 #  lock_script_id            :bigint
 #  balance_occupied          :decimal(30, )    default(0)
 #  last_updated_block_number :bigint

app/models/address_block_snapshot.rb

@@ -8,7 +8,7 @@ class NewNodeDataProcessor
     include Redis::Objects
 
     value :reorg_started_at, global: true
-    attr_accessor :local_tip_block, :pending_raw_block, :ckb_txs, :target_block, :target_block_number, :addrs_changes,
+    attr_accessor :local_tip_block, :pending_raw_block, :ckb_txs, :target_block, :target_block_number,
                   :outputs, :inputs, :outputs_data, :udt_address_ids, :contained_address_ids,
                   :contained_udt_ids, :cell_datas, :enable_cota, :token_transfer_ckb_tx_ids, :addr_tx_changes, :redis_keys, :tx_previous_outputs
 
@@ -75,11 +75,10 @@ def process_block(node_block, refresh_balance: true)
 
         benchmark :process_ckb_txs, node_block, ckb_txs, contained_address_ids,
                   contained_udt_ids, tags, udt_address_ids
-        @addrs_changes = Hash.new { |hash, key| hash[key] = {} }
         @addr_tx_changes = Hash.new { |h, k| h[k] = Hash.new(0) }
 
         input_capacities, output_capacities = benchmark :build_cells_and_locks!, local_block, node_block, ckb_txs, inputs, outputs,
-                                                        tags, udt_address_ids, contained_udt_ids, contained_address_ids, addrs_changes, token_transfer_ckb_tx_ids, cell_deps
+                                                        tags, udt_address_ids, contained_udt_ids, contained_address_ids, token_transfer_ckb_tx_ids, cell_deps
 
         # update explorer data
         benchmark :update_ckb_txs_rel_and_fee, ckb_txs, tags, input_capacities, output_capacities, udt_address_ids,
@@ -91,7 +90,6 @@ def process_block(node_block, refresh_balance: true)
         benchmark :update_or_create_udt_accounts!, local_block
         # maybe can be changed to asynchronous update
         benchmark :process_dao_events!, local_block
-        benchmark :update_addresses_info, addrs_changes, local_block, refresh_balance
       end
 
       async_update_udt_infos(local_block)
@@ -522,66 +520,6 @@ def update_mining_info(local_block)
       CkbUtils.update_current_block_mining_info(local_block)
     end
 
-    def update_addresses_info(addrs_change, local_block, refresh_balance)
-      return unless refresh_balance
-
-      addrs_change.to_a.each_slice(100) do |batch|
-
-        updates = batch.map do |key, value|
-          [key, { last_updated_block_number: local_block.number, 
-                balance: value[:balance_diff], 
-                balance_occupied: value[:balance_occupied_diff].presence || 0,
-                ckb_transactions_count: value[:ckb_txs].present? ? value[:ckb_txs].size : 0,
-                live_cells_count: value[:cells_diff],
-                dao_transactions_count: value[:dao_txs].present? ? value[:dao_txs].size : 0
-              }]
-        end.to_h
-  
-        case_clauses = { last_updated_block_number: [], balance: [], balance_occupied: [], ckb_transactions_count: [], live_cells_count: [], dao_transactions_count: [] }
-        ids = []
-  
-        updates.each do |id, attrs|
-          ids << id
-          attrs.each do |column, value|
-            if column == :last_updated_block_number
-              case_clauses[column] << "WHEN #{id} THEN '#{ActiveRecord::Base.connection.quote(value)}'"
-            else
-              case_clauses[column] << "WHEN #{id} THEN #{column} + #{value}"
-            end
-          end
-        end
-        
-        set_clauses = case_clauses.map do |column, clauses|
-          if clauses.any?
-            "  #{column} = CASE id\n    #{clauses.join("\n    ")}\n    ELSE #{column}\n  END"
-          else
-            nil
-          end
-        end.compact.join(",\n")
-        
-        id_list = ids.join(', ')
-        
-        sql = <<-SQL
-          UPDATE addresses
-          SET
-            #{set_clauses}
-          WHERE id IN (#{id_list})
-        SQL
-        
-        # puts sql
-  
-        ActiveRecord::Base.connection.execute(sql)
-  
-        updated_records = Address.where(id: ids).select(:lock_hash)
-        updated_records.each do |record|
-          $redis.pipelined do
-            Rails.cache.delete_multi(%W(#{record.class.name}/#{record.lock_hash}))
-          end
-        end
-      
-      end
-    end
-
     def update_block_info!(local_block)
       local_block.update!(
         total_transaction_fee: local_block.ckb_transactions.sum(:transaction_fee),
@@ -792,7 +730,7 @@ def update_ckb_txs_rel_and_fee(
 
     def build_cells_and_locks!(
       local_block, node_block, ckb_txs, inputs, outputs, tags, udt_address_ids,
-       contained_udt_ids, contained_addr_ids, addrs_changes, token_transfer_ckb_tx_ids, cell_deps
+       contained_udt_ids, contained_addr_ids, token_transfer_ckb_tx_ids, cell_deps
     )
       cell_outputs_attributes = []
       cell_inputs_attributes = []
@@ -815,7 +753,7 @@ def build_cells_and_locks!(
       build_addresses!(outputs, local_block)
 
       build_cell_outputs!(node_block, outputs, ckb_txs, local_block, cell_outputs_attributes, output_capacities, tags,
-                          udt_address_ids, contained_udt_ids, contained_addr_ids, addrs_changes, token_transfer_ckb_tx_ids)
+                          udt_address_ids, contained_udt_ids, contained_addr_ids, token_transfer_ckb_tx_ids)
       if cell_outputs_attributes.present?
         tx_hashes = cell_outputs_attributes.pluck(:tx_hash)
         binary_hashes = CkbUtils.hexes_to_bins_sql(tx_hashes)
@@ -872,7 +810,7 @@ def build_cells_and_locks!(
       prev_outputs = nil
       build_cell_inputs(inputs, ckb_txs, local_block.id, cell_inputs_attributes, prev_cell_outputs_attributes,
                         input_capacities, tags, udt_address_ids, contained_udt_ids, contained_addr_ids,
-                        prev_outputs, addrs_changes, token_transfer_ckb_tx_ids)
+                        prev_outputs, token_transfer_ckb_tx_ids)
 
       CellInput.import cell_inputs_attributes, validate: false, batch_size: 500
       if prev_cell_outputs_attributes.present?
@@ -980,7 +918,7 @@ def script_attributes(script, script_hash)
 
     def build_cell_inputs(
       inputs, ckb_txs, local_block_id, cell_inputs_attributes, prev_cell_outputs_attributes,
-input_capacities, tags, udt_address_ids, contained_udt_ids, contained_addr_ids, prev_outputs, addrs_changes, token_transfer_ckb_tx_ids
+input_capacities, tags, udt_address_ids, contained_udt_ids, contained_addr_ids, prev_outputs, token_transfer_ckb_tx_ids
     )
       conditions = []
 
@@ -1020,7 +958,6 @@ def build_cell_inputs(
           # attributes[2] is previous_cell_output capacity
           # attributes[3] is previous_cell_output type_hash
           # attributes[4] is previous_cell address_id
-          # attributes[5] is previous_cell data
           attributes = cell_input_attributes(item, ckb_txs[tx_index]["id"],
                                              local_block_id, prev_outputs, index)
           cell_inputs_attributes << attributes[:cell_input]
@@ -1029,28 +966,13 @@ def build_cell_inputs(
             address_id = attributes[:address_id]
             capacity = attributes[:capacity]
             type_hash = attributes[:type_hash]
-            data = attributes[:data]
-            change_rec = addrs_changes[address_id]
-
             addr_tx_changes[tx_index][address_id] -= capacity
-            change_rec[:balance_diff] ||= 0
-            change_rec[:balance_diff]  -= capacity
-            change_rec[:balance_occupied_diff] ||= 0
-            change_rec[:balance_occupied_diff] -= capacity if occupied?(
-              type_hash, data
-            )
-            change_rec[:cells_diff] ||= 0
-            change_rec[:cells_diff] -= 1
-            change_rec[:ckb_txs] ||= Set.new
-            change_rec[:ckb_txs] << ckb_txs[tx_index]["tx_hash"]
 
             prev_cell_outputs_attributes << previous_output
             contained_addr_ids[tx_index] << address_id
             cell_type = previous_output[:cell_type].to_s
             if cell_type.in?(%w(nervos_dao_withdrawing))
               tags[tx_index] << "dao"
-              change_rec[:dao_txs] ||= Set.new
-              change_rec[:dao_txs] << ckb_txs[tx_index]["tx_hash"]
             elsif cell_type.in?(%w(m_nft_token nrc_721_token spore_cell did_cell))
               token_transfer_ckb_tx_ids << ckb_txs[tx_index]["id"]
             end
@@ -1098,7 +1020,7 @@ def build_cell_inputs(
 
     def build_cell_outputs!(
       node_block, outputs, ckb_txs, local_block, cell_outputs_attributes, output_capacities,
-tags, udt_address_ids, contained_udt_ids, contained_addr_ids, addrs_changes, token_transfer_ckb_tx_ids
+tags, udt_address_ids, contained_udt_ids, contained_addr_ids, token_transfer_ckb_tx_ids
     )
       outputs.each do |tx_index, items|
         cell_index = 0
@@ -1121,24 +1043,9 @@ def build_cell_outputs!(
               @redis_keys << key
             end
           end
-          cell_data = node_block.transactions[tx_index].outputs_data[cell_index]
-          change_rec = addrs_changes[address_id]
+          
           addr_tx_changes[tx_index][address_id] += item.capacity
-
-          change_rec[:balance_diff] ||= 0
-          change_rec[:balance_diff] += item.capacity
-
-          change_rec[:balance_occupied_diff] ||= 0
           type_script_hash = item.type&.compute_hash
-          change_rec[:balance_occupied_diff] += item.capacity if occupied?(
-            type_script_hash, cell_data
-          )
-
-          change_rec[:cells_diff] ||= 0
-          change_rec[:cells_diff] += 1
-
-          change_rec[:ckb_txs] ||= Set.new
-          change_rec[:ckb_txs] << ckb_txs[tx_index]["tx_hash"]
 
           contained_addr_ids[tx_index] << address_id
           attr = cell_output_attributes(item, address_id, ckb_txs[tx_index], local_block, cell_index,
@@ -1147,8 +1054,6 @@ def build_cell_outputs!(
 
           if attr[:cell_type].in?(%w(nervos_dao_deposit nervos_dao_withdrawing))
             tags[tx_index] << "dao"
-            change_rec[:dao_txs] ||= Set.new
-            change_rec[:dao_txs] << ckb_txs[tx_index]["tx_hash"]
           end
 
           if attr[:cell_type] == "udt"
@@ -1191,10 +1096,6 @@ def build_cell_outputs!(
       end
     end
 
-    def occupied?(type_hash, cell_data)
-      (cell_data.present? && cell_data != "0x") || type_hash.present?
-    end
-
     def cell_output_attributes(output, address_id, ckb_transaction, local_block, cell_index, output_data)
       lock_script_hash = output.lock.compute_hash
       key = "lock_script_hash_#{lock_script_hash}"
@@ -1306,7 +1207,6 @@ def cell_input_attributes(input, ckb_transaction_id, local_block_id,
           capacity: previous_output.capacity,
           type_hash: previous_output.type_hash,
           address_id: previous_output.address_id,
-          # data: previous_output.data
         }
       end
     end

app/models/ckb_sync/new_node_data_processor.rb

@@ -15,7 +15,7 @@ def perform(number)
     @btc_time_cell_ids = [] # btc time cells
 
     ApplicationRecord.transaction do
-      block.ckb_transactions.each do |transaction|
+      block.ckb_transactions.includes(input_cells: [:lock_script], cell_outputs: [:lock_script]).each do |transaction|
         inputs = transaction.input_cells
         outputs = transaction.cell_outputs
         (inputs + outputs).each { collect_rgb_ids(_1) }
@@ -32,7 +32,7 @@ def perform(number)
         ImportBtcTimeCellsJob.perform_now(_1)
       end
       # update bitcoin annotation
-      build_bitcoin_annotations!
+      build_bitcoin_annotations! unless @txids.empty?
     end
   end
 
@@ -91,7 +91,7 @@ def cache_raw_transactions!
   def build_bitcoin_annotations!
     annotations = []
 
-    @block.ckb_transactions.each do |transaction|
+    @block.ckb_transactions.where(id: @txids).each do |transaction|
       leap_direction, transfer_step = annotation_workflow_attributes(transaction)
       tags = annotation_tags(transaction)