feat: add template related types

block_template, cellbase_template, transaction_template
and uncle_template

Author: shaojunda

lib/ckb/types/block_template.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module CKB
+  module Types
+    class BlockTemplate
+      attr_accessor :version, :difficulty, :current_time, :number, :epoch, :parent_hash, :cycles_limit,
+                    :bytes_limit, :uncles_count_limit, :uncles, :transactions, :proposals, :cellbase, :work_id, :dao
+
+      # @param version [String | Integer] integer or hex number
+      # @param difficulty [String | Integer] integer or hex number
+      # @param current_time [String | Integer] integer or hex number
+      # @param number [String | Integer] integer or hex number
+      # @param epoch [String | Integer] integer or hex number
+      # @param parent_hash [String] 0x...
+      # @param cycles_limit [String | Integer] integer or hex number
+      # @param bytes_limit [String | Integer] integer or hex number
+      # @param uncles_count_limit [String | Integer] integer or hex number
+      # @param uncles [CKB::Types::UncleTemplate[]]
+      # @param transactions [CKB::Types::TransactionTemplate[]]
+      # @param proposals [String[]] 0x...
+      # @param cellbase [CellbaseTemplate]
+      # @param work_id [String | Integer] integer or hex number
+      # @param dao [String] 0x...
+      def initialize(
+        version:,
+        difficulty:,
+        current_time:,
+        number:,
+        epoch:,
+        parent_hash:,
+        cycles_limit:,
+        bytes_limit:,
+        uncles_count_limit:,
+        uncles:,
+        transactions:,
+        proposals:,
+        cellbase:,
+        work_id:,
+        dao:
+      )
+        @version =  Utils.to_int(version)
+        @difficulty = Utils.to_int(difficulty)
+        @current_time = Utils.to_int(current_time)
+        @number = Utils.to_int(number)
+        @epoch = Utils.to_int(epoch)
+        @parent_hash = parent_hash
+        @cycles_limit = Utils.to_int(cycles_limit)
+        @bytes_limit = Utils.to_int(bytes_limit)
+        @uncles_count_limit = Utils.to_int(uncles_count_limit)
+        @uncles = uncles
+        @transactions = transactions
+        @proposals = proposals
+        @cellbase = cellbase
+        @work_id = Utils.to_int(work_id)
+        @dao = dao
+      end
+
+      def to_h
+        {
+          version: Utils.to_hex(version),
+          difficulty: Utils.to_hex(difficulty),
+          current_time: Utils.to_hex(current_time),
+          number: Utils.to_hex(number),
+          epoch: Utils.to_hex(epoch),
+          parent_hash: parent_hash,
+          cycles_limit: Utils.to_hex(cycles_limit),
+          bytes_limit: Utils.to_hex(bytes_limit),
+          uncles_count_limit: Utils.to_hex(uncles_count_limit),
+          uncles: uncles.map(&:to_h),
+          transactions: transactions.map(&:to_h),
+          proposals: proposals,
+          cellbase: cellbase.to_h,
+          work_id: work_id,
+          dao: dao
+        }
+      end
+
+      def self.from_h(hash)
+        return if hash.nil?
+
+        new(
+          version: hash[:version],
+          difficulty: hash[:difficulty],
+          current_time: hash[:current_time],
+          number: hash[:number],
+          epoch: hash[:epoch],
+          parent_hash: hash[:parent_hash],
+          cycles_limit: hash[:cycles_limit],
+          bytes_limit: hash[:bytes_limit],
+          uncles_count_limit: hash[:uncles_count_limit],
+          uncles: hash[:uncles],
+          transactions: hash[:transactions],
+          proposals: hash[:proposals],
+          cellbase: hash[:cellbase],
+          work_id: hash[:work_id],
+          dao: hash[:dao]
+        )
+      end
+    end
+  end
+end

lib/ckb/types/cellbase_template.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module CKB
+  module Types
+    class CellbaseTemplate
+      attr_accessor :hash, :cycles, :data
+
+      # @param hash [String] 0x..
+      # @param cycles [String | Integer] integer or hex number
+      # @param data [CKB::Type::Transaction]
+      def initialize(hash:, cycles:, data:)
+        @hash = hash
+        @cycles = Utils.to_int(cycles)
+        @data = data
+      end
+
+      def to_h
+        {
+          hash: hash,
+          cycles: Utils.to_hex(cycles),
+          data: data.to_h
+        }
+      end
+
+      def self.from_h(hash)
+        return if hash.nil?
+
+        new(
+          hash: hash[:hash],
+          cycles: hash[:cycles],
+          data: Transaction.from_h(hash[:data]),
+        )
+      end
+    end
+  end
+end
+

lib/ckb/types/transaction_template.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CKB
+  module Types
+    class TransactionTemplate
+      attr_accessor :hash, :required, :cycles, :depends, :data
+
+      # @param hash [String] 0x..
+      # @param required [Boolean]
+      # @param cycles [String | Integer] integer or hex number
+      # @param depends [String[] | Integer[]] integer[] or hex number[]
+      # @param data [CKB::Type::Transaction]
+      def initialize(hash:, required:, cycles:, depends:, data:)
+        @hash = hash
+        @required = required
+        @cycles = Utils.to_int(cycles)
+        @depends = depends.map { |depend| Utils.to_int(depend) }
+        @data = data
+      end
+
+      def to_h
+        {
+          hash: hash,
+          required: required,
+          cycles: Utils.to_hex(cycles),
+          depends: depends.map { |depend| Utils.to_hex(depend) },
+          data: data.to_h
+        }
+      end
+
+      def self.from_h(hash)
+        return if hash.nil?
+
+        new(
+          hash: hash[:hash],
+          required: hash[:required],
+          cycles: hash[:cycles],
+          depends: hash[:depends],
+          data: Transaction.from_h(hash[:data]),
+        )
+      end
+    end
+  end
+end
+

lib/ckb/types/types.rb

@@ -30,6 +30,10 @@
 require_relative "cell_dep"
 require_relative "cell_data"
 require_relative "cell_info"
+require_relative "uncle_template"
+require_relative "transaction_template"
+require_relative "cellbase_template"
+require_relative "block_template"
 
 module CKB
   module Types

lib/ckb/types/uncle_template.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module CKB
+  module Types
+    class UncleTemplate
+      attr_accessor :hash, :required, :proposals, :header
+
+      # @param hash [String] 0x..
+      # @param required [Boolean]
+      # @param proposals [String[]] 0x..
+      # @param header [CKB::Type::BlockHeader]
+      def initialize(hash:, required:, proposals:, header:)
+        @hash = hash
+        @required = required
+        @proposals = proposals
+        @header = header
+      end
+
+      def to_h
+        {
+          hash: hash,
+          required: required,
+          proposals: proposals,
+          header: header.to_h
+        }
+      end
+
+      def self.from_h(hash)
+        return if hash.nil?
+
+        new(
+          hash: hash[:hash],
+          required: hash[:required],
+          proposals: hash[:proposals],
+          header: BlockHeader.from_h(hash[:header])
+        )
+      end
+    end
+  end
+end
+