Merge pull request #2571 from nervosnetwork/testnet

Deploy to mainnet

Author: rabbitz

app/controllers/api/v2/fiber/graph_nodes_controller.rb

@@ -2,34 +2,38 @@ module Api
   module V2
     module Fiber
       class GraphNodesController < BaseController
+        before_action :find_node, only: %i[show graph_channels transactions]
+
         def index
-          @page = params.fetch(:page, 1)
-          @page_size = params.fetch(:page_size, FiberGraphNode.default_per_page)
-          @nodes =
-            if params[:q].present?
-              FiberGraphNode.with_deleted.where("node_name = :q or peer_id = :q or node_id = :q", q: params[:q]).page(@page).per(@page_size)
-            else
-              FiberGraphNode.with_deleted.page(@page).per(@page_size)
-            end
+          @nodes = GraphNodes::Index.run!({ key: params[:q], page: params[:page], page_size: params[:page_size] })
         end
 
-        def show
-          @node = FiberGraphNode.with_deleted.find_by(node_id: params[:node_id])
-          raise Api::V2::Exceptions::FiberGraphNodeNotFoundError unless @node
+        def show; end
 
-          @graph_channels = FiberGraphChannel.with_deleted.where(node1: params[:node_id]).or(
-            FiberGraphChannel.with_deleted.where(node2: params[:node_id]),
-          )
+        def graph_channels
+          @channels = GraphNodes::GraphChannels.run!(query_params)
+        end
 
-          if params[:status] == "closed"
-            @graph_channels = @graph_channels.with_deleted.where.not(closed_transaction_id: nil)
-          end
+        def transactions
+          @transactions = GraphNodes::Transactions.run!(query_params)
         end
 
         def addresses
           nodes = FiberGraphNode.all.select(:node_id, :addresses)
           render json: { data: nodes.map { { node_id: _1.node_id, addresses: _1.addresses, connections: _1.connected_node_ids } } }
         end
+
+        private
+
+        def find_node
+          @node = FiberGraphNode.with_deleted.find_by(node_id: params[:node_id])
+          raise Api::V2::Exceptions::FiberGraphNodeNotFoundError unless @node
+        end
+
+        def query_params
+          params.permit(:node_id, :sort, :page, :page_size, :type_hash, :min_token_amount, :max_token_amount,
+                        :address_hash, :status, :start_date, :end_date)
+        end
       end
     end
   end

app/interactions/addresses/explore.rb

@@ -12,7 +12,8 @@ def execute
     def find_address
       return Address.find_by(lock_hash: key) if QueryKeyUtils.valid_hex?(key)
       return find_by_address_hash(key) if QueryKeyUtils.valid_address?(key)
-      return find_by_bitcoin_address_hash(key) if BitcoinUtils.valid_address?(key)
+
+      find_by_bitcoin_address_hash(key) if BitcoinUtils.valid_address?(key)
     end
 
     def find_by_address_hash(key)

app/interactions/graph_nodes/graph_channels.rb

@@ -0,0 +1,92 @@
+module GraphNodes
+  class GraphChannels < ActiveInteraction::Base
+    string :node_id, default: nil
+    string :sort, default: "position_time.desc"
+    integer :page, default: 1
+    integer :page_size, default: FiberGraphChannel.default_per_page
+
+    string :type_hash, default: nil
+    decimal :min_token_amount, default: nil
+    decimal :max_token_amount, default: nil
+
+    string :address_hash, default: nil
+    string :status, default: nil
+
+    integer :start_date, default: nil
+    integer :end_date, default: nil
+
+    validates :status, inclusion: { in: %w[open closed], allow_nil: true }
+    validate :validate_date!
+
+    def execute
+      scope = FiberGraphChannel.with_deleted
+      scope = scope.where(node1: node_id).or(scope.where(node2: node_id))
+      return FiberGraphChannel.none if scope.empty?
+
+      scope = filter_by_address(scope)
+      scope = filter_by_status(scope)
+      scope = filter_by_date(scope)
+      scope = filter_by_type_hash(scope)
+
+      sort_column, sort_direction = channels_ordering
+      scope.order(sort_column => sort_direction).page(page).per(page_size).fast_page
+    end
+
+    private
+
+    def filter_by_address(scope)
+      return scope unless address_hash
+
+      address = Address.find_address!(address_hash)
+      scope.includes(:fiber_account_books).where(fiber_account_books: { address: })
+    end
+
+    def filter_by_status(scope)
+      case status
+      when "closed"
+        scope.where.not(closed_transaction_id: nil)
+      when "open"
+        scope.where(closed_transaction_id: nil)
+      else
+        scope
+      end
+    end
+
+    def filter_by_date(scope)
+      scope = scope.where(created_timestamp: start_date..) if start_date
+      scope = scope.where(created_timestamp: ..end_date) if end_date
+      scope
+    end
+
+    def filter_by_type_hash(scope)
+      return scope unless type_hash
+
+      if type_hash.eql?("0x0")
+        scope = scope.where(udt_id: nil)
+        scope = scope.where(capacity: min_token_amount..) if min_token_amount
+        scope = scope.where(capacity: ..max_token_amount) if max_token_amount
+      else
+        scope = scope.includes(:udt).where(udt: { type_hash: })
+        scope = scope.includes(:funding_cell).where(funding_cell: { udt_amount: min_token_amount.. }) if min_token_amount
+        scope = scope.includes(:funding_cell).where(funding_cell: { udt_amount: ..max_token_amount }) if max_token_amount
+      end
+
+      scope
+    end
+
+    def channels_ordering
+      sort_by_param, sort_order = sort.to_s.split(".", 2)
+      sort_by = { "position_time" => "created_timestamp" }.fetch(sort_by_param, "capacity")
+      sort_order = sort_order&.downcase
+      sort_order = "asc" unless %w[asc desc].include?(sort_order)
+
+      [sort_by, sort_order]
+    end
+
+    def validate_date!
+      if start_date.present? && end_date.present? && start_date > end_date
+        raise "invalid date"
+      end
+    end
+  end
+end

app/interactions/graph_nodes/index.rb

@@ -0,0 +1,13 @@
+module GraphNodes
+  class Index < ActiveInteraction::Base
+    string :key, default: nil
+    integer :page, default: 1
+    integer :page_size, default: FiberGraphNode.default_per_page
+
+    def execute
+      scope = FiberGraphNode.with_deleted
+      scope = scope.where("node_name = :key or peer_id = :key or node_id = :key", key:) if key
+      scope.page(page).per(page_size).fast_page
+    end
+  end
+end

app/interactions/graph_nodes/transactions.rb

@@ -0,0 +1,102 @@
+module GraphNodes
+  class Transactions < ActiveInteraction::Base
+    string :node_id, default: nil
+    string :sort, default: "block_timestamp.desc"
+    integer :page, default: 1
+    integer :page_size, default: FiberGraphChannel.default_per_page
+
+    string :type_hash, default: nil
+    decimal :min_token_amount, default: nil
+    decimal :max_token_amount, default: nil
+
+    string :address_hash, default: nil
+    string :status, default: nil
+
+    integer :start_date, default: nil
+    integer :end_date, default: nil
+
+    validates :status, inclusion: { in: %w[open closed], allow_nil: true }
+
+    def execute
+      channels = FiberGraphChannel.with_deleted
+      channels = channels.where(node1: node_id).or(channels.where(node2: node_id))
+      return FiberGraphChannel.none if channels.empty?
+
+      channels = filter_by_address(channels)
+      channels = filter_by_type_hash(channels)
+
+      wrap_result(channels)
+    end
+
+    private
+
+    def filter_by_address(channels)
+      return channels unless address_hash
+
+      address = Address.find_address!(address_hash)
+      channels.includes(:fiber_account_books).where(fiber_account_books: { address: })
+    end
+
+    def filter_by_type_hash(channels)
+      return channels unless type_hash
+
+      if type_hash.eql?("0x0")
+        channels = channels.where(udt_id: nil)
+        channels = channels.where(capacity: min_token_amount..) if min_token_amount
+        channels = channels.where(capacity: ..max_token_amount) if max_token_amount
+      else
+        channels = channels.includes(:udt).where(udt: { type_hash: })
+        channels = channels.includes(:funding_cell).where(funding_cell: { udt_amount: min_token_amount.. }) if min_token_amount
+        channels = channels.includes(:funding_cell).where(funding_cell: { udt_amount: ..max_token_amount }) if max_token_amount
+      end
+
+      channels
+    end
+
+    def wrap_result(channels)
+      transactions = channels.flat_map do |channel|
+        list = []
+        list << transaction_data(channel.open_transaction_info, channel, true)
+        if channel.closed_transaction
+          list << transaction_data(channel.closed_transaction_info, channel, false)
+        end
+        list
+      end
+
+      transactions = sort_transactions(transactions)
+      transactions = filter_by_status(transactions)
+      transactions = filter_by_block_timestamp(transactions)
+
+      Kaminari.paginate_array(transactions).page(page).per(page_size)
+    end
+
+    def transaction_data(tx_info, channel, is_open)
+      { is_open: is_open, is_udt: channel.udt.present? }.merge(tx_info)
+    end
+
+    def sort_transactions(transactions)
+      direction = sort == "block_timestamp.desc" ? -1 : 1
+      transactions.sort_by { |tx| tx[:block_timestamp] * direction }
+    end
+
+    def filter_by_block_timestamp(transactions)
+      return transactions unless start_date || end_date
+
+      transactions.select do |tx|
+        ts = tx[:block_timestamp].to_i
+        (start_date.nil? || ts >= start_date) && (end_date.nil? || ts <= end_date)
+      end
+    end
+
+    def filter_by_status(transactions)
+      case status
+      when "open"
+        transactions.select { |t| t[:is_open] }
+      when "closed"
+        transactions.reject { |t| t[:is_open] }
+      else
+        transactions
+      end
+    end
+  end
+end

app/models/fiber_account_book.rb

@@ -0,0 +1,20 @@
+class FiberAccountBook < ApplicationRecord
+  belongs_to :fiber_graph_channel, -> { with_deleted }
+  belongs_to :address
+  belongs_to :ckb_transaction
+end
+
+# == Schema Information
+#
+# Table name: fiber_account_books
+#
+#  id                     :bigint           not null, primary key
+#  fiber_graph_channel_id :bigint
+#  ckb_transaction_id     :bigint
+#  address_id             :bigint
+#
+# Indexes
+#
+#  index_fiber_account_books_on_address_id_and_ckb_transaction_id  (address_id,ckb_transaction_id) UNIQUE
+#  index_fiber_account_books_on_ckb_transaction_id                 (ckb_transaction_id)
+#

app/models/fiber_graph_channel.rb

@@ -6,30 +6,36 @@ class FiberGraphChannel < ApplicationRecord
   paginates_per DEFAULT_PAGINATES_PER
   max_paginates_per MAX_PAGINATES_PER
 
+  has_many :fiber_account_books
   belongs_to :udt, optional: true
   belongs_to :open_transaction, class_name: "CkbTransaction"
   belongs_to :closed_transaction, class_name: "CkbTransaction", optional: true
+  belongs_to :funding_cell, class_name: "CellOutput", foreign_key: :cell_output_id
   belongs_to :address
-  belongs_to :cell_output
 
   validates :open_transaction_id, presence: true
 
   scope :open_channels, -> { where(closed_transaction_id: nil) }
 
   def open_transaction_info
-    open_transaction.as_json(only: %i[tx_hash block_number block_timestamp]).merge(
-      {
-        capacity: funding_cell.capacity,
-        udt_info: funding_cell.udt_info,
-        address: funding_cell.address_hash,
-      },
-    )
+    {
+      tx_hash: open_transaction.tx_hash,
+      block_number: open_transaction.block_number,
+      block_timestamp: open_transaction.block_timestamp,
+      capacity: funding_cell.capacity,
+      udt_info: funding_cell.udt_info,
+      address: funding_cell.address_hash,
+    }
   end
 
   def closed_transaction_info
     return Hash.new unless closed_transaction
 
-    closed_transaction.as_json(only: %i[tx_hash block_number block_timestamp]).merge(
+    {
+      tx_hash: closed_transaction.tx_hash,
+      block_number: closed_transaction.block_number,
+      block_timestamp: open_transaction.block_timestamp,
+    }.merge(
       close_accounts: closed_transaction.outputs.map do |cell|
         {
           capacity: cell.capacity,
@@ -44,12 +50,6 @@ def udt_info
     udt&.as_json(only: %i[full_name symbol decimal icon_file])
   end
 
-  def funding_cell
-    open_transaction.outputs.includes(:lock_script).find_by(
-      lock_scripts: { code_hash: Settings.fiber_funding_code_hash },
-    )
-  end
-
   def deleted_at_timestamp
     return unless deleted_at
 
@@ -80,6 +80,8 @@ def deleted_at_timestamp
 #  deleted_at                      :datetime
 #  cell_output_id                  :bigint
 #  address_id                      :bigint
+#  update_info_of_node1            :jsonb
+#  update_info_of_node2            :jsonb
 #
 # Indexes
 #

app/models/fiber_graph_node.rb

@@ -31,8 +31,8 @@ def open_channels_count
   end
 
   def last_updated_timestamp
-    node1_timestamps = FiberGraphChannel.where(node1: node_id).pluck(:last_updated_timestamp_of_node1)
-    node2_timestamps = FiberGraphChannel.where(node2: node_id).pluck(:last_updated_timestamp_of_node2)
+    node1_timestamps = FiberGraphChannel.where(node1: node_id).filter_map { _1.update_info_of_node1["timestamp"]&.to_i }
+    node2_timestamps = FiberGraphChannel.where(node2: node_id).filter_map { _1.update_info_of_node2["timestamp"]&.to_i }
     closed_transaction_ids = FiberGraphChannel.where(node1: node_id).
       or(FiberGraphChannel.where(node2: node_id)).
       where.not(closed_transaction_id: nil).pluck(:closed_transaction_id)