flow_client 0.2.3-arm64-darwin-21

data/lib/flow/legacy/execution/execution_pb.rb

@@ -0,0 +1,65 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: flow/legacy/execution/execution.proto
+
+require 'google/protobuf'
+
+require 'flow/legacy/entities/account_pb'
+require 'flow/legacy/entities/event_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("flow/legacy/execution/execution.proto", :syntax => :proto3) do
+    add_message "execution.PingRequest" do
+    end
+    add_message "execution.PingResponse" do
+    end
+    add_message "execution.GetAccountAtBlockIDRequest" do
+      optional :block_id, :bytes, 1
+      optional :address, :bytes, 2
+    end
+    add_message "execution.GetAccountAtBlockIDResponse" do
+      optional :account, :message, 1, "entities.Account"
+    end
+    add_message "execution.ExecuteScriptAtBlockIDRequest" do
+      optional :block_id, :bytes, 1
+      optional :script, :bytes, 2
+      repeated :arguments, :bytes, 3
+    end
+    add_message "execution.ExecuteScriptAtBlockIDResponse" do
+      optional :value, :bytes, 1
+    end
+    add_message "execution.GetEventsForBlockIDsResponse" do
+      repeated :results, :message, 1, "execution.GetEventsForBlockIDsResponse.Result"
+    end
+    add_message "execution.GetEventsForBlockIDsResponse.Result" do
+      optional :block_id, :bytes, 1
+      optional :block_height, :uint64, 2
+      repeated :events, :message, 3, "entities.Event"
+    end
+    add_message "execution.GetEventsForBlockIDsRequest" do
+      optional :type, :string, 1
+      repeated :block_ids, :bytes, 2
+    end
+    add_message "execution.GetTransactionResultRequest" do
+      optional :block_id, :bytes, 1
+      optional :transaction_id, :bytes, 2
+    end
+    add_message "execution.GetTransactionResultResponse" do
+      optional :status_code, :uint32, 1
+      optional :error_message, :string, 2
+      repeated :events, :message, 3, "entities.Event"
+    end
+  end
+end
+
+module Execution
+  PingRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.PingRequest").msgclass
+  PingResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.PingResponse").msgclass
+  GetAccountAtBlockIDRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.GetAccountAtBlockIDRequest").msgclass
+  GetAccountAtBlockIDResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.GetAccountAtBlockIDResponse").msgclass
+  ExecuteScriptAtBlockIDRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.ExecuteScriptAtBlockIDRequest").msgclass
+  ExecuteScriptAtBlockIDResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.ExecuteScriptAtBlockIDResponse").msgclass
+  GetEventsForBlockIDsResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.GetEventsForBlockIDsResponse").msgclass
+  GetEventsForBlockIDsResponse::Result = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.GetEventsForBlockIDsResponse.Result").msgclass
+  GetEventsForBlockIDsRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.GetEventsForBlockIDsRequest").msgclass
+  GetTransactionResultRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.GetTransactionResultRequest").msgclass
+  GetTransactionResultResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("execution.GetTransactionResultResponse").msgclass
+end

data/lib/flow/legacy/execution/execution_services_pb.rb

@@ -0,0 +1,42 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: flow/legacy/execution/execution.proto for package 'execution'
+
+require 'grpc'
+require 'flow/legacy/execution/execution_pb'
+
+module Execution
+  module ExecutionAPI
+    # ExecutionAPI is the API provided by the execution nodes.
+    class Service
+
+      include ::GRPC::GenericService
+
+      self.marshal_class_method = :encode
+      self.unmarshal_class_method = :decode
+      self.service_name = 'execution.ExecutionAPI'
+
+      # Ping is used to check if the access node is alive and healthy.
+      rpc :Ping, ::Execution::PingRequest, ::Execution::PingResponse
+      # Accounts
+      #
+      # GetAccountAtBlockID gets an account by address at the given block ID
+      rpc :GetAccountAtBlockID, ::Execution::GetAccountAtBlockIDRequest, ::Execution::GetAccountAtBlockIDResponse
+      # Scripts
+      #
+      # ExecuteScriptAtBlockID executes a ready-only Cadence script against the
+      # execution state at the block with the given ID.
+      rpc :ExecuteScriptAtBlockID, ::Execution::ExecuteScriptAtBlockIDRequest, ::Execution::ExecuteScriptAtBlockIDResponse
+      # Events
+      #
+      # GetEventsForBlockIDs retrieves events for all the specified block IDs that
+      # have the given type
+      rpc :GetEventsForBlockIDs, ::Execution::GetEventsForBlockIDsRequest, ::Execution::GetEventsForBlockIDsResponse
+      # Transaction
+      #
+      # GetTransactionResult gets the result of a transaction.
+      rpc :GetTransactionResult, ::Execution::GetTransactionResultRequest, ::Execution::GetTransactionResultResponse
+    end
+
+    Stub = Service.rpc_stub_class
+  end
+end

data/lib/flow_client/account.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FlowClient
+  class AccountKey
+    attr_accessor :public_key,
+                  :index, :sequence_number,
+                  :sign_algo, :hash_algo,
+                  :weight, :revoked
+
+    def initialize(public_key: nil, index: nil, sequence_number: nil, weight: 1000, revoked: false, hash_algo: FlowClient::Crypto::HashAlgos::SHA3_256)
+      @public_key = public_key
+      @index = index
+      @sequence_number = sequence_number
+      @weight = weight
+      @revoked = revoked
+      @hash_algo = hash_algo
+    end
+  end
+
+  class Account
+    attr_accessor :address, :balance, :keys, :contracts
+
+    def initialize(address: nil, balance: nil, keys: [], contracts: {})
+      @keys = keys
+      @address = address
+      @balance = balance
+      @contracts = contracts
+      @contracts = {}
+    end
+  end
+end

data/lib/flow_client/block.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module FlowClient
+  # Represents a block
+  class Block
+    attr_accessor :id,
+                  :parent_id,
+                  :height,
+                  :timestamp,
+                  :collection_guarantees,
+                  :block_seals,
+                  :signatures
+
+    def initialize
+      @id = nil
+      @parent_id = nil
+      @height = nil
+      @timestamp = nil
+      @collection_guarantees = []
+      @block_seals = []
+      @signatures = []
+    end
+
+    def self.parse_grpc_block_response(block_response)
+      block = Block.new
+      block.id = block_response.block.id.unpack1("H*")
+      block.parent_id = block_response.block.parent_id.unpack1("H*")
+      block.height = block_response.block.height
+      block.timestamp = FlowClient::Utils.parse_protobuf_timestamp(block_response.block.timestamp)
+      block.collection_guarantees = block_response.block.collection_guarantees.to_a.map do |cg|
+        FlowClient::CollectionGuarantee.parse_grpc_type(cg)
+      end
+      block.block_seals = block_response.block.block_seals.to_a.map do |seal|
+        FlowClient::BlockSeal.parse_grpc_type(seal)
+      end
+      block.signatures = block_response.block.signatures.to_a.map { |sig| sig.unpack1("H*") }
+      block
+    end
+  end
+
+  # Represents a block seal
+  class BlockSeal
+    attr_accessor :block_id,
+                  :execution_receipt_id,
+                  :execution_receipt_signatures,
+                  :result_approval_signatures
+
+    def initialize
+      @block_id = nil
+      @execution_receipt_id = nil
+      @execution_receipt_signatures = []
+      @result_approval_signatures = []
+    end
+
+    def self.parse_grpc_type(grpc_type)
+      block_seal = BlockSeal.new
+      block_seal.block_id = grpc_type.block_id.unpack1("H*")
+      block_seal.execution_receipt_id = grpc_type.execution_receipt_id.unpack1("H*")
+      block_seal.execution_receipt_signatures = grpc_type.execution_receipt_signatures.to_a.map do |sig|
+        sig.unpack1("H*")
+      end
+      block_seal.result_approval_signatures = grpc_type.result_approval_signatures.to_a.map { |sig| sig.unpack1("H*") }
+      block_seal
+    end
+  end
+
+  # Represents a block header
+  class BlockHeader
+    attr_accessor :id, :parent_id, :height, :timestamp
+
+    def initialize; end
+
+    def self.parse_grpc_type(grpc_type)
+      header = BlockHeader.new
+      header.id = grpc_type.id.unpack1("H*")
+      header.height = grpc_type.height
+      header.timestamp = FlowClient::Utils.parse_protobuf_timestamp(grpc_type.timestamp)
+      header
+    end
+  end
+end

data/lib/flow_client/cadence_type.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module FlowClient
+  module CadenceType
+    # Returns an OpenStruct representing a Cadence String type
+    #
+    # @example
+    #   @arg = FlowClient::CadenceType.String("Hello world!")
+    #
+    # @param [String] the string value
+    #
+    # @returns [OpenStruct] the Cadence String struct
+    def self.String(value)
+      OpenStruct.new(type: "String", value: value.to_s)
+    end
+
+    # Returns an OpenStruct representing a Cadence Optional type
+    #
+    # @example
+    #   @arg = FlowClient::CadenceType.Optional("Hello world!")
+    #   @arg = FlowClient::CadenceType.Optional()
+    #
+    # @param [String] the string value
+    #
+    # @returns [OpenStruct] the Cadence Optional struct
+    def self.Optional(value = nil)
+      OpenStruct.new(type: "Optional", value: value)
+    end
+
+    # Returns an OpenStruct representing a Cadence Void type
+    #
+    # @example
+    #   @arg = FlowClient::CadenceType.Void()
+    #
+    # @returns [OpenStruct] the Cadence Void struct
+    def self.Void
+      OpenStruct.new(type: "Void")
+    end
+
+    def self.Bool(bool)
+      OpenStruct.new(type: "Bool", value: bool.to_s.downcase == "true")
+    end
+
+    def self.Address(address)
+      OpenStruct.new(type: "Address", value: address.to_s)
+    end
+
+    def self.Int(value)
+      OpenStruct.new(type: "Int", value: value.to_s)
+    end
+
+    def self.UInt(value)
+      OpenStruct.new(type: "UInt", value: value.to_s)
+    end
+
+    def self.Int8(value)
+      OpenStruct.new(type: "Int8", value: value.to_s)
+    end
+
+    def self.UInt8(value)
+      OpenStruct.new(type: "UInt8", value: value.to_s)
+    end
+
+    def self.Int16(value)
+      OpenStruct.new(type: "Int16", value: value.to_s)
+    end
+
+    def self.UInt16(value)
+      OpenStruct.new(type: "UInt16", value: value.to_s)
+    end
+
+    def self.Int32(value)
+      OpenStruct.new(type: "Int32", value: value.to_s)
+    end
+
+    def self.UInt32(value)
+      OpenStruct.new(type: "UInt32", value: value.to_s)
+    end
+
+    def self.Int64(value)
+      OpenStruct.new(type: "Int64", value: value.to_s)
+    end
+
+    def self.UInt64(value)
+      OpenStruct.new(type: "UInt64", value: value.to_s)
+    end
+
+    def self.Int128(value)
+      OpenStruct.new(type: "Int128", value: value.to_s)
+    end
+
+    def self.UInt128(value)
+      OpenStruct.new(type: "UInt128", value: value.to_s)
+    end
+
+    def self.Int256(value)
+      OpenStruct.new(type: "Int256", value: value.to_s)
+    end
+
+    def self.UInt256(value)
+      OpenStruct.new(type: "UInt256", value: value.to_s)
+    end
+
+    def self.Word8(value)
+      OpenStruct.new(type: "Word8", value: value.to_s)
+    end
+
+    def self.Word16(value)
+      OpenStruct.new(type: "Word16", value: value.to_s)
+    end
+
+    def self.Word32(value)
+      OpenStruct.new(type: "Word32", value: value.to_s)
+    end
+
+    def self.Word64(value)
+      OpenStruct.new(type: "Word64", value: value.to_s)
+    end
+
+    def self.Fix64(value)
+      OpenStruct.new(type: "Fix64", value: value.to_s)
+    end
+
+    def self.UFix64(value)
+      OpenStruct.new(type: "UFix64", value: value.to_s)
+    end
+
+    def self.Array(values)
+      OpenStruct.new(type: "Array", value: values)
+    end
+
+    def self.Dictionary(values)
+      OpenStruct.new(type: "Dictionary", value: values)
+    end
+
+    def self.DictionaryValue(key, value)
+      OpenStruct.new(key: key, value: value)
+    end
+
+    def self.Path(domain, identifier)
+      unless %w[storage private public].include? domain.to_s.downcase
+        raise raise ArgumentError, "Domain can only be one of storage, private or public"
+      end
+
+      OpenStruct.new(
+        type: "Path",
+        value: OpenStruct.new(domain: domain, identifier: identifier)
+      )
+    end
+
+    def self.Type(type_value)
+      OpenStruct.new(type: "Type", value: OpenStruct.new(staticType: type_value.to_s))
+    end
+
+    def self.Capability(path, address, borrow_type)
+      OpenStruct.new(
+        type: "Capability",
+        value: OpenStruct.new(
+          path: path.to_s,
+          address: address.to_s,
+          borrowType: borrow_type.to_s
+        )
+      )
+    end
+
+    def self.Composite(type, value)
+      valid_types = %i[struct resource event contract enum]
+      unless valid_types.include? type
+        raise ArgumentError, "incorrect type, expected :struct, :resource, :event, :contract or :enum"
+      end
+
+      OpenStruct.new(type: type.to_s.capitalize, value: value)
+    end
+
+    def self.CompositeValue(id, fields)
+      OpenStruct.new(id: id, fields: fields)
+    end
+
+    def self.Field(name, value)
+      OpenStruct.new(name: name, value: value)
+    end
+  end
+end