Merge pull request #2637 from nervosnetwork/testnet

Deploy to mainnet

Author: zmcNotafraid

app/controllers/api/v1/address_dao_transactions_controller.rb

@@ -12,8 +12,7 @@ def show
           recent.page(@page).per(@page_size)
         json =
           Rails.cache.realize(ckb_dao_transactions.cache_key, version: ckb_dao_transactions.cache_version) do
-            records_counter = RecordCounters::AddressDaoTransactions.new(address)
-            options = FastJsonapi::PaginationMetaGenerator.new(request:, records: ckb_dao_transactions, page: @page, page_size: @page_size, records_counter:).call
+            options = FastJsonapi::PaginationMetaGenerator.new(request:, records: ckb_dao_transactions, page: @page, page_size: @page_size).call
             CkbTransactionsSerializer.new(ckb_dao_transactions, options.merge(params: { previews: true })).serialized_json
           end
 

app/controllers/api/v1/address_udt_transactions_controller.rb

@@ -17,8 +17,7 @@ def show
           recent.page(@page).per(@page_size).fast_page
         json =
           Rails.cache.realize(ckb_udt_transactions.cache_key, version: ckb_udt_transactions.cache_version) do
-            records_counter = RecordCounters::AddressUdtTransactions.new(address, udt.id)
-            options = FastJsonapi::PaginationMetaGenerator.new(request:, records: ckb_udt_transactions, page: @page, page_size: @page_size, records_counter:).call
+            options = FastJsonapi::PaginationMetaGenerator.new(request:, records: ckb_udt_transactions, page: @page, page_size: @page_size).call
             CkbTransactionsSerializer.new(ckb_udt_transactions, options.merge(params: { previews: true })).serialized_json
           end
 

app/controllers/api/v1/block_transactions_controller.rb

@@ -21,14 +21,12 @@ def show
 
         if stale?(ckb_transactions)
           expires_in 10.seconds, public: true, must_revalidate: true, stale_while_revalidate: 5.seconds
-          records_counter = RecordCounters::BlockTransactions.new(ckb_transactions)
           ckb_transactions = ckb_transactions.page(@page).per(@page_size).fast_page
           options = FastJsonapi::PaginationMetaGenerator.new(
             request:,
             records: ckb_transactions,
             page: @page,
             page_size: @page_size,
-            records_counter:,
           ).call
           json = CkbTransactionsSerializer.new(ckb_transactions,
                                                options.merge(params: { previews: true })).serialized_json

app/controllers/api/v1/blocks_controller.rb

@@ -31,12 +31,12 @@ def index
           head :not_found and return unless order_by.in? %w[number reward timestamp ckb_transactions_count]
 
           blocks = blocks.order(order_by => asc_or_desc).order("number DESC").page(@page).per(@page_size)
+          total_count = TableRecordCount.find_by(table_name: "blocks")&.count
 
           json =
             Rails.cache.realize(blocks.cache_key, version: blocks.cache_version, race_condition_ttl: 3.seconds) do
-              records_counter = RecordCounters::Blocks.new
               options = FastJsonapi::PaginationMetaGenerator.new(request: request, records: blocks, page: @page,
-                                                                 page_size: @page_size, records_counter: records_counter).call
+                                                                 page_size: @page_size, total_count:).call
               BlockListSerializer.new(blocks, options).serialized_json
             end
         end

app/controllers/api/v1/ckb_transactions_controller.rb

@@ -41,17 +41,16 @@ def index
 
           ckb_transactions = ckb_transactions.order(order_by => asc_or_desc).
             page(@page).per(@page_size).fast_page
-
+          total_count = TableRecordCount.find_by(table_name: "ckb_transactions")&.count
           json =
             Rails.cache.realize(ckb_transactions.cache_key,
                                 version: ckb_transactions.cache_version, race_condition_ttl: 3.seconds) do
-              records_counter = RecordCounters::Transactions.new
               options = FastJsonapi::PaginationMetaGenerator.new(
                 request:,
                 records: ckb_transactions,
                 page: @page,
                 page_size: @page_size,
-                records_counter:,
+                total_count:,
               ).call
               CkbTransactionListSerializer.new(ckb_transactions,
                                                options).serialized_json
@@ -70,17 +69,18 @@ def query
 
         ckb_transactions =
           if @address
-            records_counter = @tx_ids =
+            @tx_ids =
               AccountBook.tx_committed.where(
                 address_id: @address.id,
               ).order(
                 "block_number desc, tx_index desc",
               ).select(
                 "ckb_transaction_id",
               ).page(@page).per(@page_size).fast_page
+            total_count = @tx_ids.total_count
             CkbTransaction.where(id: @tx_ids.map(&:ckb_transaction_id)).order(block_number: :desc, tx_index: :desc)
           else
-            records_counter = RecordCounters::Transactions.new
+            total_count = TableRecordCount.find_by(table_name: "ckb_transactions")&.count
             CkbTransaction.recent.normal.page(@page).per(@page_size).fast_page
           end
         ckb_transactions = ckb_transactions.select(:id, :tx_hash, :block_id, :tags,
@@ -93,7 +93,7 @@ def query
               records: ckb_transactions,
               page: @page,
               page_size: @page_size,
-              records_counter:,
+              total_count: total_count,
             ).call
             CkbTransactionsSerializer.new(ckb_transactions,
                                           options.merge(params: {

app/interactions/users/ckb_transactions.rb

@@ -19,7 +19,6 @@ def execute
 
       options = FastJsonapi::PaginationMetaGenerator.new(
         records: transactions,
-        records_counter: account_books,
         request:,
         page:,
         page_size:,
@@ -36,7 +35,7 @@ def filter_account_books
       address_ids = user.address_ids
       if address_hash.present?
         address = Address.find_address!(address_hash)
-        address_ids = Array[address.id]
+        address_ids = [address.id]
       end
 
       scope = AccountBook.joins(:ckb_transaction).where(

app/lib/fast_jsonapi/pagination_meta_generator.rb

@@ -3,13 +3,12 @@ class PaginationMetaGenerator
     DEFAULT_PAGE = 1
     DEFAULT_PER_PAGE = 20
 
-    def initialize(request:, records:, page:, page_size:, total_pages: nil, records_counter: nil, total_count: nil)
+    def initialize(request:, records:, page:, page_size:, total_pages: nil, total_count: nil)
       @url = request.base_url + request.path + query_string(request.query_parameters)
       @page = page.to_i
       @page_size = limit_page_size(records, page_size.to_i)
       @records = records
-      @records_counter = records_counter || records
-      @total_count = total_count || @records_counter.total_count.to_i
+      @total_count = total_count || records.total_count
       @total_pages = total_pages || calculated_total_pages
       @hash = { links: {}, meta: { total: @total_count, page_size: @page_size, total_pages: @total_pages } }
     end
@@ -24,7 +23,7 @@ def call
 
     private
 
-    attr_reader :page, :page_size, :records, :records_counter, :total_count
+    attr_reader :page, :page_size, :records, :total_count
     attr_accessor :url, :hash
 
     def current_page

app/models/block.rb

@@ -19,11 +19,6 @@ class Block < ApplicationRecord
 
   # the `ckb_transactions` is only available when the block is included in chain
   has_many :ckb_transactions
-  has_many :block_transactions
-  # the transactions included in the block no matter if the block is included in chain
-  has_many :contained_transactions, class_name: "CkbTransaction",
-                                    through: :block_transactions,
-                                    inverse_of: :included_blocks
   has_many :uncle_blocks
   has_many :cell_outputs
   has_many :cell_inputs