flow_client 0.1.1 → 0.2.2

data/lib/flow_client/client.rb

@@ -6,6 +6,12 @@ require "json"
 
 # Collection of classes to interact with the Flow blockchain
 module FlowClient
+  class CadenceRuntimeError < StandardError
+  end
+
+  class ClientError < StandardError
+  end
+
   # Flow client
   class Client
     attr_accessor :address_aliases
@@ -20,65 +26,348 @@ module FlowClient
       @stub.ping(req)
     end
 
-    # Accounts
+    # :section: Accounts
+
+    # Returns an account for the address specified at the latest
+    # block.
+    #
+    # @param [String] the address string value
+    #
+    # @return [FlowClient::Account] the account 
     def get_account(address)
       req = Access::GetAccountAtLatestBlockRequest.new(address: to_bytes(address))
-      res = @stub.get_account_at_latest_block(req)
-      res.account
+
+      begin
+        res = @stub.get_account_at_latest_block(req)
+      rescue GRPC::BadStatus => e
+        raise ClientError, e.details
+      else
+        account = FlowClient::Account.new(
+          address: res.account.address.unpack1("H*"),
+          balance: res.account.balance/100000000.0
+        )
+
+        res.account.keys.each do |key|
+          account.keys << FlowClient::AccountKey.new(
+            public_key: key.public_key.unpack1("H*"),
+            index: key.index,
+            sequence_number: key.sequence_number,
+            revoked: key.revoked,
+            weight: key.weight
+          )
+        end
+
+        account.contracts = res.account.contracts
+        account
+      end
+    end
+
+    # Creates a new account
+    #
+    # @return [FlowClient::Account] the newly created account 
+    def create_account(new_account_public_keys, contracts, payer_account, signer)
+      script = File.read(File.join("lib", "cadence", "templates", "create-account.cdc"))
+
+      arguments = [
+        CadenceType.Array(
+          new_account_public_keys.to_a.map { |key| CadenceType.String(key) }
+        ),
+        CadenceType.Dictionary(
+          contracts.to_a.map { |name, code| CadenceType.DictionaryValue(
+            CadenceType.String(name), CadenceType.String(code.unpack1("H*"))
+          ) }
+        ),
+      ]
+
+      transaction = FlowClient::Transaction.new
+      transaction.script = script
+      transaction.reference_block_id = get_latest_block.id
+      transaction.proposer_address = payer_account.address
+      transaction.proposer_key_index = 0
+      transaction.arguments = arguments
+      transaction.proposer_key_sequence_number = get_account(payer_account.address).keys.first.sequence_number
+      transaction.payer_address = payer_account.address
+      transaction.authorizer_addresses = [payer_account.address]
+      transaction.add_envelope_signature(payer_account.address, 0, signer)
+      res = send_transaction(transaction)
+
+      new_account = nil
+      wait_for_transaction(res.id) do |response|
+        raise CadenceRuntimeError, response.error_message if response.status_code != 0
+
+        event_payload = response.events.select { |e| e.type == "flow.AccountCreated" }.first.payload
+        payload_json = JSON.parse(event_payload)
+        new_account_address = payload_json["value"]["fields"][0]["value"]["value"]
+        new_account = get_account(new_account_address)
+      end
+
+      new_account
+    end
+
+    # Adds a public key to an account
+    def add_account_key(public_key_hex, payer_account, signer, weight)
+      script = File.read(File.join("lib", "cadence", "templates", "add-account-key.cdc"))
+
+      arguments = [
+        CadenceType.String(public_key_hex),
+        CadenceType.UFix64(weight)
+      ]
+
+      transaction = FlowClient::Transaction.new
+      transaction.script = script
+      transaction.reference_block_id = get_latest_block.id
+      transaction.proposer_address = payer_account.address
+      transaction.proposer_key_index = 0
+      transaction.arguments = arguments
+      transaction.proposer_key_sequence_number = get_account(payer_account.address).keys.first.sequence_number
+      transaction.payer_address = payer_account.address
+      transaction.authorizer_addresses = [payer_account.address]
+      transaction.add_envelope_signature(payer_account.address, 0, signer)
+      res = send_transaction(transaction)
+
+      wait_for_transaction(res.id) do |response|
+        raise CadenceRuntimeError, response.error_message if response.status_code != 0
+      end
+    end
+
+    # Adds a contract to an account
+    def add_contract(name, code, payer_account, signer)
+      script = File.read(File.join("lib", "cadence", "templates", "add-contract.cdc"))
+      code_hex = code.unpack1("H*")
+
+      arguments = [
+        CadenceType.String(name),
+        CadenceType.String(code_hex)
+      ]
+
+      transaction = FlowClient::Transaction.new
+      transaction.script = script
+      transaction.reference_block_id = get_latest_block.id
+      transaction.proposer_address = payer_account.address
+      transaction.proposer_key_index = 0
+      transaction.arguments = arguments
+      transaction.proposer_key_sequence_number = get_account(payer_account.address).keys.first.sequence_number
+      transaction.payer_address = payer_account.address
+      transaction.authorizer_addresses = [payer_account.address]
+      transaction.add_envelope_signature(payer_account.address, 0, signer)
+      res = send_transaction(transaction)
+
+      wait_for_transaction(res.id) do |response|
+        raise CadenceRuntimeError, response.error_message if response.status_code != 0
+      end
     end
 
-    # Scripts
+    # Removes a contract from an account
+    def remove_contract(name, payer_account, signer)
+      script = File.read(File.join("lib", "cadence", "templates", "remove-contract.cdc"))
+
+      arguments = [
+        CadenceType.String(name),
+      ]
+
+      transaction = FlowClient::Transaction.new
+      transaction.script = script
+      transaction.reference_block_id = get_latest_block.id
+      transaction.proposer_address = payer_account.address
+      transaction.proposer_key_index = 0
+      transaction.arguments = arguments
+      transaction.proposer_key_sequence_number = get_account(payer_account.address).keys.first.sequence_number
+      transaction.payer_address = payer_account.address
+      transaction.authorizer_addresses = [payer_account.address]
+      transaction.add_envelope_signature(payer_account.address, 0, signer)
+      res = send_transaction(transaction)
+
+      wait_for_transaction(res.id) do |response|
+        raise CadenceRuntimeError, response.error_message if response.status_code != 0
+      end
+    end
+
+    # Updates a contract on an account
+    def update_contract(name, code, payer_account, signer)
+      script = File.read(File.join("lib", "cadence", "templates", "update-contract.cdc"))
+      code_hex = code.unpack1("H*")
+
+      arguments = [
+        CadenceType.String(name),
+        CadenceType.String(code_hex)
+      ]
+
+      transaction = FlowClient::Transaction.new
+      transaction.script = script
+      transaction.reference_block_id = get_latest_block.id
+      transaction.proposer_address = payer_account.address
+      transaction.proposer_key_index = 0
+      transaction.arguments = arguments
+      transaction.proposer_key_sequence_number = get_account(payer_account.address).keys.first.sequence_number
+      transaction.payer_address = payer_account.address
+      transaction.authorizer_addresses = [payer_account.address]
+      transaction.add_envelope_signature(payer_account.address, 0, signer)
+      res = send_transaction(transaction)
+
+      wait_for_transaction(res.id) do |response|
+        raise CadenceRuntimeError, response.error_message if response.status_code != 0
+      end
+    end
+
+    # :section: Scripts
+
+    # Executes a script on the blockchain
     def execute_script(script, args = [])
+      processed_args = []
+      args.to_a.each do |arg|
+        processed_arg = arg.class == OpenStruct ? Utils.openstruct_to_json(arg) : arg
+        processed_args << processed_arg
+      end
+
       req = Access::ExecuteScriptAtLatestBlockRequest.new(
         script: FlowClient::Utils.substitute_address_aliases(script, @address_aliases),
-        arguments: args
+        arguments: processed_args
       )
+
       res = @stub.execute_script_at_latest_block(req)
       parse_json(res.value)
     end
 
-    # Blocks
+    # :section: Blocks
+
+    # Returns the latest block
+    #
+    # @return [FlowClient::Block] the block
     def get_latest_block(is_sealed: true)
       req = Access::GetLatestBlockRequest.new(
         is_sealed: is_sealed
       )
+      res = @stub.get_latest_block(req)
+      Block.parse_grpc_block_response(res)
+    end
 
-      @stub.get_latest_block(req)
+    # Returns the block with id
+    #
+    # @return [FlowClient::Block] the block
+    def get_block_by_id(id)
+      req = Access::GetBlockByIDRequest.new(
+        id: to_bytes(id)
+      )
+      res = @stub.get_block_by_id(req)
+      Block.parse_grpc_block_response(res)
     end
 
-    # Events
+    # Returns the latest with height
+    #
+    # @param [Integer] block height
+    #
+    # @return [FlowClient::Block] the block
+    def get_block_by_height(height)
+      req = Access::GetBlockByHeightRequest.new(
+        height: height
+      )
+      res = @stub.get_block_by_height(req)
+      Block.parse_grpc_block_response(res)
+    end
+
+    # :section: Collections
+
+    # Returns the collection with id
+    #
+    # @param [String] collection id
+    #
+    # @return [FlowClient::Collection] the collection
+    def get_collection_by_id(id)
+      req = Access::GetCollectionByIDRequest.new(
+        id: to_bytes(id)
+      )
+      res = @stub.get_collection_by_id(req)
+      Collection.parse_grpc_type(res)
+    end
+
+    # :section: Events
+
+    # Returns events of the given type between the start and end block heights
+    #
+    # @param [String] event name
+    # @param [Integer] start block height
+    # @param [Integer] end block height
+    #
+    # @return [FlowClient::EventsResult] the events response
     def get_events(type, start_height, end_height)
       req = Access::GetEventsForHeightRangeRequest.new(
         type: type,
         start_height: start_height,
         end_height: end_height
       )
-      @stub.get_events_for_height_range(req)
+      begin
+        res = @stub.get_events_for_height_range(req)
+      rescue GRPC::BadStatus => e
+        raise ClientError, e.details
+      else
+        res.results.map { |event| EventsResult.parse_grpc_type(event) }
+      end
     end
 
-    # Transactions
+    # :section: Transactions
 
-    # Send a FlowClient::Transaction transaction to the blockchain
+    # Sends a transaction to the blockchain
+    #
+    # @return [FlowClient::TransactionResponse] the transaction response
     def send_transaction(transaction)
       transaction.address_aliases = @address_aliases
       req = Access::SendTransactionRequest.new(
         transaction: transaction.to_protobuf_message
       )
-      @stub.send_transaction(req)
+
+      begin
+        res = @stub.send_transaction(req)
+      rescue GRPC::BadStatus => e
+        raise ClientError, e.details
+      else
+        TransactionResponse.parse_grpc_type(res)
+      end
     end
 
+    # Returns the transaction with transaction_id
+    #
+    # @return [FlowClient::Transaction] the transaction
     def get_transaction(transaction_id)
       req = Access::GetTransactionRequest.new(
         id: to_bytes(transaction_id)
       )
-      @stub.get_transaction(req)
+
+      begin
+        res = @stub.get_transaction(req)
+      rescue GRPC::BadStatus => e
+        raise ClientError, e.details
+      else
+        Transaction.parse_grpc_type(res.transaction)
+      end
     end
 
+    # Returns a transaction result
+    #
+    # @return [FlowClient::TransactionResult] the transaction result
     def get_transaction_result(transaction_id)
       req = Access::GetTransactionRequest.new(
         id: to_bytes(transaction_id)
       )
-      @stub.get_transaction_result(req)
+
+      begin
+        res = @stub.get_transaction_result(req)
+      rescue GRPC::BadStatus => e
+        raise ClientError, e.details
+      else
+        TransactionResult.parse_grpc_type(res)
+      end
+    end
+
+    # Polls the blockchain for the transaction result until it is sealed
+    # or expired
+    def wait_for_transaction(transaction_id)
+      response = get_transaction_result(transaction_id)
+      while ![:SEALED, :EXPIRED].include? response.status
+        sleep(0.5)
+        response = get_transaction_result(transaction_id)
+      end
+
+      yield(response)
     end
 
     private

data/lib/flow_client/collection.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module FlowClient
+  class Collection
+    attr_accessor :id, :transaction_ids
+
+    def initialize
+      @id = nil
+      @transaction_ids = []
+    end
+
+    def self.parse_grpc_type(grpc_type)
+      collection = Collection.new
+      collection.id = grpc_type.collection.id.unpack1("H*")
+      collection.transaction_ids = grpc_type.collection.transaction_ids.to_a.map { |tid| tid.unpack1("H*") }
+      collection
+    end
+  end
+
+  class CollectionGuarantee
+    attr_accessor :collection_id, :signatures
+
+    def initialize
+      @collection_id = nil
+      @signatures = []
+    end
+
+    def self.parse_grpc_type(grpc_type)
+      collection_guarantee = CollectionGuarantee.new
+      collection_guarantee.collection_id = grpc_type.collection_id.unpack1("H*")
+      collection_guarantee.signatures = grpc_type.signatures.to_a.map { |s| s.unpack1("H*") }
+      collection_guarantee
+    end
+  end
+end

data/lib/flow_client/crypto.rb

@@ -3,31 +3,60 @@
 require "openssl"
 
 module FlowClient
+  # Crypto helpers
   class Crypto
-    def self.sign(data, key)
-      digest = OpenSSL::Digest.digest("SHA3-256", data)
-      asn = key.dsa_sign_asn1(digest)
-      asn1 = OpenSSL::ASN1.decode(asn)
-      r, s = asn1.value
+    module Curves
+      P256 = "prime256v1"
+      SECP256K1 = "secp256k1"
+    end
+
+    module HashAlgos
+      SHA2_256 = "SHA2-256"
+      SHA3_256 = "SHA3-256"
+    end
+
+    # Sign data using the provided key
+    def self.sign(data, private_key_hex, hash_algo = HashAlgos::SHA3_256)
+      ssl_key = FlowClient::Crypto.key_from_hex_keys(private_key_hex)
+      # TODO: Fix this so that both hashing algos will work
+      asn = ssl_key.dsa_sign_asn1(OpenSSL::Digest.digest(hash_algo, data))
+      r, s = OpenSSL::ASN1.decode(asn).value
       combined_bytes = Utils.left_pad_bytes([r.value.to_s(16)].pack("H*").unpack("C*"), 32) +
                        Utils.left_pad_bytes([s.value.to_s(16)].pack("H*").unpack("C*"), 32)
       combined_bytes.pack("C*")
     end
 
-    # TODO: Handle both sig algos here
+    # Constructs an OpenSSL::PKey::EC key from an octet string
+    # keypair.
+    #
     # secp256k1
     # prime256v1
-    def self.key_from_hex_keys(private_hex, public_hex)
-      asn1 = OpenSSL::ASN1::Sequence(
-        [
-          OpenSSL::ASN1::Integer(1),
-          OpenSSL::ASN1::OctetString([private_hex].pack("H*")),
-          OpenSSL::ASN1::ObjectId("prime256v1", 0, :EXPLICIT),
-          OpenSSL::ASN1::BitString([public_hex].pack("H*"), 1, :EXPLICIT)
-        ]
-      )
+    def self.key_from_hex_keys(private_hex, curve = Curves::P256)
+      group = OpenSSL::PKey::EC::Group.new(curve)
+      new_key = OpenSSL::PKey::EC.new(group)
+      new_key.private_key = OpenSSL::BN.new(private_hex, 16)
+      new_key.public_key = group.generator.mul(new_key.private_key)
+      new_key
+    end
 
-      OpenSSL::PKey::EC.new(asn1.to_der)
+    # Returns an octet string keypair.
+    #
+    # Supported ECC curves are:
+    # Crypto::Curves::P256
+    # Crypto::Curves::SECP256K1
+    #
+    # The 04 prefix indicating that the public key is uncompressed is stripped.
+    # @see https://datatracker.ietf.org/doc/html/rfc5480
+    #
+    # Usage example:
+    # private_key, public_key = FlowClient::Crypto.generate_key_pair(FlowClient::Crypto::Curves::P256)
+    def self.generate_key_pair(curve = Curves::P256)
+      key = OpenSSL::PKey::EC.new(curve).generate_key
+      public_key = key.public_key.to_bn.to_s(16).downcase
+      [
+        key.private_key.to_s(16).downcase,
+        public_key[2..public_key.length]
+      ]
     end
   end
 end

data/lib/flow_client/event.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module FlowClient
+  class EventsResult
+    attr_accessor :block_id,
+                  :block_height,
+                  :events,
+                  :block_timestamp
+
+    def initialize
+      @block_id = nil
+      @block_height = nil
+      @events = nil
+      @block_timestamp = nil
+    end
+
+    def self.parse_grpc_type(type)
+      event = EventsResult.new
+      event.block_id = type.block_id.unpack1("H*")
+      event.block_height = type.block_height
+      event.block_timestamp = FlowClient::Utils.parse_protobuf_timestamp(type.block_timestamp)
+      event.events = type.events.map { |event| FlowClient::Event.parse_grpc_type(event) }
+      event
+    end
+  end
+
+  class Event
+    attr_accessor :type,
+                  :transaction_id,
+                  :transaction_index,
+                  :event_index,
+                  :payload
+
+    def initialize
+      @type = nil
+      @transaction_id = nil
+      @transaction_index = nil
+      @event_index = nil
+      @payload = nil
+    end
+
+    def self.parse_grpc_type(type)
+      event = Event.new
+      event.type = type.type
+      event.transaction_id = type.transaction_id.unpack1("H*")
+      event.transaction_index = type.transaction_index
+      event.event_index = type.event_index
+      event.payload = type.payload
+      event
+    end
+  end
+end

data/lib/flow_client/proposal_key.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FlowClient
+  class ProposalKey
+    attr_accessor :address,
+                  :sequence_number,
+                  :key_id
+
+    def initialize(address: nil, key_id: nil, sequence_number: nil)
+      @address = address
+      @sequence_number = sequence_number
+      @key_id = key_id
+    end
+
+    def self.parse_grpc_type(type)
+      signature = ProposalKey.new
+      signature.address = type.address.unpack1("H*")
+      signature.sequence_number = type.sequence_number
+      signature.key_id = type.key_id
+      signature
+    end
+  end
+end

data/lib/flow_client/signature.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FlowClient
+  class Signature
+    attr_accessor :address,
+                  :signature,
+                  :key_id
+
+    def initialize
+      @address = nil
+      @signature = nil
+      @key_id = nil
+    end
+
+    def self.parse_grpc_type(pb_signature)
+      signature = Signature.new
+      signature.address = pb_signature.address.unpack1("H*")
+      signature.signature = pb_signature.signature.unpack1("H*")
+      signature.key_id = pb_signature.key_id
+      signature
+    end
+  end
+end

data/lib/flow_client/signer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FlowClient
+  # An abstract super class for the transaction signers. Subclasses must
+  # implement the sign method to sign transactions.
+  class Signer
+    def sign(data); end
+  end
+
+  # Implements a local singer using an in-memory key.
+  class LocalSigner < Signer
+    def initialize(private_key)
+      super()
+      @private_key = private_key
+    end
+
+    def sign(data)
+      super(data)
+      FlowClient::Crypto.sign(data, @private_key)
+    end
+  end
+end