flow_client 0.2.3-arm64-darwin-21

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "flow_client"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docker-compose.yml

@@ -0,0 +1,12 @@
+version: "3"
+services:
+  emulator:
+    image: gcr.io/flow-container-registry/emulator:latest
+    ports:
+      - "8080:8080"
+      - "3569:3569"
+    environment:
+      - FLOW_SERVICEPRIVATEKEY=4d9287571c8bff7482ffc27ef68d5b4990f9bd009a1e9fa812aae08ba167d57f
+      - FLOW_SERVICEKEYSIGALGO=ECDSA_P256
+      - FLOW_SERVICEKEYHASHALGO=SHA3_256
+      - FLOW_VERBOSE=true

data/flow.json

@@ -0,0 +1,21 @@
+{
+	"emulators": {
+		"default": {
+			"port": 3569,
+			"serviceAccount": "emulator-account"
+		}
+	},
+	"contracts": {},
+	"networks": {
+		"emulator": "127.0.0.1:3569",
+		"mainnet": "access.mainnet.nodes.onflow.org:9000",
+		"testnet": "access.devnet.nodes.onflow.org:9000"
+	},
+	"accounts": {
+		"emulator-account": {
+			"address": "f8d6e0586b0a20c7",
+			"key": "38a7eef2053e165c2d635fb471fb26c91d9da2914a8f13c58ec210412adb2067"
+		}
+	},
+	"deployments": {}
+}

data/flow_client.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "lib/flow_client/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "flow_client"
+  spec.version       = FlowClient::VERSION
+  spec.authors       = ["Nico du Plessis"]
+  spec.email         = ["nico@glucode.com"]
+  spec.summary       = "A Ruby client for the Flow blockchain"
+  spec.description   = "A Ruby client for the Flow blockchain"
+  spec.homepage      = "https://github.com/glucode/flow_client"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.7.2"
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'https://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/glucode/flow_client"
+  spec.metadata["changelog_uri"] = "https://github.com/glucode/flow_client"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_runtime_dependency "grpc", "~> 1.48.0"
+  spec.add_runtime_dependency "grpc-tools", "~> 1.48.0"
+  spec.add_runtime_dependency "json", "~> 2.6.2"
+  spec.add_runtime_dependency "openssl", "~> 3.0.0"
+  spec.add_runtime_dependency "rlp", "~> 0.7.3"
+
+  spec.add_development_dependency "simplecov"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+
+  spec.platform = Gem::Platform::CURRENT
+end

data/lib/cadence/contracts/NonFungibleToken.cdc

@@ -0,0 +1,144 @@
+/**
+
+## The Flow Non-Fungible Token standard
+
+## `NonFungibleToken` contract interface
+
+The interface that all non-fungible token contracts could conform to.
+If a user wants to deploy a new nft contract, their contract would need
+to implement the NonFungibleToken interface.
+
+Their contract would have to follow all the rules and naming
+that the interface specifies.
+
+## `NFT` resource
+
+The core resource type that represents an NFT in the smart contract.
+
+## `Collection` Resource
+
+The resource that stores a user's NFT collection.
+It includes a few functions to allow the owner to easily
+move tokens in and out of the collection.
+
+## `Provider` and `Receiver` resource interfaces
+
+These interfaces declare functions with some pre and post conditions
+that require the Collection to follow certain naming and behavior standards.
+
+They are separate because it gives the user the ability to share a reference
+to their Collection that only exposes the fields and functions in one or more
+of the interfaces. It also gives users the ability to make custom resources
+that implement these interfaces to do various things with the tokens.
+
+By using resources and interfaces, users of NFT smart contracts can send
+and receive tokens peer-to-peer, without having to interact with a central ledger
+smart contract.
+
+To send an NFT to another user, a user would simply withdraw the NFT
+from their Collection, then call the deposit function on another user's
+Collection to complete the transfer.
+
+*/
+
+// The main NFT contract interface. Other NFT contracts will
+// import and implement this interface
+//
+pub contract interface NonFungibleToken {
+
+    // The total number of tokens of this type in existence
+    pub var totalSupply: UInt64
+
+    // Event that emitted when the NFT contract is initialized
+    //
+    pub event ContractInitialized()
+
+    // Event that is emitted when a token is withdrawn,
+    // indicating the owner of the collection that it was withdrawn from.
+    //
+    // If the collection is not in an account's storage, `from` will be `nil`.
+    //
+    pub event Withdraw(id: UInt64, from: Address?)
+
+    // Event that emitted when a token is deposited to a collection.
+    //
+    // It indicates the owner of the collection that it was deposited to.
+    //
+    pub event Deposit(id: UInt64, to: Address?)
+
+    // Interface that the NFTs have to conform to
+    //
+    pub resource interface INFT {
+        // The unique ID that each NFT has
+        pub let id: UInt64
+    }
+
+    // Requirement that all conforming NFT smart contracts have
+    // to define a resource called NFT that conforms to INFT
+    pub resource NFT: INFT {
+        pub let id: UInt64
+    }
+
+    // Interface to mediate withdraws from the Collection
+    //
+    pub resource interface Provider {
+        // withdraw removes an NFT from the collection and moves it to the caller
+        pub fun withdraw(withdrawID: UInt64): @NFT {
+            post {
+                result.id == withdrawID: "The ID of the withdrawn token must be the same as the requested ID"
+            }
+        }
+    }
+
+    // Interface to mediate deposits to the Collection
+    //
+    pub resource interface Receiver {
+
+        // deposit takes an NFT as an argument and adds it to the Collection
+        //
+        pub fun deposit(token: @NFT)
+    }
+
+    // Interface that an account would commonly 
+    // publish for their collection
+    pub resource interface CollectionPublic {
+        pub fun deposit(token: @NFT)
+        pub fun getIDs(): [UInt64]
+        pub fun borrowNFT(id: UInt64): &NFT
+    }
+
+    // Requirement for the the concrete resource type
+    // to be declared in the implementing contract
+    //
+    pub resource Collection: Provider, Receiver, CollectionPublic {
+
+        // Dictionary to hold the NFTs in the Collection
+        pub var ownedNFTs: @{UInt64: NFT}
+
+        // withdraw removes an NFT from the collection and moves it to the caller
+        pub fun withdraw(withdrawID: UInt64): @NFT
+
+        // deposit takes a NFT and adds it to the collections dictionary
+        // and adds the ID to the id array
+        pub fun deposit(token: @NFT)
+
+        // getIDs returns an array of the IDs that are in the collection
+        pub fun getIDs(): [UInt64]
+
+        // Returns a borrowed reference to an NFT in the collection
+        // so that the caller can read data and call methods from it
+        pub fun borrowNFT(id: UInt64): &NFT {
+            pre {
+                self.ownedNFTs[id] != nil: "NFT does not exist in the collection!"
+            }
+        }
+    }
+
+    // createEmptyCollection creates an empty Collection
+    // and returns it to the caller so that they can own NFTs
+    pub fun createEmptyCollection(): @Collection {
+        post {
+            result.getIDs().length == 0: "The created collection must be empty!"
+        }
+    }
+}

data/lib/cadence/templates/add-account-key.cdc

@@ -0,0 +1,16 @@
+transaction(publicKey: String, weight: UFix64) {
+	prepare(signer: AuthAccount) {
+		// signer.addPublicKey(publicKey.decodeHex())
+
+		let key = PublicKey(
+			publicKey: publicKey.decodeHex(),
+			signatureAlgorithm: SignatureAlgorithm.ECDSA_P256
+		)
+
+		signer.keys.add(
+			publicKey: key,
+			hashAlgorithm: HashAlgorithm.SHA3_256,
+			weight: weight
+		)
+	}
+}

data/lib/cadence/templates/add-contract.cdc

@@ -0,0 +1,5 @@
+transaction(name: String, code: String) {
+	prepare(signer: AuthAccount) {
+		signer.contracts.add(name: name, code: code.decodeHex())
+	}
+}

data/lib/cadence/templates/create-account.cdc

@@ -0,0 +1,21 @@
+transaction(publicKeys: [String], contracts: {String: String}) {
+	prepare(signer: AuthAccount) {
+		let acct = AuthAccount(payer: signer)
+		for keyHex in publicKeys {
+			let key = PublicKey(
+				publicKey: keyHex.decodeHex(),
+				signatureAlgorithm: SignatureAlgorithm.ECDSA_P256
+			)
+
+			acct.keys.add(
+				publicKey: key,
+				hashAlgorithm: HashAlgorithm.SHA3_256,
+				weight: 1000.0
+			)
+		}
+	
+		for contract in contracts.keys {
+			acct.contracts.add(name: contract, code: contracts[contract]!.decodeHex())
+		}
+	}
+}

data/lib/cadence/templates/remove-contract.cdc

@@ -0,0 +1,5 @@
+transaction(name: String) {
+	prepare(signer: AuthAccount) {
+		signer.contracts.remove(name: name)
+	}
+}

data/lib/cadence/templates/update-contract.cdc

@@ -0,0 +1,5 @@
+transaction(name: String, code: String) {
+	prepare(signer: AuthAccount) {
+		signer.contracts.update__experimental(name: name, code: code.decodeHex())
+	}
+}

data/lib/flow/access/access_pb.rb

@@ -0,0 +1,168 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: flow/access/access.proto
+
+require 'google/protobuf'
+
+require 'flow/entities/account_pb'
+require 'flow/entities/block_header_pb'
+require 'flow/entities/block_pb'
+require 'flow/entities/collection_pb'
+require 'flow/entities/event_pb'
+require 'flow/entities/transaction_pb'
+require 'google/protobuf/timestamp_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("flow/access/access.proto", :syntax => :proto3) do
+    add_message "flow.access.PingRequest" do
+    end
+    add_message "flow.access.PingResponse" do
+    end
+    add_message "flow.access.GetLatestBlockHeaderRequest" do
+      optional :is_sealed, :bool, 1
+    end
+    add_message "flow.access.GetBlockHeaderByIDRequest" do
+      optional :id, :bytes, 1
+    end
+    add_message "flow.access.GetBlockHeaderByHeightRequest" do
+      optional :height, :uint64, 1
+    end
+    add_message "flow.access.BlockHeaderResponse" do
+      optional :block, :message, 1, "flow.entities.BlockHeader"
+    end
+    add_message "flow.access.GetLatestBlockRequest" do
+      optional :is_sealed, :bool, 1
+    end
+    add_message "flow.access.GetBlockByIDRequest" do
+      optional :id, :bytes, 1
+    end
+    add_message "flow.access.GetBlockByHeightRequest" do
+      optional :height, :uint64, 1
+    end
+    add_message "flow.access.BlockResponse" do
+      optional :block, :message, 1, "flow.entities.Block"
+    end
+    add_message "flow.access.GetCollectionByIDRequest" do
+      optional :id, :bytes, 1
+    end
+    add_message "flow.access.CollectionResponse" do
+      optional :collection, :message, 1, "flow.entities.Collection"
+    end
+    add_message "flow.access.SendTransactionRequest" do
+      optional :transaction, :message, 1, "flow.entities.Transaction"
+    end
+    add_message "flow.access.SendTransactionResponse" do
+      optional :id, :bytes, 1
+    end
+    add_message "flow.access.GetTransactionRequest" do
+      optional :id, :bytes, 1
+    end
+    add_message "flow.access.TransactionResponse" do
+      optional :transaction, :message, 1, "flow.entities.Transaction"
+    end
+    add_message "flow.access.TransactionResultResponse" do
+      optional :status, :enum, 1, "flow.entities.TransactionStatus"
+      optional :status_code, :uint32, 2
+      optional :error_message, :string, 3
+      repeated :events, :message, 4, "flow.entities.Event"
+      optional :block_id, :bytes, 5
+    end
+    add_message "flow.access.GetAccountRequest" do
+      optional :address, :bytes, 1
+    end
+    add_message "flow.access.GetAccountResponse" do
+      optional :account, :message, 1, "flow.entities.Account"
+    end
+    add_message "flow.access.GetAccountAtLatestBlockRequest" do
+      optional :address, :bytes, 1
+    end
+    add_message "flow.access.AccountResponse" do
+      optional :account, :message, 1, "flow.entities.Account"
+    end
+    add_message "flow.access.GetAccountAtBlockHeightRequest" do
+      optional :address, :bytes, 1
+      optional :block_height, :uint64, 2
+    end
+    add_message "flow.access.ExecuteScriptAtLatestBlockRequest" do
+      optional :script, :bytes, 1
+      repeated :arguments, :bytes, 2
+    end
+    add_message "flow.access.ExecuteScriptAtBlockIDRequest" do
+      optional :block_id, :bytes, 1
+      optional :script, :bytes, 2
+      repeated :arguments, :bytes, 3
+    end
+    add_message "flow.access.ExecuteScriptAtBlockHeightRequest" do
+      optional :block_height, :uint64, 1
+      optional :script, :bytes, 2
+      repeated :arguments, :bytes, 3
+    end
+    add_message "flow.access.ExecuteScriptResponse" do
+      optional :value, :bytes, 1
+    end
+    add_message "flow.access.GetEventsForHeightRangeRequest" do
+      optional :type, :string, 1
+      optional :start_height, :uint64, 2
+      optional :end_height, :uint64, 3
+    end
+    add_message "flow.access.GetEventsForBlockIDsRequest" do
+      optional :type, :string, 1
+      repeated :block_ids, :bytes, 2
+    end
+    add_message "flow.access.EventsResponse" do
+      repeated :results, :message, 1, "flow.access.EventsResponse.Result"
+    end
+    add_message "flow.access.EventsResponse.Result" do
+      optional :block_id, :bytes, 1
+      optional :block_height, :uint64, 2
+      repeated :events, :message, 3, "flow.entities.Event"
+      optional :block_timestamp, :message, 4, "google.protobuf.Timestamp"
+    end
+    add_message "flow.access.GetNetworkParametersRequest" do
+    end
+    add_message "flow.access.GetNetworkParametersResponse" do
+      optional :chain_id, :string, 1
+    end
+    add_message "flow.access.GetLatestProtocolStateSnapshotRequest" do
+    end
+    add_message "flow.access.ProtocolStateSnapshotResponse" do
+      optional :serializedSnapshot, :bytes, 1
+    end
+  end
+end
+
+
+module Access
+  PingRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.PingRequest").msgclass
+  PingResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.PingResponse").msgclass
+  GetLatestBlockHeaderRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetLatestBlockHeaderRequest").msgclass
+  GetBlockHeaderByIDRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetBlockHeaderByIDRequest").msgclass
+  GetBlockHeaderByHeightRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetBlockHeaderByHeightRequest").msgclass
+  BlockHeaderResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.BlockHeaderResponse").msgclass
+  GetLatestBlockRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetLatestBlockRequest").msgclass
+  GetBlockByIDRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetBlockByIDRequest").msgclass
+  GetBlockByHeightRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetBlockByHeightRequest").msgclass
+  BlockResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.BlockResponse").msgclass
+  GetCollectionByIDRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetCollectionByIDRequest").msgclass
+  CollectionResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.CollectionResponse").msgclass
+  SendTransactionRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.SendTransactionRequest").msgclass
+  SendTransactionResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.SendTransactionResponse").msgclass
+  GetTransactionRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetTransactionRequest").msgclass
+  TransactionResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.TransactionResponse").msgclass
+  TransactionResultResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.TransactionResultResponse").msgclass
+  GetAccountRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetAccountRequest").msgclass
+  GetAccountResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetAccountResponse").msgclass
+  GetAccountAtLatestBlockRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetAccountAtLatestBlockRequest").msgclass
+  AccountResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.AccountResponse").msgclass
+  GetAccountAtBlockHeightRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetAccountAtBlockHeightRequest").msgclass
+  ExecuteScriptAtLatestBlockRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.ExecuteScriptAtLatestBlockRequest").msgclass
+  ExecuteScriptAtBlockIDRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.ExecuteScriptAtBlockIDRequest").msgclass
+  ExecuteScriptAtBlockHeightRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.ExecuteScriptAtBlockHeightRequest").msgclass
+  ExecuteScriptResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.ExecuteScriptResponse").msgclass
+  GetEventsForHeightRangeRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetEventsForHeightRangeRequest").msgclass
+  GetEventsForBlockIDsRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetEventsForBlockIDsRequest").msgclass
+  EventsResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.EventsResponse").msgclass
+  EventsResponse::Result = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.EventsResponse.Result").msgclass
+  GetNetworkParametersRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetNetworkParametersRequest").msgclass
+  GetNetworkParametersResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetNetworkParametersResponse").msgclass
+  GetLatestProtocolStateSnapshotRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.GetLatestProtocolStateSnapshotRequest").msgclass
+  ProtocolStateSnapshotResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.access.ProtocolStateSnapshotResponse").msgclass
+end

data/lib/flow/access/access_services_pb.rb

@@ -0,0 +1,96 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: flow/access/access.proto for package 'flow.access'
+
+require 'grpc'
+require 'flow/access/access_pb'
+
+module Access
+  module AccessAPI
+    # AccessAPI is the public-facing API provided by access nodes.
+    class Service
+
+      include ::GRPC::GenericService
+
+      self.marshal_class_method = :encode
+      self.unmarshal_class_method = :decode
+      self.service_name = 'flow.access.AccessAPI'
+
+      # Ping is used to check if the access node is alive and healthy.
+      rpc :Ping, ::Access::PingRequest, ::Access::PingResponse
+      # Block Headers
+      #
+      # GetLatestBlockHeader gets the latest sealed or unsealed block header.
+      rpc :GetLatestBlockHeader, ::Access::GetLatestBlockHeaderRequest, ::Access::BlockHeaderResponse
+      # GetBlockHeaderByID gets a block header by ID.
+      rpc :GetBlockHeaderByID, ::Access::GetBlockHeaderByIDRequest, ::Access::BlockHeaderResponse
+      # GetBlockHeaderByHeight gets a block header by height.
+      rpc :GetBlockHeaderByHeight, ::Access::GetBlockHeaderByHeightRequest, ::Access::BlockHeaderResponse
+      # Blocks
+      #
+      # GetLatestBlock gets the full payload of the latest sealed or unsealed
+      # block.
+      rpc :GetLatestBlock, ::Access::GetLatestBlockRequest, ::Access::BlockResponse
+      # GetBlockByID gets a full block by ID.
+      rpc :GetBlockByID, ::Access::GetBlockByIDRequest, ::Access::BlockResponse
+      # GetBlockByHeight gets a full block by height.
+      rpc :GetBlockByHeight, ::Access::GetBlockByHeightRequest, ::Access::BlockResponse
+      # Collections
+      #
+      # GetCollectionByID gets a collection by ID.
+      rpc :GetCollectionByID, ::Access::GetCollectionByIDRequest, ::Access::CollectionResponse
+      # Transactions
+      #
+      # SendTransaction submits a transaction to the network.
+      rpc :SendTransaction, ::Access::SendTransactionRequest, ::Access::SendTransactionResponse
+      # GetTransaction gets a transaction by ID.
+      rpc :GetTransaction, ::Access::GetTransactionRequest, ::Access::TransactionResponse
+      # GetTransactionResult gets the result of a transaction.
+      rpc :GetTransactionResult, ::Access::GetTransactionRequest, ::Access::TransactionResultResponse
+      # Accounts
+      #
+      # GetAccount is an alias for GetAccountAtLatestBlock.
+      #
+      # Warning: this function is deprecated. It behaves identically to
+      # GetAccountAtLatestBlock and will be removed in a future version.
+      rpc :GetAccount, ::Access::GetAccountRequest, ::Access::GetAccountResponse
+      # GetAccountAtLatestBlock gets an account by address from the latest sealed
+      # execution state.
+      rpc :GetAccountAtLatestBlock, ::Access::GetAccountAtLatestBlockRequest, ::Access::AccountResponse
+      # GetAccountAtBlockHeight gets an account by address at the given block
+      # height
+      rpc :GetAccountAtBlockHeight, ::Access::GetAccountAtBlockHeightRequest, ::Access::AccountResponse
+      # Scripts
+      #
+      # ExecuteScriptAtLatestBlock executes a read-only Cadence script against the
+      # latest sealed execution state.
+      rpc :ExecuteScriptAtLatestBlock, ::Access::ExecuteScriptAtLatestBlockRequest, ::Access::ExecuteScriptResponse
+      # ExecuteScriptAtBlockID executes a ready-only Cadence script against the
+      # execution state at the block with the given ID.
+      rpc :ExecuteScriptAtBlockID, ::Access::ExecuteScriptAtBlockIDRequest, ::Access::ExecuteScriptResponse
+      # ExecuteScriptAtBlockHeight executes a ready-only Cadence script against the
+      # execution state at the given block height.
+      rpc :ExecuteScriptAtBlockHeight, ::Access::ExecuteScriptAtBlockHeightRequest, ::Access::ExecuteScriptResponse
+      # Events
+      #
+      # GetEventsForHeightRange retrieves events emitted within the specified block
+      # range.
+      rpc :GetEventsForHeightRange, ::Access::GetEventsForHeightRangeRequest, ::Access::EventsResponse
+      # GetEventsForBlockIDs retrieves events for the specified block IDs and event
+      # type.
+      rpc :GetEventsForBlockIDs, ::Access::GetEventsForBlockIDsRequest, ::Access::EventsResponse
+      # NetworkParameters
+      #
+      # GetNetworkParameters retrieves the Flow network details
+      rpc :GetNetworkParameters, ::Access::GetNetworkParametersRequest, ::Access::GetNetworkParametersResponse
+      # ProtocolState
+      #
+      # GetLatestProtocolStateSnapshot retrieves the latest sealed protocol state
+      # snapshot. Used by Flow nodes joining the network to bootstrap a
+      # space-efficient local state.
+      rpc :GetLatestProtocolStateSnapshot, ::Access::GetLatestProtocolStateSnapshotRequest, ::Access::ProtocolStateSnapshotResponse
+    end
+
+    Stub = Service.rpc_stub_class
+  end
+end
+

data/lib/flow/entities/account_pb.rb

@@ -0,0 +1,30 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: flow/entities/account.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("flow/entities/account.proto", :syntax => :proto3) do
+    add_message "flow.entities.Account" do
+      optional :address, :bytes, 1
+      optional :balance, :uint64, 2
+      optional :code, :bytes, 3
+      repeated :keys, :message, 4, "flow.entities.AccountKey"
+      map :contracts, :string, :bytes, 5
+    end
+    add_message "flow.entities.AccountKey" do
+      optional :index, :uint32, 1
+      optional :public_key, :bytes, 2
+      optional :sign_algo, :uint32, 3
+      optional :hash_algo, :uint32, 4
+      optional :weight, :uint32, 5
+      optional :sequence_number, :uint32, 6
+      optional :revoked, :bool, 7
+    end
+  end
+end
+
+module Entities
+  Account = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.entities.Account").msgclass
+  AccountKey = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.entities.AccountKey").msgclass
+end

data/lib/flow/entities/block_header_pb.rb

@@ -0,0 +1,20 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: flow/entities/block_header.proto
+
+require 'google/protobuf'
+
+require 'google/protobuf/timestamp_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("flow/entities/block_header.proto", :syntax => :proto3) do
+    add_message "flow.entities.BlockHeader" do
+      optional :id, :bytes, 1
+      optional :parent_id, :bytes, 2
+      optional :height, :uint64, 3
+      optional :timestamp, :message, 4, "google.protobuf.Timestamp"
+    end
+  end
+end
+
+module Entities
+  BlockHeader = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.entities.BlockHeader").msgclass
+end

data/lib/flow/entities/block_pb.rb

@@ -0,0 +1,25 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: flow/entities/block.proto
+
+require 'google/protobuf'
+
+require 'google/protobuf/timestamp_pb'
+require 'flow/entities/collection_pb'
+require 'flow/entities/block_seal_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("flow/entities/block.proto", :syntax => :proto3) do
+    add_message "flow.entities.Block" do
+      optional :id, :bytes, 1
+      optional :parent_id, :bytes, 2
+      optional :height, :uint64, 3
+      optional :timestamp, :message, 4, "google.protobuf.Timestamp"
+      repeated :collection_guarantees, :message, 5, "flow.entities.CollectionGuarantee"
+      repeated :block_seals, :message, 6, "flow.entities.BlockSeal"
+      repeated :signatures, :bytes, 7
+    end
+  end
+end
+
+module Entities
+  Block = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("flow.entities.Block").msgclass
+end