libra_client 0.1.3

data/lib/libra/mnemonic.rb

@@ -0,0 +1,147 @@
+
+require 'openssl'
+require 'securerandom'
+require 'digest'
+
+module Libra
+
+    MNEMONIC_SALT_PREFIX = "LIBRA WALLET: mnemonic salt prefix$"
+    MASTER_KEY_SALT = "LIBRA WALLET: master key salt$"
+    INFO_PREFIX = "LIBRA WALLET: derived key$"
+
+    class Mnemonic
+      def self.to_seed(mnemonic, passphrase = 'LIBRA')
+        seed = OpenSSL::PKCS5.pbkdf2_hmac(
+          mnemonic, MNEMONIC_SALT_PREFIX + passphrase, 2048, 64, OpenSSL::Digest::SHA512.new
+        ) # how to support SHA3_256 in ruby?
+        seed.unpack('H*')[0].first
+      end
+
+      def self.generate(strength_bits = 256)
+        if (strength_bits % 32) > 0
+          raise ArgumentError, format(
+            'Strength should be divisible by 32, but it is not (%<strength_bits>d)',
+            strength_bits: strength_bits
+          )
+        end
+        data = SecureRandom.random_bytes((strength_bits / 8).floor)
+        to_mnemonic(data)
+      end
+
+      def self.wordlist
+        @wordlist ||= nil
+        return @wordlist if @wordlist
+        @wordlist = WORDLIST_ENGLISH.split(/[ \n]/).map(&:strip).reject(&:empty?)
+        if @wordlist.size != (radix = 2048)
+          raise ArgumentError, format(
+            'Wordlist should contain %<radix>d words, but it contains %<count>d words.',
+            radix: radix, count: wordlist.size
+          )
+        end
+        @wordlist
+      end
+
+      def self.to_mnemonic(data)
+        if (data.bytesize % 4) > 0
+          raise ArgumentError, format(
+            'Data length in bits should be divisible by 32, ' \
+            'but it is not (%<count>d bytes = %<bits_count>d bits).',
+            count: data.bytesize, bits_count: data.bytesize * 8
+          )
+        end
+        b = data.unpack('B*')[0] +
+            Digest::SHA256.digest(data).unpack('B*')[0]
+                          .ljust(256, '0')[0...(data.bytesize * 8 / 32)]
+
+        (0...(b.bytesize / 11)).map do |i|
+          idx = b[(i * 11)...((i + 1) * 11)].to_i(2)
+          wordlist[idx]
+        end.join(' ')
+      end
+
+      WORDLIST_ENGLISH = <<-TEXT.freeze
+        abandon ability able about above absent absorb abstract absurd abuse access accident account accuse achieve acid acoustic acquire across act action actor actress actual adapt
+        add addict address adjust admit adult advance advice aerobic affair afford afraid again age agent agree ahead aim air airport aisle alarm album alcohol alert
+        alien all alley allow almost alone alpha already also alter always amateur amazing among amount amused analyst anchor ancient anger angle angry animal ankle announce
+        annual another answer antenna antique anxiety any apart apology appear apple approve april arch arctic area arena argue arm armed armor army around arrange arrest
+        arrive arrow art artefact artist artwork ask aspect assault asset assist assume asthma athlete atom attack attend attitude attract auction audit august aunt author auto
+        autumn average avocado avoid awake aware away awesome awful awkward axis baby bachelor bacon badge bag balance balcony ball bamboo banana banner bar barely bargain
+        barrel base basic basket battle beach bean beauty because become beef before begin behave behind believe below belt bench benefit best betray better between beyond
+        bicycle bid bike bind biology bird birth bitter black blade blame blanket blast bleak bless blind blood blossom blouse blue blur blush board boat body
+        boil bomb bone bonus book boost border boring borrow boss bottom bounce box boy bracket brain brand brass brave bread breeze brick bridge brief bright
+        bring brisk broccoli broken bronze broom brother brown brush bubble buddy budget buffalo build bulb bulk bullet bundle bunker burden burger burst bus business busy
+        butter buyer buzz cabbage cabin cable cactus cage cake call calm camera camp can canal cancel candy cannon canoe canvas canyon capable capital captain car
+        carbon card cargo carpet carry cart case cash casino castle casual cat catalog catch category cattle caught cause caution cave ceiling celery cement census century
+        cereal certain chair chalk champion change chaos chapter charge chase chat cheap check cheese chef cherry chest chicken chief child chimney choice choose chronic chuckle
+        chunk churn cigar cinnamon circle citizen city civil claim clap clarify claw clay clean clerk clever click client cliff climb clinic clip clock clog close
+        cloth cloud clown club clump cluster clutch coach coast coconut code coffee coil coin collect color column combine come comfort comic common company concert conduct
+        confirm congress connect consider control convince cook cool copper copy coral core corn correct cost cotton couch country couple course cousin cover coyote crack cradle
+        craft cram crane crash crater crawl crazy cream credit creek crew cricket crime crisp critic crop cross crouch crowd crucial cruel cruise crumble crunch crush
+        cry crystal cube culture cup cupboard curious current curtain curve cushion custom cute cycle dad damage damp dance danger daring dash daughter dawn day deal
+        debate debris decade december decide decline decorate decrease deer defense define defy degree delay deliver demand demise denial dentist deny depart depend deposit depth deputy
+        derive describe desert design desk despair destroy detail detect develop device devote diagram dial diamond diary dice diesel diet differ digital dignity dilemma dinner dinosaur
+        direct dirt disagree discover disease dish dismiss disorder display distance divert divide divorce dizzy doctor document dog doll dolphin domain donate donkey donor door dose
+        double dove draft dragon drama drastic draw dream dress drift drill drink drip drive drop drum dry duck dumb dune during dust dutch duty dwarf
+        dynamic eager eagle early earn earth easily east easy echo ecology economy edge edit educate effort egg eight either elbow elder electric elegant element elephant
+        elevator elite else embark embody embrace emerge emotion employ empower empty enable enact end endless endorse enemy energy enforce engage engine enhance enjoy enlist enough
+        enrich enroll ensure enter entire entry envelope episode equal equip era erase erode erosion error erupt escape essay essence estate eternal ethics evidence evil evoke
+        evolve exact example excess exchange excite exclude excuse execute exercise exhaust exhibit exile exist exit exotic expand expect expire explain expose express extend extra eye
+        eyebrow fabric face faculty fade faint faith fall false fame family famous fan fancy fantasy farm fashion fat fatal father fatigue fault favorite feature february
+        federal fee feed feel female fence festival fetch fever few fiber fiction field figure file film filter final find fine finger finish fire firm first
+        fiscal fish fit fitness fix flag flame flash flat flavor flee flight flip float flock floor flower fluid flush fly foam focus fog foil fold
+        follow food foot force forest forget fork fortune forum forward fossil foster found fox fragile frame frequent fresh friend fringe frog front frost frown frozen
+        fruit fuel fun funny furnace fury future gadget gain galaxy gallery game gap garage garbage garden garlic garment gas gasp gate gather gauge gaze general
+        genius genre gentle genuine gesture ghost giant gift giggle ginger giraffe girl give glad glance glare glass glide glimpse globe gloom glory glove glow glue
+        goat goddess gold good goose gorilla gospel gossip govern gown grab grace grain grant grape grass gravity great green grid grief grit grocery group grow
+        grunt guard guess guide guilt guitar gun gym habit hair half hammer hamster hand happy harbor hard harsh harvest hat have hawk hazard head health
+        heart heavy hedgehog height hello helmet help hen hero hidden high hill hint hip hire history hobby hockey hold hole holiday hollow home honey hood
+        hope horn horror horse hospital host hotel hour hover hub huge human humble humor hundred hungry hunt hurdle hurry hurt husband hybrid ice icon idea
+        identify idle ignore ill illegal illness image imitate immense immune impact impose improve impulse inch include income increase index indicate indoor industry infant inflict inform
+        inhale inherit initial inject injury inmate inner innocent input inquiry insane insect inside inspire install intact interest into invest invite involve iron island isolate issue
+        item ivory jacket jaguar jar jazz jealous jeans jelly jewel job join joke journey joy judge juice jump jungle junior junk just kangaroo keen keep
+        ketchup key kick kid kidney kind kingdom kiss kit kitchen kite kitten kiwi knee knife knock know lab label labor ladder lady lake lamp language
+        laptop large later latin laugh laundry lava law lawn lawsuit layer lazy leader leaf learn leave lecture left leg legal legend leisure lemon lend length
+        lens leopard lesson letter level liar liberty library license life lift light like limb limit link lion liquid list little live lizard load loan lobster
+        local lock logic lonely long loop lottery loud lounge love loyal lucky luggage lumber lunar lunch luxury lyrics machine mad magic magnet maid mail main
+        major make mammal man manage mandate mango mansion manual maple marble march margin marine market marriage mask mass master match material math matrix matter maximum
+        maze meadow mean measure meat mechanic medal media melody melt member memory mention menu mercy merge merit merry mesh message metal method middle midnight milk
+        million mimic mind minimum minor minute miracle mirror misery miss mistake mix mixed mixture mobile model modify mom moment monitor monkey monster month moon moral
+        more morning mosquito mother motion motor mountain mouse move movie much muffin mule multiply muscle museum mushroom music must mutual myself mystery myth naive name
+        napkin narrow nasty nation nature near neck need negative neglect neither nephew nerve nest net network neutral never news next nice night noble noise nominee
+        noodle normal north nose notable note nothing notice novel now nuclear number nurse nut oak obey object oblige obscure observe obtain obvious occur ocean october
+        odor off offer office often oil okay old olive olympic omit once one onion online only open opera opinion oppose option orange orbit orchard order
+        ordinary organ orient original orphan ostrich other outdoor outer output outside oval oven over own owner oxygen oyster ozone pact paddle page pair palace palm
+        panda panel panic panther paper parade parent park parrot party pass patch path patient patrol pattern pause pave payment peace peanut pear peasant pelican pen
+        penalty pencil people pepper perfect permit person pet phone photo phrase physical piano picnic picture piece pig pigeon pill pilot pink pioneer pipe pistol pitch
+        pizza place planet plastic plate play please pledge pluck plug plunge poem poet point polar pole police pond pony pool popular portion position possible post
+        potato pottery poverty powder power practice praise predict prefer prepare present pretty prevent price pride primary print priority prison private prize problem process produce profit
+        program project promote proof property prosper protect proud provide public pudding pull pulp pulse pumpkin punch pupil puppy purchase purity purpose purse push put puzzle
+        pyramid quality quantum quarter question quick quit quiz quote rabbit raccoon race rack radar radio rail rain raise rally ramp ranch random range rapid rare
+        rate rather raven raw razor ready real reason rebel rebuild recall receive recipe record recycle reduce reflect reform refuse region regret regular reject relax release
+        relief rely remain remember remind remove render renew rent reopen repair repeat replace report require rescue resemble resist resource response result retire retreat return reunion
+        reveal review reward rhythm rib ribbon rice rich ride ridge rifle right rigid ring riot ripple risk ritual rival river road roast robot robust rocket
+        romance roof rookie room rose rotate rough round route royal rubber rude rug rule run runway rural sad saddle sadness safe sail salad salmon salon
+        salt salute same sample sand satisfy satoshi sauce sausage save say scale scan scare scatter scene scheme school science scissors scorpion scout scrap screen script
+        scrub sea search season seat second secret section security seed seek segment select sell seminar senior sense sentence series service session settle setup seven shadow
+        shaft shallow share shed shell sheriff shield shift shine ship shiver shock shoe shoot shop short shoulder shove shrimp shrug shuffle shy sibling sick side
+        siege sight sign silent silk silly silver similar simple since sing siren sister situate six size skate sketch ski skill skin skirt skull slab slam
+        sleep slender slice slide slight slim slogan slot slow slush small smart smile smoke smooth snack snake snap sniff snow soap soccer social sock soda
+        soft solar soldier solid solution solve someone song soon sorry sort soul sound soup source south space spare spatial spawn speak special speed spell spend
+        sphere spice spider spike spin spirit split spoil sponsor spoon sport spot spray spread spring spy square squeeze squirrel stable stadium staff stage stairs stamp
+        stand start state stay steak steel stem step stereo stick still sting stock stomach stone stool story stove strategy street strike strong struggle student stuff
+        stumble style subject submit subway success such sudden suffer sugar suggest suit summer sun sunny sunset super supply supreme sure surface surge surprise surround survey
+        suspect sustain swallow swamp swap swarm swear sweet swift swim swing switch sword symbol symptom syrup system table tackle tag tail talent talk tank tape
+        target task taste tattoo taxi teach team tell ten tenant tennis tent term test text thank that theme then theory there they thing this thought
+        three thrive throw thumb thunder ticket tide tiger tilt timber time tiny tip tired tissue title toast tobacco today toddler toe together toilet token tomato
+        tomorrow tone tongue tonight tool tooth top topic topple torch tornado tortoise toss total tourist toward tower town toy track trade traffic tragic train transfer
+        trap trash travel tray treat tree trend trial tribe trick trigger trim trip trophy trouble truck true truly trumpet trust truth try tube tuition tumble
+        tuna tunnel turkey turn turtle twelve twenty twice twin twist two type typical ugly umbrella unable unaware uncle uncover under undo unfair unfold unhappy uniform
+        unique unit universe unknown unlock until unusual unveil update upgrade uphold upon upper upset urban urge usage use used useful useless usual utility vacant vacuum
+        vague valid valley valve van vanish vapor various vast vault vehicle velvet vendor venture venue verb verify version very vessel veteran viable vibrant vicious victory
+        video view village vintage violin virtual virus visa visit visual vital vivid vocal voice void volcano volume vote voyage wage wagon wait walk wall walnut
+        want warfare warm warrior wash wasp waste water wave way wealth weapon wear weasel weather web wedding weekend weird welcome west wet whale what wheat
+        wheel when where whip whisper wide width wife wild will win window wine wing wink winner winter wire wisdom wise wish witness wolf woman wonder
+        wood wool word work world worry worth wrap wreck wrestle wrist write wrong yard year yellow you young youth zebra zero zone zoo
+      TEXT
+    end
+end

data/lib/libra/version.rb

@@ -0,0 +1,3 @@
+module Libra
+  VERSION = "0.1.3"
+end

data/lib/libra_client.rb

@@ -0,0 +1,173 @@
+protolib = File.expand_path(File.dirname(__FILE__) + '/../proto-lib')
+$LOAD_PATH.unshift(protolib) if File.directory?(protolib) && !$LOAD_PATH.include?(protolib)
+
+require 'grpc'
+require 'admission_control_services_pb'
+require 'canoser'
+require 'rest_client'
+
+require "libra/version"
+require 'libra/account_address'
+require 'libra/account_config'
+require 'libra/access_path'
+require 'libra/account_resource'
+require 'libra/mnemonic'
+
+
+module Libra
+  class LibraError < StandardError; end
+
+  module  BinaryExtensions
+    # bin-to-hex
+    def bin2hex; unpack("H*")[0]; end
+    # hex-to-bin
+    def hex2bin; [self].pack("H*"); end
+  end
+
+  class ::String
+    include Libra::BinaryExtensions
+  end
+
+  NETWORKS = {
+	testnet:{
+		host: "ac.testnet.libra.org:8000",
+		faucet_host: "faucet.testnet.libra.org"
+	}
+  }
+
+
+  class Client
+
+  	def initialize(network="testnet")
+  		raise LibraError.new("only support testnet now.") unless network.to_s == "testnet"
+  		@host = NETWORKS[network.to_sym][:host]
+  		@faucet_host = NETWORKS[network.to_sym][:faucet_host]
+  	end
+
+    def get_latest_transaction_version
+      stub = AdmissionControl::AdmissionControl::Stub.new(@host,:this_channel_is_insecure)
+      resp = stub.update_to_latest_ledger(Types::UpdateToLatestLedgerRequest.new())
+      resp.ledger_info_with_sigs.ledger_info.version
+    end
+
+    def update_to_latest_ledger(requested_items)
+      request = Types::UpdateToLatestLedgerRequest.new(client_known_version: 0, requested_items: requested_items)
+      stub = AdmissionControl::AdmissionControl::Stub.new(@host,:this_channel_is_insecure)
+      response = stub.update_to_latest_ledger(request)
+      # [:response_items, :ledger_info_with_sigs, :validator_change_events]
+      response
+    end
+
+    def get_sequence_number(address)
+      state = get_account_state(address)
+      state.sequence_number
+    end
+
+    def get_balance(address)
+      state = get_account_state(address)
+      state.balance
+    end
+
+    def get_account_state(address)
+      query = Types::GetAccountStateRequest.new(address: AccountAddress.hex_to_bytes(address))
+      item = Types::RequestItem.new(get_account_state_request: query)
+      resp = update_to_latest_ledger([item])
+      state = resp.response_items[0].get_account_state_response.account_state_with_proof
+      map = Libra::AccountState.deserialize(state.blob.blob).blob
+      resource = map[AccountConfig::ACCOUNT_RESOURCE_PATH]
+      Libra::AccountResource.deserialize(resource.pack('C*'))
+    end
+
+    def get_transactions(start_version, limit=1, fetch_events=false)
+      query = Types::GetTransactionsRequest.new(start_version: start_version, limit: limit, fetch_events: fetch_events)
+      item = Types::RequestItem.new(get_transactions_request: query)
+      resp = update_to_latest_ledger([item])
+      txn_list_with_proof = resp.response_items[0].get_transactions_response.txn_list_with_proof
+      #[:transactions, :infos, :events_for_versions, :first_transaction_version, :proof_of_first_transaction, :proof_of_last_transaction]
+      txn_list_with_proof.transactions
+    end
+
+    def get_transaction(start_version)
+      #Types::SignedTransaction [:raw_txn_bytes, :sender_public_key, :sender_signature]
+      get_transactions(start_version)[0]
+    end
+
+    def get_account_transaction(address, sequence_number, fetch_events=true)
+      addr = AccountAddress.hex_to_bytes(address)
+      query = Types::GetAccountTransactionBySequenceNumberRequest.new(account: addr, sequence_number: sequence_number, fetch_events: fetch_events)
+      item = Types::RequestItem.new(get_account_transaction_by_sequence_number_request: query)
+      resp = update_to_latest_ledger([item])
+      transaction = resp.response_items[0].get_account_transaction_by_sequence_number_response.signed_transaction_with_proof
+      #Types::SignedTransactionWithProof [:version, :signed_transaction, :proof, :events]
+      transaction
+    end
+
+    # Returns events specified by `access_path` with sequence number in range designated by
+    # `start_seq_num`, `ascending` and `limit`. If ascending is true this query will return up to
+    # `limit` events that were emitted after `start_event_seq_num`. Otherwise it will return up to
+    # `limit` events in the reverse order. Both cases are inclusive.
+    def get_events(address_hex, path, start_sequence_number, ascending=true, limit=1)
+      access_path = AccessPath.new(address_hex, path).to_proto
+      query = Types::GetEventsByEventAccessPathRequest.new(access_path: access_path, start_event_seq_num: start_sequence_number, ascending: ascending, limit: limit)
+      item = Types::RequestItem.new(get_events_by_event_access_path_request: query)
+      resp = update_to_latest_ledger([item])
+      resp.response_items[0].get_events_by_event_access_path_response.events_with_proof
+    end
+
+    def get_events_sent(address_hex, start_sequence_number, ascending=true, limit=1)
+      path = AccountConfig.account_sent_event_path
+      get_events(address_hex, path, start_sequence_number, ascending, limit)
+    end
+
+    def get_events_received(address_hex, start_sequence_number, ascending=true, limit=1)
+      path = AccountConfig.account_received_event_path
+      get_events(address_hex, path, start_sequence_number, ascending, limit)
+    end
+
+    def get_latest_events_sent(address_hex, limit=1)
+      get_events_sent(address_hex, 2**64-1, false, limit)
+    end
+
+    def get_latest_events_received(address_hex, limit=1)
+      get_events_received(address_hex, 2**64-1, false, limit)
+    end
+
+    def mint_coins_with_local_faucet_account
+    end
+
+    def mint_coins_with_faucet_service(receiver, num_coins, is_blocking)
+      resp = RestClient.post "http://#{@faucet_host}?amount=#{num_coins}&address=#{receiver}", {}
+      if resp.code != 200
+        raise LibraError.new("Failed to query remote faucet server[status=#{resp.code}]: #{resp.body}")
+      end
+      sequence_number = resp.body.to_i
+      if is_blocking
+        puts AccountConfig.association_address.hex
+        self.wait_for_transaction(AccountConfig.association_address.hex, sequence_number);
+      end
+    end
+
+    def wait_for_transaction(account, sequence_number)
+      max_iterations = 500
+      puts("waiting ")
+      while (max_iterations > 0 )do
+        $stdout.flush
+        max_iterations -= 1;
+        transaction = get_account_transaction(account, sequence_number - 1, true)
+        if transaction && transaction.events
+          puts "transaction is stored!"
+          if transaction.events.events.size == 0
+            puts "no events emitted"
+          end
+          return
+        else
+          print(".")
+          sleep(0.01)
+        end
+      end
+      puts "wait_for_transaction timeout"
+    end
+
+  end
+
+end

data/libra_client.gemspec

@@ -0,0 +1,49 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "libra/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "libra_client"
+  spec.version       = Libra::VERSION
+  spec.authors       = ["yuan xinyu"]
+  spec.email         = ["yuanxinyu.hangzhou@gmail.com"]
+
+  spec.summary       = %q{A ruby client for Libra network.}
+  spec.description   = %q{A ruby client for Libra network.}
+  spec.homepage      = "https://github.com/yuanxinyu/libra_client.git"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/yuanxinyu/libra_client.git"
+    spec.metadata["changelog_uri"] = "https://github.com/yuanxinyu/libra_client.git"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # 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('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "byebug", "~> 11.0"
+
+  spec.add_dependency "grpc", "~> 1.23"
+  spec.add_dependency "canoser", "~> 0.1.2"
+  spec.add_dependency "rest-client", "~> 2.0"
+  #spec.add_dependency "openssl", "~> 3.0.0" #not ready, need SHA3 support.
+
+end

data/libra_client.sublime-project

@@ -0,0 +1,16 @@
+{
+  "folders":
+  [
+    {
+      "path": ".",
+      "folder_exclude_patterns": [".bundle",".idea","certs","coverage","tmp","log","pkg"],
+      "file_exclude_patterns": ["*.sublime-workspace","*.sqlite3","spec/examples.txt",".byebug_history",".DS_Store"]
+    }
+  ],
+  "settings":
+  {
+    "translate_tabs_to_spaces": true,
+    "trim_trailing_white_space_on_save": true,
+    "tab_size": 2
+  }
+}

data/proto-lib/access_path_pb.rb

@@ -0,0 +1,17 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: access_path.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("access_path.proto", :syntax => :proto3) do
+    add_message "types.AccessPath" do
+      optional :address, :bytes, 1
+      optional :path, :bytes, 2
+    end
+  end
+end
+
+module Types
+  AccessPath = Google::Protobuf::DescriptorPool.generated_pool.lookup("types.AccessPath").msgclass
+end

data/proto-lib/account_state_blob_pb.rb

@@ -0,0 +1,23 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: account_state_blob.proto
+
+require 'google/protobuf'
+
+require 'proof_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("account_state_blob.proto", :syntax => :proto3) do
+    add_message "types.AccountStateBlob" do
+      optional :blob, :bytes, 1
+    end
+    add_message "types.AccountStateWithProof" do
+      optional :version, :uint64, 1
+      optional :blob, :message, 2, "types.AccountStateBlob"
+      optional :proof, :message, 3, "types.AccountStateProof"
+    end
+  end
+end
+
+module Types
+  AccountStateBlob = Google::Protobuf::DescriptorPool.generated_pool.lookup("types.AccountStateBlob").msgclass
+  AccountStateWithProof = Google::Protobuf::DescriptorPool.generated_pool.lookup("types.AccountStateWithProof").msgclass
+end

data/proto-lib/admission_control_pb.rb

@@ -0,0 +1,37 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: admission_control.proto
+
+require 'google/protobuf'
+
+require 'get_with_proof_pb'
+require 'transaction_pb'
+require 'proof_pb'
+require 'ledger_info_pb'
+require 'vm_errors_pb'
+require 'mempool_status_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("admission_control.proto", :syntax => :proto3) do
+    add_message "admission_control.SubmitTransactionRequest" do
+      optional :signed_txn, :message, 1, "types.SignedTransaction"
+    end
+    add_message "admission_control.SubmitTransactionResponse" do
+      optional :validator_id, :bytes, 4
+      oneof :status do
+        optional :vm_status, :message, 1, "types.VMStatus"
+        optional :ac_status, :enum, 2, "admission_control.AdmissionControlStatus"
+        optional :mempool_status, :enum, 3, "mempool.MempoolAddTransactionStatus"
+      end
+    end
+    add_enum "admission_control.AdmissionControlStatus" do
+      value :Accepted, 0
+      value :Blacklisted, 1
+      value :Rejected, 2
+    end
+  end
+end
+
+module AdmissionControl
+  SubmitTransactionRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("admission_control.SubmitTransactionRequest").msgclass
+  SubmitTransactionResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("admission_control.SubmitTransactionResponse").msgclass
+  AdmissionControlStatus = Google::Protobuf::DescriptorPool.generated_pool.lookup("admission_control.AdmissionControlStatus").enummodule
+end