fabric-gateway 0.2.0 → 0.4.1

data/lib/fabric/contract.rb

@@ -25,28 +25,16 @@ module Fabric
   class Contract
     attr_reader :network, :chaincode_name, :contract_name
 
+    # @!parse include Fabric::Accessors::Network
+    # @!parse include Fabric::Accessors::Gateway
+    include Fabric::Accessors::Network
+
     def initialize(network, chaincode_name, contract_name = '')
       @network = network
       @chaincode_name = chaincode_name
       @contract_name = contract_name
     end
 
-    def client
-      network.client
-    end
-
-    def signer
-      network.signer
-    end
-
-    def gateway
-      network.gateway
-    end
-
-    def network_name
-      network.name
-    end
-
     #
     # Evaluate a transaction function and return its results. A transaction proposal will be evaluated on endorsing
     # peers but the transaction will not be sent to the ordering service and so will not be committed to the ledger.
@@ -66,7 +54,6 @@ module Fabric
     # transaction function will be evaluated on endorsing peers and then submitted to the ordering service to be
     # committed to the ledger.
     #
-    # @TODO: Not yet complete
     #
     # @param [String] transaction_name
     # @param [Array] arguments array of arguments to pass to the transaction
@@ -102,8 +89,6 @@ module Fabric
     # transaction function will be evaluated on endorsing peers and then submitted to the ordering service to be
     # committed to the ledger.
     #
-    # @TODO: Implement Me! - LEFT OFF HERE!
-    #
     # @param [String] transaction_name
     # @param [Hash] proposal_options
     # @option proposal_options [Array] :arguments array of arguments to pass to the transaction
@@ -116,17 +101,15 @@ module Fabric
     #
     def submit(transaction_name, proposal_options = {})
       transaction = new_proposal(transaction_name, **proposal_options).endorse
-      submitted = transaction.submit
-
-      status = submitted.get_status
+      transaction.submit
 
-      raise CommitError, status unless status.get_status == ::GRPC::Core::StatusCodes::OK
+      transaction.result
     end
 
     #
-    # @TODO: unimplemented, not sure if this can be implemented because
-    # the official grpc ruby client does not support non-blocking async
-    # calls (https://github.com/grpc/grpc/issues/10973)
+    # @todo unimplemented, not sure if this can be implemented because
+    #   the official grpc ruby client does not support non-blocking async
+    #   calls (https://github.com/grpc/grpc/issues/10973)
     #
     # not 100% sure if grpc support is necessary for this.
     #
@@ -134,6 +117,30 @@ module Fabric
       raise NotYetImplemented
     end
 
+    #
+    # Get chaincode events emitted by transaction functions of the chaincode.
+    #
+    # @see Fabric::Client#chaincode_events Fabric::Client#chaincode_events - explanation of the different return types
+    #   and example usage.
+    # @see https://www.rubydoc.info/gems/grpc/GRPC%2FClientStub:server_streamer Call options for options parameter
+    #
+    # @param [Integer] start_block Block number at which to start reading chaincode events.
+    # @param [Hash] call_options gRPC call options (merged with default_call_options from initializer)
+    # @yield [chaincode_event] loops through the chaincode events
+    # @yieldparam [Gateway::ChaincodeEventsResponse] chaincode_event the chaincode event
+    #
+    # @return [Enumerator|GRPC::ActiveCall::Operation|nil] Dependent on parameters passed;
+    #   please see Fabric::Client#get_chaincode_events
+    #
+    def chaincode_events(start_block: nil, call_options: {}, &block)
+      network.chaincode_events(
+        self,
+        start_block: start_block,
+        call_options: call_options,
+        &block
+      )
+    end
+
     #
     # Creates a transaction proposal that can be evaluated or endorsed. Supports off-line signing flow.
     #
@@ -156,6 +163,14 @@ module Fabric
       Proposal.new(proposed_transaction)
     end
 
+    #
+    # Generates the qualified transaction name for the contract. (prepends the contract name to the transaction name if
+    # contract name is set)
+    #
+    # @param [string] transaction_name
+    #
+    # @return [string] qualified transaction name
+    #
     def qualified_transaction_name(transaction_name)
       contract_name.nil? || contract_name.empty? ? transaction_name : "#{contract_name}:#{transaction_name}"
     end

data/lib/fabric/ec_crypto_suite.rb

@@ -8,7 +8,7 @@ module Fabric
   #
   # Elliptic-curve Crypto Suite using OpenSSL
   #
-  # @TODO missing tests
+  # @todo missing tests
   class ECCryptoSuite # rubocop:disable Metrics/ClassLength
     DEFAULT_KEY_SIZE = 256
     DEFAULT_DIGEST_ALGORITHM = 'SHA256'

data/lib/fabric/entities/chaincode_events_requests.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Fabric
+  #
+  # Encapsulates a Chaincode Events Request protobuf message
+  #
+  class ChaincodeEventsRequest
+    attr_reader :contract,
+                :start_block
+
+    # @!parse include Fabric::Accessors::Network
+    # @!parse include Fabric::Accessors::Gateway
+    include Fabric::Accessors::Contract
+
+    #
+    # Creates a new ChaincodeEventsRequest
+    #
+    # @param [Fabric::Contract] contract an instance of a contract
+    # @param [Integer] start_block Block number at which to start reading chaincode events.
+    #
+    def initialize(contract, start_block: nil)
+      @contract = contract
+      @start_block = start_block
+    end
+
+    #
+    # Returns the signed request
+    #
+    # @return [Gateway::SignedChaincodeEventsRequest] generated signed request
+    #
+    def signed_request
+      @signed_request ||= ::Gateway::SignedChaincodeEventsRequest.new(request: chaincode_events_request.to_proto)
+    end
+
+    #
+    # Returns the chaincode events request
+    #
+    # @return [Gateway::ChaincodeEventsRequest] chaincode events request - controls what events are returned
+    #   from a chaincode events request
+    #
+    def chaincode_events_request
+      @chaincode_events_request ||= new_chaincode_events_request
+    end
+
+    #
+    # Get the serialized chaincode events request protobuffer message.
+    #
+    # @return [String] protobuffer serialized chaincode events request
+    #
+    def request_bytes
+      signed_request.request
+    end
+
+    #
+    # Get the digest of the chaincode events request. This is used to generate a digital signature.
+    #
+    # @return [String] chaincode events request digest
+    #
+    def request_digest
+      Fabric.crypto_suite.digest(request_bytes)
+    end
+
+    #
+    # Sets the signed request signature.
+    #
+    # @param [String] signature
+    #
+    # @return [void]
+    #
+    def signature=(signature)
+      signed_request.signature = signature
+    end
+
+    #
+    # Returns the signed_request signature
+    #
+    # @return [String] Raw byte string signature
+    #
+    def signature
+      signed_request.signature
+    end
+
+    #
+    # Sign the chaincode events request; Noop if request already signed.
+    #
+    # @return [void]
+    #
+    def sign
+      return if signed?
+
+      self.signature = signer.sign(request_bytes)
+    end
+
+    #
+    # Checks if the signed chaincode events has been signed.
+    #
+    # @return [Boolean] true if the signed chaincode events has been signed; otherwise false.
+    #
+    def signed?
+      !signed_request.signature.empty?
+    end
+
+    #
+    # Get chaincode events emitted by transaction functions of a specific chaincode.
+    #
+    # @see Fabric::Client#chaincode_events Fabric::Client#chaincode_events - explanation of the different return types
+    #   and example usage.
+    # @see https://www.rubydoc.info/gems/grpc/GRPC%2FClientStub:server_streamer Call options for options parameter
+    #
+    # @param [Hash] options gRPC call options (merged with default_call_options from initializer)
+    # @yield [chaincode_event] loops through the chaincode events
+    # @yieldparam [Gateway::ChaincodeEventsResponse] chaincode_event the chaincode event
+    #
+    # @return [Enumerator|GRPC::ActiveCall::Operation|nil] Dependent on parameters passed;
+    #   please see Fabric::Client#get_chaincode_events
+    #
+    def get_events(options = {}, &block)
+      sign
+
+      client.chaincode_events(signed_request, options, &block)
+    end
+
+    private
+
+    #
+    # Generates a new chaincode events request
+    #
+    # @return [Gateway::ChaincodeEventsRequest] chaincode events request - controls what events are returned
+    #
+    def new_chaincode_events_request
+      ::Gateway::ChaincodeEventsRequest.new(
+        channel_id: network_name,
+        chaincode_id: chaincode_name,
+        identity: signer.to_proto,
+        start_position: start_position
+      )
+    end
+
+    #
+    # Generates the start_position for the chaincode events request or returns the cached start_position
+    #
+    # @return [Orderer::SeekPosition] start position for the chaincode events request
+    #
+    def start_position
+      @start_position ||= new_start_position
+    end
+
+    #
+    # Generates the start position for the chaincode events request; if no start_block is specified,
+    # generates a seek next commit start position, otherwise generates a start_position to the start_block
+    #
+    # @return [Orderer::SeekPosition] start position for the chaincode events request
+    #
+    def new_start_position
+      specified = nil
+      next_commit = nil
+
+      if start_block
+        specified = ::Orderer::SeekSpecified.new(number: start_block)
+      else
+        next_commit = ::Orderer::SeekNextCommit.new
+      end
+      Orderer::SeekPosition.new(specified: specified, next_commit: next_commit)
+    end
+  end
+end

data/lib/fabric/entities/envelope.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Fabric
+  #
+  # Encapsulates an Envelop protobuf message
+  #
+  class Envelope
+    # @return [Common::Envelope] transaction envelope
+    attr_reader :envelope
+
+    #
+    # Creates a new Envelope instance.
+    #
+    # @param [Common::Envelope] envelope
+    #
+    def initialize(envelope)
+      @envelope = envelope
+    end
+
+    #
+    # Checks if the envelope has been signed.
+    #
+    # @return [Boolean] true if the envelope has been signed; otherwise false.
+    #
+    def signed?
+      !envelope.signature.empty?
+    end
+
+    #
+    # The protobuffer serialized form of the envelope payload.
+    #
+    # @return [String] serialized payload
+    #
+    def payload_bytes
+      envelope.payload
+    end
+
+    #
+    # The digest of the payload.
+    #
+    # @return [String] payload digest
+    #
+    def payload_digest
+      Fabric.crypto_suite.digest(envelope.payload)
+    end
+
+    #
+    # Sets the envelope signature.
+    #
+    # @param [String] signature
+    #
+    # @return [void]
+    #
+    def signature=(signature)
+      envelope.signature = signature
+    end
+
+    #
+    # Returns the results from the transaction result payload.
+    #
+    # @return [Payload] transaction result payload
+    #
+    def result
+      @result ||= parse_result_from_payload
+    end
+
+    #
+    # Returns the deserialized payload.
+    #
+    # @return [Common::Payload] Envelope payload
+    #
+    def payload
+      @payload ||= Common::Payload.decode(envelope.payload)
+    end
+
+    #
+    # Returns the envelope payload header.
+    #
+    # Envelope => Payload => Header
+    #
+    # @return [Common::Header] Envelope Payload Header
+    #
+    def header
+      raise Fabric::Error, 'Missing header' if payload.header.nil?
+
+      @header ||= payload.header
+    end
+
+    #
+    # Returns the deserialized transaction channel header
+    #
+    # Envelope => Payload => Header => ChannelHeader
+    #
+    # @return [Common::ChannelHeader] envelop payload header channel header
+    #
+    def channel_header
+      @channel_header ||= Common::ChannelHeader.decode(header.channel_header)
+    end
+
+    #
+    # Grabs the channel_name frmo the depths of the envelope.
+    #
+    # @return [String] channel name
+    #
+    def channel_name
+      channel_header.channel_id
+    end
+
+    #
+    # Returns the deserialized transaction
+    #
+    # @return [Protos::Transaction] transaction
+    #
+    def transaction
+      @transaction ||= Protos::Transaction.decode(payload.data)
+    end
+
+    private
+
+    #
+    # Parse the transaction actions from the payload looking for the transaction result payload.
+    #
+    # @return [String] result payload
+    # @raise [Fabric::Error] if the transaction result payload is not found
+    #
+    def parse_result_from_payload
+      errors = []
+      transaction.actions.each do |action|
+        return parse_result_from_transaction_action(action)
+      rescue Fabric::Error => e
+        errors << e
+      end
+
+      raise Fabric::Error, "No proposal response found: #{errors.inspect}"
+    end
+
+    #
+    # Parse a single transaction action looking for the transaction result payload.
+    #
+    # @param [Protos::TransactionAction] transaction_action
+    #
+    # @return [Payload] transaction result payload
+    # @raise [Fabric::Error] if the endorsed_action is missing or the chaincode response is missing
+    #
+    def parse_result_from_transaction_action(transaction_action)
+      action_payload = Protos::ChaincodeActionPayload.decode(transaction_action.payload)
+      endorsed_action = action_payload.action
+      raise Fabric::Error, 'Missing endorsed action' if endorsed_action.nil?
+
+      response_payload = Protos::ProposalResponsePayload.decode(endorsed_action.proposal_response_payload)
+      chaincode_action = Protos::ChaincodeAction.decode(response_payload.extension)
+      chaincode_response = chaincode_action.response
+      raise Fabric::Error, 'Missing chaincode response' if chaincode_response.nil?
+
+      chaincode_response.payload
+    end
+  end
+end

data/lib/fabric/{identity.rb → entities/identity.rb}

@@ -76,9 +76,9 @@ module Fabric
     #
     # Creates a new gateway passing in the current identity
     #
-    # @param [Gateway::Gateway::Stub] connection <description>
+    # @param [Fabric::Client] client
     #
-    # @return [Fabric::Gateway] <description>
+    # @return [Fabric::Gateway] gateway
     #
     def new_gateway(client)
       Fabric::Gateway.new(self, client)

data/lib/fabric/{proposal.rb → entities/proposal.rb}

@@ -22,33 +22,7 @@ module Fabric
       @proposed_transaction.contract
     end
 
-    def network
-      contract.network
-    end
-
-    def client
-      network.client
-    end
-
-    def signer
-      network.signer
-    end
-
-    def gateway
-      network.gateway
-    end
-
-    def network_name
-      network.name
-    end
-
-    def contract_name
-      contract.contract_name
-    end
-
-    def chaincode_name
-      contract.chaincode_name
-    end
+    include Fabric::Accessors::Contract
 
     def transaction_id
       proposed_transaction.transaction_id
@@ -96,7 +70,7 @@ module Fabric
     # @return [String] raw binary digest of the proposal message.
     #
     def digest
-      signer.digest(proposal.to_proto)
+      Fabric.crypto_suite.digest(proposal.to_proto)
     end
 
     #
@@ -153,8 +127,22 @@ module Fabric
       evaluate_response.result.payload
     end
 
-    def endorse
-      # TODO: endorse proposal
+    #
+    # Obtain endorsement for the transaction proposal from sufficient peers to allow it to be committed to the ledger.
+    #
+    # @param [Hash] options gRPC call options @see https://www.rubydoc.info/gems/grpc/GRPC%2FClientStub:request_response
+    #
+    # @return [Fabric::Transaction] An endorsed transaction that can be submitted to the ledger.
+    #
+    def endorse(options = {})
+      sign
+      endorse_response = client.endorse(new_endorse_request, options)
+
+      raise Fabric::Error, 'Missing transaction envelope' if endorse_response.prepared_transaction.nil?
+
+      prepared_transaction = new_prepared_transaction(endorse_response.prepared_transaction)
+
+      Fabric::Transaction.new(network, prepared_transaction)
     end
 
     #
@@ -170,13 +158,32 @@ module Fabric
       )
     end
 
+    #
+    # Creates a new endorse request from this proposal.
+    #
+    # @return [Gateway::EndorseRequest] EndorseRequest protobuf message
+    #
     def new_endorse_request
-      # TODO
+      ::Gateway::EndorseRequest.new(
+        transaction_id: transaction_id,
+        channel_id: network_name,
+        proposed_transaction: signed_proposal,
+        endorsing_organizations: proposed_transaction.endorsing_organizations
+      )
     end
 
-    def new_prepared_transaction
-      # TODO
-      # used in endorse
+    #
+    # Creates a new prepared transaction from a transaction envelope.
+    #
+    # @param [Common::Envelope] envelope transaction envelope
+    #
+    # @return [Gateway::PreparedTransaction] prepared transaction protobuf message
+    #
+    def new_prepared_transaction(envelope)
+      ::Gateway::PreparedTransaction.new(
+        transaction_id: transaction_id,
+        envelope: envelope
+      )
     end
   end
 end

data/lib/fabric/{proposed_transaction.rb → entities/proposed_transaction.rb}

@@ -19,6 +19,10 @@ module Fabric
     # This is usually used in conjunction with transientData for private data scenarios.
     attr_reader :endorsing_organizations
 
+    # @!parse include Fabric::Accessors::Network
+    # @!parse include Fabric::Accessors::Gateway
+    include Fabric::Accessors::Contract
+
     def initialize(contract, transaction_name, arguments: [], transient_data: {}, endorsing_organizations: [])
       @contract = contract
       @transaction_name = transaction_name
@@ -29,34 +33,6 @@ module Fabric
       generate_proposed_transaction
     end
 
-    def network
-      contract.network
-    end
-
-    def client
-      network.client
-    end
-
-    def signer
-      network.signer
-    end
-
-    def gateway
-      network.gateway
-    end
-
-    def network_name
-      network.name
-    end
-
-    def contract_name
-      contract.contract_name
-    end
-
-    def chaincode_name
-      contract.chaincode_name
-    end
-
     #
     # Builds the proposed transaction protobuf message
     #

data/lib/fabric/entities/status.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Fabric
+  #
+  # Status of a transaction that is to be committed to the ledger.
+  #
+  class Status
+    TRANSACTION_STATUSES = ::Protos::TxValidationCode.constants.map(&::Protos::TxValidationCode.method(:const_get))
+                                                     .collect do |i|
+      [::Protos::TxValidationCode.lookup(i), i]
+    end.to_h
+
+    # @return [Integer] Block number in which the transaction committed.
+    attr_reader :block_number
+
+    # @return [Integer] Transaction status
+    attr_reader :code
+
+    # @return [Boolean] `true` if the transaction committed successfully; otherwise `false`.
+    attr_reader :successful
+
+    # @return [String] The ID of the transaction.
+    attr_reader :transaction_id
+
+    def initialize(transaction_id, block_number, code)
+      @transaction_id = transaction_id
+      @block_number = block_number
+      @code = code
+      @successful = @code == TRANSACTION_STATUSES[:VALID]
+    end
+  end
+end