hyperledger-fabric-sdk 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8868d76ed70adc4cedf983ad30718b1964bdd4a4a06291bc336d7381bc152a74
-  data.tar.gz: 97809db15dee6a3f8ac534a63eb3933895e8f0fa0ebd255b10569124e5ff06c4
+  metadata.gz: 526fd39f6b4ffb1466bd6cab26b3e36ff210c246d43cca39d22f403871ed8983
+  data.tar.gz: '068980d43804bb71cbcf30817bdaa39a711384dbd4b708a4e9fcd3dae027c17c'
 SHA512:
-  metadata.gz: e4c1c49bdc093de69d552136954eacf30f0e92128222f5e878d760e71dd94ac08720ad832e8172014fb2363ce507963fe1099f1c7589878875c412704063de8f
-  data.tar.gz: e91abaeeee3053694b18362ab2fff01132267782ae6fdc0e01ed8bcc04540ff565fa70ae6bd5e4931068664f8ae51230008792e3a9cf1592c23ba5284bead9e0
+  metadata.gz: a87997e6303f440171c13a291a23cc1c5bf4c67e56aad7f5665f8ca1c39f5178684510104de55b2d7c7e4a78f4eb271d95de3f128677af27ee86efe501f57a20
+  data.tar.gz: e31ddad32d3a636dd10d2b02e21dfb517f66f417ee12796d6ea4751fb6fc61d69ae23407cce3e65a3fe0934af8209ebd9c92498aa78ae0f61a188196aab68875

data/lib/fabric/block_decoder.rb

@@ -0,0 +1,299 @@
+module Fabric
+  class BlockDecoder
+    def self.decode_block(proposal_block)
+      {
+        header: decode_block_header(proposal_block),
+        data: decode_block_data(proposal_block.data),
+        metadata: decode_block_metadata(proposal_block.metadata)
+      }
+    end
+
+    private
+
+    def self.decode_block_metadata(proto_block_metadata)
+      return {} unless proto_block_metadata.metadata
+
+      {
+        metadata: [
+          decode_metadata_signatures(proto_block_metadata.metadata[0]),
+          decode_last_config_sequence_number(proto_block_metadata.metadata[1]),
+          decode_transaction_filter(proto_block_metadata.metadata[2])
+        ]
+      }
+    end
+
+    def self.decode_transaction_filter(metadata_data)
+      return unless metadata_data
+
+      metadata_data.bytes
+    end
+
+    def self.decode_last_config_sequence_number(metadata_data)
+      return { value: {} } unless metadata_data
+
+      proto_metadata = Common::Metadata.decode(metadata_data)
+      proto_last_config = Common::LastConfig.decode(proto_metadata.value)
+
+      {
+        value: {
+          index: proto_last_config.index
+        },
+        signatures: decode_metadata_value_signatures(proto_metadata.signatures)
+      }
+    end
+
+    def self.decode_metadata_signatures(metadata_data)
+      proto_metadata = Common::Metadata.decode(metadata_data)
+
+      {
+        value: proto_metadata.value,
+        signatures: decode_metadata_value_signatures(proto_metadata.signatures)
+      }
+    end
+
+    def decode_metadata_value_signatures(proto_meta_signatures)
+      Array.wrap(proto_meta_signatures).map do |meta_signature_data|
+        proto_metadata_signature = Common::MetadataSignature.decode(meta_signature_data)
+
+        {
+          signature_header: decode_signature_header(proto_metadata_signature.signature_header),
+          signature: Fabric.crypto_suite.encode_hex(proto_metadata_signature.signature)
+        }
+      end
+    end
+
+    def self.decode_metadata_value_signatures(proto_meta_signatures); end
+
+    def self.decode_block_header(block_data)
+      {
+        number: block_data.header.number,
+        previous_hash: Fabric.crypto_suite.encode_hex(block_data.header.previous_hash),
+        data_hash: Fabric.crypto_suite.encode_hex(block_data.header.data_hash)
+      }
+    end
+
+    def self.decode_block_data(proto_block_data)
+      data = { data: [] }
+
+      proto_block_data.data.each do |envelope_data|
+        proto_envelope = Common::Envelope.decode envelope_data
+
+        data[:data].push decode_block_data_envelope(proto_envelope)
+      end
+
+      data
+    end
+
+    def self.decode_block_data_envelope(proto_envelope)
+      envelope = { payload: {} }
+      envelope[:signature] = Fabric.crypto_suite.encode_hex proto_envelope.signature
+      proto_payload = Common::Payload.decode(proto_envelope.payload)
+      envelope[:payload][:header] = decode_payload_header proto_payload.header
+      envelope[:payload][:data] =
+        decode_payload_based_on_type proto_payload.data,
+                                     envelope[:payload][:header][:channel_header][:type]
+
+      envelope
+    end
+
+    def self.decode_payload_header(proto_header)
+      header = {}
+      header[:channel_header] = decode_channel_header proto_header.channel_header
+      header[:signature_header] = decode_signature_header proto_header.signature_header
+
+      header
+    end
+
+    def self.decode_channel_header(channel_header_data)
+      channel_header = {}
+
+      proto_channel_header = Common::ChannelHeader.decode channel_header_data
+      channel_header[:type] = proto_channel_header.type
+      channel_header[:version] = proto_channel_header.version
+      channel_header[:timestamp] = Helper.timestamp_to_time proto_channel_header.timestamp
+      channel_header[:channel_id] = proto_channel_header.channel_id
+      channel_header[:tx_id] = proto_channel_header.tx_id
+      channel_header[:epoch] = proto_channel_header.epoch
+      channel_header[:extension] = decode_payload_header_extension proto_channel_header.extension
+
+      channel_header
+    end
+
+    def self.decode_payload_header_extension(extension_data)
+      return unless extension_data
+
+      Protos::ChaincodeHeaderExtension.decode(extension_data).to_hash
+    end
+
+    def self.decode_signature_header(signature_header_data)
+      signature_header = {}
+      proto_signature_header = Common::SignatureHeader.decode signature_header_data
+      signature_header[:creator] = decode_identity proto_signature_header.creator
+      signature_header[:nonce] = Fabric.crypto_suite.encode_hex proto_signature_header.nonce
+
+      signature_header
+    end
+
+    def self.decode_identity(creator_data)
+      identity = {}
+
+      proto_identity = Msp::SerializedIdentity.decode creator_data
+      identity[:mspid] = proto_identity.mspid
+      identity[:id_bytes] = proto_identity.id_bytes
+
+      identity
+    end
+
+    def self.decode_payload_based_on_type(proto_data, type)
+      case type
+      when Common::HeaderType::CONFIG then {}
+      when Common::HeaderType::CONFIG_UPDATE then {}
+      when Common::HeaderType::ENDORSER_TRANSACTION then decode_endorser_transaction proto_data
+      else {}
+      end
+    end
+
+    def self.decode_endorser_transaction(transaction_data)
+      proto_transaction = Protos::Transaction.decode transaction_data
+
+      {
+        actions: proto_transaction.actions.map do |proto_action|
+                   {
+                     header: decode_signature_header(proto_action.header),
+                     payload: decode_chaincode_action_payload(proto_action.payload)
+                   }
+                 end
+      }
+    end
+
+    def self.decode_chaincode_action_payload(payload_data)
+      proto_payload = Protos::ChaincodeActionPayload.decode payload_data
+
+      {
+        chaincode_proposal_payload:
+          decode_chaincode_proposal_payload(proto_payload.chaincode_proposal_payload),
+        action:
+          decode_chaincode_endorsed_action(proto_payload.action)
+      }
+    end
+
+    def self.decode_chaincode_proposal_payload(payload_data)
+      proto_chaincode_proposal_payload = Protos::ChaincodeProposalPayload.decode payload_data
+
+      {
+        input: decode_chaincode_proposal_payload_input(proto_chaincode_proposal_payload.input)
+      }
+    end
+
+    def self.decode_chaincode_proposal_payload_input(input_data)
+      Protos::ChaincodeInvocationSpec.decode(input_data).to_hash
+    end
+
+    def self.decode_chaincode_input(input_data)
+      proto_chaincode_input = Protos::ChaincodeInput.decode input_data
+
+      proto_chaincode_input.to_hash
+    end
+
+    def self.decode_chaincode_endorsed_action(proto_action)
+      {
+        proposal_response_payload:
+          decode_proposal_response_payload(proto_action.proposal_response_payload),
+        endorsements:
+          proto_action.endorsements.map do |proto_endorsement|
+            decode_endorsement proto_endorsement
+          end
+      }
+    end
+
+    def self.decode_endorsement(proto_endorsement)
+      {
+        endorser: decode_identity(proto_endorsement.endorser),
+        signature: Fabric.crypto_suite.encode_hex(proto_endorsement.signature)
+      }
+    end
+
+    def self.decode_proposal_response_payload(proposal_response_payload_bytes)
+      proposal_response_payload = {}
+      proto_proposal_response_payload =
+        Protos::ProposalResponsePayload.decode proposal_response_payload_bytes
+      proposal_response_payload[:proposal_hash] =
+        Fabric.crypto_suite.encode_hex proto_proposal_response_payload.proposal_hash
+      proposal_response_payload[:extension] =
+        decode_chaincode_action proto_proposal_response_payload.extension
+
+      proposal_response_payload
+    end
+
+    def self.decode_chaincode_action(action_data)
+      proto_chaincode_action = Protos::ChaincodeAction.decode action_data
+
+      {
+        results: decode_read_write_sets(proto_chaincode_action.results),
+        events: decode_chaincode_events(proto_chaincode_action.events),
+        response: decode_response(proto_chaincode_action.response),
+        chaincode_id: decode_chaincode_id(proto_chaincode_action.chaincode_id)
+      }
+    end
+
+    def self.decode_read_write_sets(rw_sets_data)
+      proto_tx_read_write_set = Rwset::TxReadWriteSet.decode rw_sets_data
+      tx_read_write_set = { data_model: proto_tx_read_write_set.data_model }
+      ns_rwset = proto_tx_read_write_set.ns_rwset
+
+      tx_read_write_set[:ns_rwset] =
+        if proto_tx_read_write_set.data_model == :KV
+          decode_ns_rwset ns_rwset
+        else
+          ns_rwset
+        end
+
+      tx_read_write_set
+    end
+
+    def self.decode_ns_rwset(ns_rwset)
+      ns_rwset.map do |proto_ns_rwset|
+        {
+          namespace: proto_ns_rwset.namespace,
+          rwset: decode_kv_rw_set(proto_ns_rwset.rwset),
+          collection_hashed_rwset:
+            decode_collection_hashed_rw_set(proto_ns_rwset.collection_hashed_rwset)
+        }
+      end
+    end
+
+    def self.decode_kv_rw_set(rwset_data)
+      Kvrwset::KVRWSet.decode(rwset_data).to_hash
+    end
+
+    def self.decode_collection_hashed_rw_set(proto_collection_hashed_rwset)
+      proto_collection_hashed_rwset.map do |proto_hashed_rwset|
+        {
+          collection_name: proto_hashed_rwset.collection_name,
+          decode_hashed_rwset: decode_hashed_rwset(proto_hashed_rwset.hashed_rwset_data),
+          pvt_rwset_hash: proto_hashed_rwset.pvt_rwset_hash
+        }
+      end
+    end
+
+    def self.decode_hashed_rwset(hashed_rwset_data)
+      Rwset::HashedRWSet.decode(hashed_rwset_data).to_hash
+    end
+
+    def self.decode_chaincode_events(event_data)
+      Protos::ChaincodeEvent.decode(event_data).to_hash
+    end
+
+    def self.decode_response(proposal_response)
+      return unless proposal_response
+
+      proposal_response.to_hash
+    end
+
+    def self.decode_chaincode_id(chaincode_id)
+      return unless chaincode_id
+
+      chaincode_id.to_hash
+    end
+  end
+end

data/lib/fabric/chaincode_response.rb

@@ -0,0 +1,47 @@
+module Fabric
+  class ChaincodeResponse
+    attr_reader :proposal, :proposal_responses, :responses
+
+    def initialize(attrs)
+      @proposal = attrs[:proposal]
+      @proposal_responses = attrs[:proposal_responses].compact
+      @responses = proposal_responses.map(&:response)
+    end
+
+    def success?
+      success_responses.any?
+    end
+
+    def success_responses
+      @success_responses ||= responses.select { |response| response.status == 200 }
+    end
+
+    def failure_response
+      @failure_response ||= responses.find { |response| response.status == 500 }
+    end
+
+    def tx_id
+      proposal.tx_id
+    end
+
+    def tx_timestamp
+      proposal.tx_timestamp
+    end
+
+    def tx_unix_timestamp
+      (tx_timestamp.seconds * 1000 + tx_timestamp.nanos / 10**6).to_i
+    end
+
+    def payload
+      success_responses.first&.payload
+    end
+
+    def validate!
+      return if success?
+
+      raise NetworkOfflineError if proposal_responses.empty?
+
+      raise ErrorFactory.create failure_response.message
+    end
+  end
+end

data/lib/fabric/channel.rb

@@ -1,54 +1,75 @@
-require 'peer/transaction_pb'
-
 module Fabric
   class Channel
-    attr_reader :identity_context, :name, :peers, :orderers
+    attr_reader :identity, :crypto_suite, :channel_id,
+                :orderers, :peers, :logger
+
+    def initialize(opts = {})
+      options = Fabric.options.merge opts
 
-    def initialize(args)
-      @identity_context = args[:identity_context]
-      @name = args[:name]
-      @peers = args[:peers] || []
-      @orderers = args[:orderers] || []
+      @channel_id = options[:channel_id]
+      @logger = Logger.new options[:logger], options[:logger_filters]
+      @identity = options[:identity]
+      @crypto_suite = options[:crypto_suite]
     end
 
-    def query_by_chaincode(request)
-      request[:targets] ||= peers
-      request[:transaction] = TransactionID.new identity_context
+    def register_peer(url, opts = {})
+      @peers ||= []
 
-      PeerEndorser.send_transaction_proposal request, name, identity_context
+      @peers << Peer.new(url: url, opts: opts, logger: logger)
     end
 
-    def send_transaction(request, &block)
-      header = Common::Header.decode request[:proposal].header
-      chaincode_action_payload = build_chaincode_action request
+    def register_orderer(url, opts = {})
+      @orderers ||= []
 
-      transaction_action = Protos::TransactionAction.new header: header.signature_header,
-                                                         payload: chaincode_action_payload.to_proto
-      transaction = Protos::Transaction.new actions: [transaction_action]
+      @orderers << Orderer.new(url: url, opts: opts, logger: logger)
+    end
 
-      payload = Common::Payload.new header: header,
-                                    data: transaction.to_proto
+    def query(request = {})
+      request[:channel_id] = channel_id
 
-      envelope = Common::Envelope.new signature: identity_context.identity.sign(payload.to_proto),
-                                      payload: payload.to_proto
+      logging __method__, request
+
+      proposal = Proposal.new crypto_suite, identity, request
+      proposal_responses = peers.map { |peer| peer.send_process_proposal(proposal.signed_proposal) }
 
-      orderers.first.send_broadcast envelope, &block
+      chaincode_response = ChaincodeResponse.new proposal: proposal,
+                                                 proposal_responses: proposal_responses
+
+      chaincode_response.validate!
+
+      chaincode_response
+    end
+
+    def invoke(chaincode_response)
+      transaction = Transaction.new crypto_suite,
+                                    identity,
+                                    proposal: chaincode_response.proposal,
+                                    responses: chaincode_response.proposal_responses
+
+      send_transaction transaction
+
+      chaincode_response
+    end
+
+    def create_transaction_info
+      TransactionInfo.new crypto_suite, identity
     end
 
     private
 
-      def build_chaincode_action(request)
-        responses = request[:responses].select { |response| response.response.status == 200 }
-        endorsements = responses.map { |response| response.endorsement }
-        chaincode_endorser_action =
-          Protos::ChaincodeEndorsedAction.new proposal_response_payload: responses.first.payload,
-                                              endorsements: endorsements
+    def send_transaction(transaction)
+      payload = Common::Payload.new header: transaction.header,
+                                    data: transaction.transaction.to_proto
 
-        payload = Protos::ChaincodeProposalPayload.decode request[:proposal].payload
-        payload_no_trans = Protos::ChaincodeProposalPayload.new input: payload.input
+      envelope = Common::Envelope.new signature: identity.sign(payload.to_proto),
+                                      payload: payload.to_proto
+
+      orderers.each { |orderer| orderer.send_broadcast envelope }
+    end
 
-        Protos::ChaincodeActionPayload.new action: chaincode_endorser_action,
-                                           chaincode_proposal_payload: payload_no_trans.to_proto
-      end
+    def logging(section, message = {})
+      logger.info section.to_s.upcase.colorize(:yellow),
+                  message.to_s.colorize(:blue)
+    end
   end
 end

data/lib/fabric/client.rb

@@ -1,45 +1,127 @@
 module Fabric
   class Client
-    attr_reader :identity_context, :orderers, :peers, :channels
+    attr_reader :identity, :crypto_suite,
+                :orderers, :peers, :logger
 
-    def initialize(options = {})
-      options = Fabric.options.merge(options)
+    MAX_ATTEMPTS_CHECK_TRANSACTION = 20
+    DELAY_PERIOD_CHECK_TRANSACTION = 2
 
-      @identity_context = options[:identity_context]
-      @orderers = {}
-      @channels = {}
-      @peers = {}
+    def initialize(opts = {})
+      options = Fabric.options.merge opts
+
+      @logger = Logger.new options[:logger], options[:logger_filters]
+      @identity = options[:identity]
+      @crypto_suite = options[:crypto_suite]
+    end
+
+    def register_peer(url, opts = {})
+      @peers ||= []
+
+      @peers << Peer.new(url: url, opts: opts, logger: logger)
+    end
+
+    def register_orderer(url, opts = {})
+      @orderers ||= []
+
+      @orderers << Orderer.new(url: url, opts: opts, logger: logger)
+    end
+
+    def query(request = {})
+      logging __method__, request
+
+      proposal = Proposal.new crypto_suite, identity, request
+
+      send_query(proposal) { |response| parse_chaincode_response response.response }
+    end
+
+    def invoke(request = {})
+      logging __method__, request
+
+      proposal = Proposal.new crypto_suite, identity, request
+
+      responses = send_query(proposal) { |response| parse_peer_response response }
+
+      transaction = Transaction.new crypto_suite, identity, proposal: proposal,
+                                                            responses: responses
+
+      send_transaction(transaction) { |response| parse_orderer_response response }
+
+      responses.map { |response| parse_chaincode_response response.response }
     end
 
-    def config
-      conf = {}
-      Configuration::VALID_OPTIONS_KEYS.each do |key|
-        conf[key] = public_send key
+    private
+
+    def send_query(proposal, &block)
+      peers.map do |peer|
+        peer_response = peer.send_process_proposal(proposal.signed_proposal)
+
+        block ? yield(peer_response) : peer_response
       end
+    end
+
+    def send_transaction(transaction, &block)
+      payload = Common::Payload.new header: transaction.header,
+                                    data: transaction.transaction.to_proto
+
+      envelope = Common::Envelope.new signature: identity.sign(payload.to_proto),
+                                      payload: payload.to_proto
+
+      orderers.each { |orderer| orderer.send_broadcast envelope, &block }
+
+      check_transaction transaction
+    end
+
+    def check_transaction(transaction)
+      MAX_ATTEMPTS_CHECK_TRANSACTION.times do
+        begin
+          validation_code = get_transaction_validation_code transaction
 
-      conf
+          logging __method__, tx_id: transaction.tx_id, status: validation_code
+
+          return validation_code if validation_code == :VALID
+
+          raise Fabric::TransactionError, validation_code
+        rescue UnknownError => ex
+          sleep DELAY_PERIOD_CHECK_TRANSACTION
+
+          logger.debug ex.message
+        end
+      end
     end
 
-    def new_channel(name)
-      channels[name] ||= Channel.new name: name,
-                                     orderers: orderers.values , peers: peers.values,
-                                     identity_context: identity_context
+    def get_transaction_validation_code(transaction)
+      channel_id = transaction.proposal.channel_id
+      responses = query channel_id: channel_id,
+                        chaincode_id: 'qscc',
+                        args: ['GetTransactionByID', channel_id, transaction.tx_id]
+      processed_transaction = Protos::ProcessedTransaction.decode responses.first
 
-      channels[name]
+      Protos::TxValidationCode.lookup processed_transaction.validationCode
     end
 
-    def new_peer(url, opts = {})
-      peers[url] ||= Peer.new url: url, opts: opts,
-                              identity_context: identity_context
+    def parse_chaincode_response(response)
+      case response.status
+      when 200 then response.payload
+      when 500 then raise ErrorFactory.create(response.message)
+      end
+    end
 
-      peers[url]
+    def parse_peer_response(response)
+      case response.response.status
+      when 200 then response
+      when 500 then raise ErrorFactory.create(response.response.message)
+      end
     end
 
-    def new_orderer(url, opts = {})
-      orderers[url] ||= Orderer.new url: url, opts: opts,
-                                    identity_context: identity_context
+    def parse_orderer_response(response)
+      raise OrdererError response.message unless response.status == :SUCCESS
+
+      response
+    end
 
-      orderers[url]
+    def logging(section, message = {})
+      logger.info section.to_s.upcase.colorize(:yellow),
+                  message.to_s.colorize(:blue)
     end
   end
 end

data/lib/fabric/configuration.rb

@@ -1,14 +1,20 @@
 module Fabric
   module Configuration
-    VALID_OPTIONS_KEYS = [:identity_context, :orderers, :peers]
+    DEFAULT_TIMEOUT = 30
 
-    attr_accessor *VALID_OPTIONS_KEYS
+    VALID_OPTIONS_KEYS = %i[
+      crypto_suite identity orderers
+      channel_id peers timeout logger
+      logger_filters event_hub_url
+    ].freeze
+
+    VALID_OPTIONS_KEYS.each { |attr| attr_accessor attr }
 
     def self.extended(base)
       base.reset
     end
 
-    def configure
+    def self.configure
       yield self
     end
 
@@ -19,7 +25,9 @@ module Fabric
     end
 
     def reset
-      VALID_OPTIONS_KEYS.each {|key| send("#{key}=", nil)}
+      VALID_OPTIONS_KEYS.each { |key| send("#{key}=", nil) }
+
+      self.timeout = DEFAULT_TIMEOUT
     end
   end
 end

data/lib/fabric/constants.rb

@@ -13,6 +13,6 @@ module Fabric
     FUNC_GET_CONFIG_BLOCK = 'GetConfigBlock'.freeze
 
     ## Variables
-    CHANNEL_HEADER_VERSION = 1.freeze
+    CHANNEL_HEADER_VERSION = 1
   end
 end