Merge pull request #2695 from nervosnetwork/testnet

Deploy to mainnet

Author: u2

app/interactions/addresses/live_cells.rb

@@ -63,7 +63,8 @@ def filter_by_tag(scope)
         scope.where(lock_script_id: filtered_ids)
       when "deployment"
         scope_ids = scope.pluck(:id)
-        matched_ids = Contract.where(deployed_cell_output_id: scope_ids).pluck(:deployed_cell_output_id)
+        deployed_ids = Contract.pluck(:deployed_cell_output_id)
+        matched_ids = scope_ids & deployed_ids
         scope.where(id: matched_ids)
       else
         CellOutput.none

app/jobs/revert_block_job.rb

@@ -22,13 +22,13 @@ 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!
       end
 
       benchmark :recalculate_udt_accounts, udt_type_hashes, local_tip_block
-      benchmark :update_address_balance_and_ckb_transactions_count, local_tip_block
       benchmark :revert_block_rewards, local_tip_block
       ForkedEvent.create!(block_number: local_tip_block.number, epoch_number: local_tip_block.epoch,
                           block_timestamp: local_tip_block.timestamp)
@@ -40,22 +40,76 @@ def perform(local_tip_block = nil)
   end
 
   def update_address_balance_and_ckb_transactions_count(local_tip_block)
-    snapshots = AddressBlockSnapshot.where.not(block_id: local_tip_block.id).where(address_id: local_tip_block.address_ids).order(block_number: :desc).distinct.group_by(&:address_id)
-    local_tip_block.contained_addresses.each do |address|
-      snapshot = snapshots.fetch(address.id, []).first
-      if snapshot.present?
-        attrs = snapshot.final_state
-        address.update!(attrs)
-      else
-        address.live_cells_count = address.cell_outputs.live.count
-        address.ckb_transactions_count = AccountBook.tx_committed.where(address_id: address.id).count
-        address.dao_transactions_count = DaoEvent.processed.where(address_id: address.id).distinct.count(:ckb_transaction_id)
-        address.cal_balance!
-        address.save!
-      end
+    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
 
-    AddressBlockSnapshot.where(block_id: local_tip_block.id).delete_all
+    # 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)

app/models/address.rb

@@ -51,28 +51,20 @@ def self.find_by_address_hash(address_hash, *_args, **_kargs)
   def self.find_or_create_by_address_hash(address_hash, block_timestamp = 0)
     parsed = CkbUtils.parse_address(address_hash)
     lock_hash = parsed.script.compute_hash
-    lock_script = LockScript.find_by(
-      code_hash: parsed.code_hash,
-      hash_type: parsed.hash_type,
-      args: parsed.args,
-    )
 
-    create_with(
-      address_hash: CkbUtils.generate_address(parsed.script),
-      block_timestamp:,
-      lock_script_id: lock_script&.id,
-    ).find_or_create_by lock_hash:
-  end
-
-  def self.find_or_create_by_lock(lock_script)
-    lock_hash = lock_script.compute_hash
-    address_hash = CkbUtils.generate_address(lock_script)
-    address = Address.find_or_initialize_by(lock_hash:)
-    # force use new version address
-    address.address_hash = address_hash
-    address.lock_script = LockScript
-    address.save!
-    address
+    key = "lock_script_hash_#{lock_hash}"
+    lock_script_id = Rails.cache.read(key) || LockScript.find_by(script_hash: lock_hash)&.id
+
+    address_id = Rails.cache.read("address_lock_hash_#{lock_hash}")
+    if address_id
+      return address_id
+    else
+      create_with(
+        address_hash: CkbUtils.generate_address(parsed.script),
+        block_timestamp:,
+        lock_script_id: lock_script_id,
+      ).find_or_create_by(lock_hash:)&.id
+    end
   end
 
   # @param lock_script [CKB::Types::Script]

app/models/cell_output.rb

@@ -79,8 +79,6 @@ class CellOutput < ApplicationRecord
 
   attribute :tx_hash, :ckb_hash
 
-  attr_accessor :raw_address
-
   scope :consumed_after, ->(block_timestamp) {
                            where("consumed_block_timestamp >= ?", block_timestamp)
                          }
@@ -110,8 +108,6 @@ class CellOutput < ApplicationRecord
   scope :by_scripts, ->(lock_script_ids, type_script_ids) { where("lock_script_id IN (?) OR type_script_id IN (?)", lock_script_ids, type_script_ids) }
   scope :established_status, -> { where(status: ["live", "dead"]) }
 
-  before_create :setup_address
-
   def data=(new_data)
     @data = new_data
     if new_data
@@ -134,13 +130,6 @@ def binary_data
     cell_datum&.data
   end
 
-  def setup_address
-    if raw_address
-      self.address = Address.find_or_create_by_address_hash(raw_address,
-                                                            block_timestamp)
-    end
-  end
-
   # @return [Boolean]
   def occupied?
     !free?