stellar_core_commander 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 57e0dc80ca8af0d8ffb64901553182956be06de4
+  data.tar.gz: 47674fda6cbb673d5be6642d5b291093fa5de240
+SHA512:
+  metadata.gz: 3dac295ce242278729cc17c41e9b20942bc5343a34062518c845a82d0753f6c5839775ef17f486232ab4231c165d74c8ee57dd18b4fb7579e68d44d9d5560408
+  data.tar.gz: de5bdb018fb12c3275791a521f277217382f728f58231f5a822feb2e517bba0afb688d2c5b3dcc8d35be705c908fd6d437bccb07f5b83a92f9f6959fb6558bb1

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+out.sql

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+gemspec
+
+# gem 'stellar-base', path: "~/src/stellar/ruby-stellar-base"
+# gem 'xdr', path: "~/src/stellar/ruby-xdr"# 

data/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2015] [Stellar Development Foundation]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,70 @@
+# StellarCoreCommander
+
+A helper gem for scripting a [stellar-core](https://github.com/stellar/stellar-core).  This gem provides a system of creating isolated test networks into which you can play
+transactions and record results.
+
+The motivation for this project comes from the testing needs of [horizon](https://github.com/stellar/horizon).  Horizon uses `scc` to record the various testing scenarios that its suite uses.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'stellar_core_commander'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stellar_core_commander
+
+## Usage As Command Line Tool
+
+Installing `stellar_core_commander` installs the command line tool `scc`. `scc`
+takes a recipe file, spins up a test network, plays the defined transactions against it, then dumps the ledger database to stdout.  `scc`'s usage is like so:
+
+```bash
+$ scc -r my_recipe.rb > out.sql
+```
+
+The above command will play the recipe written in `my_recipe.rb`, verify that all transactions within the recipe have succeeded, then dump the ledger database to `out.sql`
+
+## Usage as a Library
+
+TODO
+
+## Writing Recipes
+
+The heart of `scc` is a recipe, which is just a ruby script that executes in a context
+that makes it easy to play transactions against the isolated test network.  Lets look at a simple recipe:
+
+```ruby
+account :scott
+payment :master, :scott, [:native, 1000_000000]
+```
+
+Let's look at each statement in turn. `account :scott` declares a new unfunded account and binds it to the name `:scott`, which we will use in the next statement.  
+
+The next statement is more complex: `payment :master, :scott, [:native, 1000_000000]`.  This statement encodes "Send 1000 lumens from the :master account to the :scott account".
+
+`:master` (sometimes also called the "root" account) is a special account that is created when a new ledger is initialized.  We often use it in our recipes to fund other accounts, since in a ledgers initial state the :master account has all 100 billion lumen.
+
+### Recipe Reference
+
+All recipe execute within the context of a `StellarCoreCommander::Transactor`.  [See the code for all available methods](lib/stellar_core_commander/transactor.rb).
+
+## Example Recipes
+
+See [examples](examples).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/stellar_core_commander/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/scc

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'stellar_core_commander'
+require 'slop'
+
+def run
+  $opts = Slop.parse do
+    banner 'Usage: scc -r RECIPE'
+    
+    on 'stellar-core-bin', 'a path to a stellar-core executable (default to `which stellar-core`)', argument: true
+    on 'r', 'recipe', 'a recipe file', argument: true #, required: true
+  end
+
+  recipe    = load_recipe
+  commander = make_commander
+  process   = commander.make_process
+
+  #run recipe
+  transactor = StellarCoreCommander::Transactor.new(process)
+  process.run
+  process.wait_for_ready
+  transactor.run_recipe recipe
+  transactor.close_ledger
+
+  output_results(process)
+end
+
+
+def make_commander
+  stellar_core_bin = $opts[:"stellar-core-bin"]
+
+  if stellar_core_bin.blank?
+    search = `which stellar-core`.strip
+
+    if $?.success?
+      stellar_core_bin = search
+    else
+      $stderr.puts "Could not find a `stellar-core` binary, please use --stellar-core-bin to specify"
+      exit 1
+    end
+  end
+
+  StellarCoreCommander::Commander.new(stellar_core_bin).tap do |c|
+    c.cleanup_at_exit!
+  end
+end
+
+def load_recipe
+  recipe = $opts[:recipe]
+
+  if recipe.blank?
+    $stderr.puts $opts
+    exit 1
+  end
+
+  unless File.exist?(recipe)
+    $stderr.puts "not found: #{recipe}"
+    exit 1
+  end
+
+  recipe
+end
+
+def output_results(process)
+  $stdout.puts process.dump_database
+end
+
+run
+
+ 

data/examples/non_native_payment.rb

@@ -0,0 +1,20 @@
+account :usd_gateway
+account :scott
+account :andrew
+
+payment :master, :usd_gateway, [:native, 1000_000000]
+payment :master, :scott, [:native, 1000_000000]
+payment :master, :andrew, [:native, 1000_000000]
+
+close_ledger
+
+trust :scott,  :usd_gateway, "USD"
+trust :andrew, :usd_gateway, "USD"
+
+close_ledger
+
+payment :usd_gateway, :scott,  ["USD", :usd_gateway, 1000_000000]
+
+close_ledger
+
+payment :scott, :andrew, ["USD", :usd_gateway, 500_000000]

data/examples/pathed_payment.rb

@@ -0,0 +1,34 @@
+account :usd_gateway
+account :eur_gateway
+account :scott
+account :bartek
+account :andrew
+
+payment :master, :usd_gateway, [:native, 1000_000000]
+payment :master, :eur_gateway, [:native, 1000_000000]
+
+payment :master, :scott, [:native, 1000_000000]
+payment :master, :bartek, [:native, 1000_000000]
+payment :master, :andrew, [:native, 1000_000000]
+
+close_ledger
+
+trust :scott,  :usd_gateway, "USD"
+trust :bartek, :eur_gateway, "EUR"
+trust :andrew, :usd_gateway, "USD"
+trust :andrew, :eur_gateway, "EUR"
+
+close_ledger
+
+payment :usd_gateway, :scott,  ["USD", :usd_gateway, 1000_000000]
+payment :usd_gateway, :andrew, ["USD", :usd_gateway, 200_000000]
+payment :eur_gateway, :andrew, ["EUR", :eur_gateway, 200_000000]
+payment :eur_gateway, :bartek, ["EUR", :eur_gateway, 1000_000000]
+
+close_ledger
+
+offer :offer_1, :andrew, ["EUR", :eur_gateway], ["USD", :usd_gateway], 200_000000, 1.0
+
+close_ledger
+
+payment :scott, :bartek, ["EUR", :eur_gateway, 10], path: [["USD", :usd_gateway], ["EUR", :eur_gateway]]

data/examples/simple_payment.rb

@@ -0,0 +1,3 @@
+account :scott
+
+payment :master, :scott, [:native, 1000_000000]

data/lib/stellar_core_commander/commander.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+module StellarCoreCommander
+  class Commander
+    include Contracts
+
+    # 
+    # Creates a new core commander
+    # 
+    Contract String => Any
+    def initialize(stellar_core_bin)
+      @stellar_core_bin = stellar_core_bin
+      raise "no file at #{stellar_core_bin}" unless File.exist?(stellar_core_bin)
+
+      @processes = []
+    end
+
+    Contract None => Process
+    def make_process
+      tmpdir        = Dir.mktmpdir
+      identity      = Stellar::KeyPair.random
+      base_port     = 39132
+
+      FileUtils.cp(@stellar_core_bin, "#{tmpdir}/stellar-core")
+      Process.new(tmpdir, base_port, identity).tap do |p|
+        p.setup
+        @processes << p
+      end
+    end
+
+    def cleanup
+      @processes.each(&:cleanup)
+    end
+
+    def cleanup_at_exit!
+      at_exit do
+        $stderr.puts "cleaning up #{@processes.length} processes"
+        cleanup
+      end
+    end
+
+  end
+end

data/lib/stellar_core_commander/convert.rb

@@ -0,0 +1,30 @@
+module StellarCoreCommander
+  # 
+  # Generic format conversion module
+  # 
+  module Convert
+    require 'base64'
+
+    def to_hex(string)
+      string.unpack("H*").first
+    end
+
+    def from_hex(hex_string)
+      [hex_string].pack("H*")
+    end
+
+    def to_base64(string)
+      Base64.strict_encode64(string)
+    end
+
+    def from_base64(base64_string)
+      Base64.strict_decode64(base64_string)
+    end
+
+    def base58
+      Stellar::Util::Base58.stellar
+    end
+
+    extend self
+  end
+end

data/lib/stellar_core_commander/process.rb

@@ -0,0 +1,272 @@
+module StellarCoreCommander
+
+  class Process
+    include Contracts
+
+    attr_reader :working_dir
+    attr_reader :base_port
+    attr_reader :identity
+    attr_reader :pid
+    attr_reader :wait
+
+    def initialize(working_dir, base_port, identity)
+      @working_dir = working_dir
+      @base_port   = base_port
+      @identity    = identity
+
+      @server = Faraday.new(url: "http://127.0.0.1:#{http_port}") do |conn|
+        conn.request :url_encoded
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    Contract None => Any
+    def forcescp
+      run_cmd "./stellar-core", ["--forcescp"]
+      raise "Could not set --forcescp" unless $?.success?
+    end
+
+    Contract None => Any
+    def initialize_history
+      run_cmd "./stellar-core", ["--newhist", "main"]
+      raise "Could not initialize history" unless $?.success?
+    end
+
+    Contract None => Any
+    def initialize_database
+      run_cmd "./stellar-core", ["--newdb"]
+      raise "Could not initialize db" unless $?.success?
+    end
+
+    Contract None => Any
+    def create_database
+      run_cmd "createdb", [database_name]
+      raise "Could not create db: #{database_name}" unless $?.success?
+    end
+
+    Contract None => Any
+    def drop_database
+      run_cmd "dropdb", [database_name]
+      raise "Could not drop db: #{database_name}" unless $?.success?
+    end
+
+    Contract None => Any
+    def write_config
+      IO.write("#{@working_dir}/stellar-core.cfg", config)
+    end
+
+    Contract None => Any
+    def rm_working_dir
+      FileUtils.rm_rf @working_dir
+    end
+
+    Contract None => Any
+    def setup
+      write_config
+      create_database
+      initialize_history
+      initialize_database
+    end
+
+    Contract None => Num
+    def run
+      raise "already running!" if running?
+
+      forcescp
+      launch_stellar_core
+    end
+
+
+    Contract None => Any
+    def wait_for_ready
+      loop do
+
+        response = @server.get("/info") rescue false
+
+        if response
+          body = ActiveSupport::JSON.decode(response.body)
+
+          break if body["info"]["state"] == "Synced!"
+        end
+
+        $stderr.puts "waiting until stellar-core is synced"
+        sleep 1
+      end
+    end
+
+    Contract None => Bool
+    def running?
+      return false unless @pid
+      ::Process.kill 0, @pid
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    Contract Bool => Bool
+    def shutdown(graceful=true)
+      return true if !running?
+
+      if graceful
+        ::Process.kill "INT", @pid
+      else
+        ::Process.kill "KILL", @pid
+      end
+
+      @wait.value.success?
+    end
+
+    Contract None => Bool
+    def close_ledger
+      prev_ledger = latest_ledger
+      next_ledger = prev_ledger + 1
+
+      @server.get("manualclose")
+
+      Timeout.timeout(5.0) do 
+        loop do
+          current_ledger = latest_ledger
+
+          case
+          when current_ledger == next_ledger
+            break
+          when current_ledger > next_ledger
+            raise "whoa! we jumped two ledgers, from #{prev_ledger} to #{current_ledger}"
+          else
+            $stderr.puts "waiting for ledger #{next_ledger}"
+            sleep 0.5
+          end
+        end
+      end
+
+      true
+    end
+
+    Contract String => Stellar::TransactionResult
+    def submit_transaction(envelope_hex)
+      response = @server.get("tx", blob: envelope_hex)
+      body = ActiveSupport::JSON.decode(response.body)
+
+      unless body["wasReceived"] == true
+        raise "transaction failed: #{body["result"]}"
+      end
+
+      hex_tr = body["result"]
+      raw_tr = Convert.from_hex(hex_tr)
+      Stellar::TransactionResult.from_xdr(raw_tr)
+    end
+
+
+    Contract Stellar::KeyPair => Num
+    def sequence_for(account)
+      row = database[:accounts].where(:accountid => account.address).first
+      row[:seqnum]
+    end
+
+
+    Contract None => Num
+    def latest_ledger
+      database[:ledgerheaders].max(:ledgerseq)
+    end
+
+    Contract String => String
+    def transaction_result(hex_hash)
+      row = database[:txhistory].where(txid:hex_hash).first
+      row[:txresult]
+    end
+
+    Contract None => Any
+    def cleanup
+      database.disconnect
+      shutdown
+      drop_database
+      rm_working_dir
+    end
+
+    Contract None => Any
+    def dump_database
+      Dir.chdir(@working_dir) do
+        `pg_dump #{database_name} --clean --no-owner`
+      end
+    end
+
+
+    Contract None => Sequel::Database
+    def database
+      @database ||= Sequel.postgres(database_name)
+    end
+
+    Contract None => String
+    def database_name
+      "stellar_core_tmp_#{basename}"
+    end
+
+    Contract None => String
+    def dsn
+      "postgresql://dbname=#{database_name}"
+    end
+
+    Contract None => Num
+    def http_port
+      @base_port
+    end
+
+    Contract None => Num
+    def peer_port
+      @base_port + 1
+    end
+
+    private
+    Contract None => String
+    def basename
+      File.basename(@working_dir)
+    end
+
+    Contract String, ArrayOf[String] => Maybe[Bool]
+    def run_cmd(cmd, args)
+      args += [{
+          out: "stellar-core.log", 
+          err: "stellar-core.log",
+        }]
+
+      Dir.chdir @working_dir do
+        system(cmd, *args)
+      end
+    end
+
+    def launch_stellar_core
+      Dir.chdir @working_dir do
+        sin, sout, serr, wait = Open3.popen3("./stellar-core")
+
+        # throwaway stdout, stderr (the logs will record any output)
+        Thread.new{ until (line = sout.gets).nil? ; end }
+        Thread.new{ until (line = serr.gets).nil? ; end }
+
+        @wait = wait
+        @pid = wait.pid
+      end
+    end
+
+    Contract None => String
+    def config
+      <<-EOS.strip_heredoc
+        MANUAL_CLOSE=true
+        PEER_PORT=#{peer_port}
+        RUN_STANDALONE=false
+        HTTP_PORT=#{http_port}
+        PUBLIC_HTTP_PORT=false
+        PEER_SEED="#{@identity.seed}"
+        VALIDATION_SEED="#{@identity.seed}"
+        QUORUM_THRESHOLD=1
+        QUORUM_SET=["#{@identity.address}"]
+        DATABASE="#{dsn}"
+
+        [HISTORY.main]
+        get="cp history/main/{0} {1}"
+        put="cp {0} history/main/{1}"
+        mkdir="mkdir -p history/main/{0}"
+      EOS
+    end
+
+  end
+end

data/lib/stellar_core_commander/transactor.rb

@@ -0,0 +1,221 @@
+require 'fileutils'
+module StellarCoreCommander
+
+
+  # 
+  # A transactor plays transactions against a stellar-core test node.
+  # 
+  # 
+  class Transactor
+    include Contracts
+
+    class FailedTransaction < StandardError ; end
+
+    Currency = [String, Symbol]
+    Amount = Any #TODO
+
+    Contract Process => Any
+    def initialize(process)
+      @process    = process
+      @named      = {}.with_indifferent_access
+      @unverified = []
+      account :master, Stellar::KeyPair.from_raw_seed("allmylifemyhearthasbeensearching")
+    end
+
+    Contract String => Any
+
+    # 
+    # Runs the provided recipe against the process identified by @process
+    # 
+    # @param recipe_path [String] path to the recipe file
+    # 
+    def run_recipe(recipe_path)
+      raise "stellar-core not running" unless @process.running? 
+
+      recipe_content = IO.read(recipe_path)
+      instance_eval recipe_content
+    end
+
+
+    Contract Symbol, Stellar::KeyPair => Any
+    # 
+    # Registered an account for this scenario.  Future calls may refer to
+    # the name provided.
+    # 
+    # @param name [Symbol] the name to register the keypair at
+    # @param keypair=Stellar::KeyPair.random [Stellar::KeyPair] the keypair to use for this account
+    # 
+    def account(name, keypair=Stellar::KeyPair.random)
+      unless keypair.is_a?(Stellar::KeyPair)
+        raise ArgumentError, "`#{keypair.class.name}` is not `Stellar::KeyPair`"
+      end
+
+      add_named name, keypair
+    end
+
+    Contract Symbol, Symbol, Amount, Or[{}, {path: Any}] => Any
+    def payment(from, to, amount, options={})
+      from = get_account from
+      to   = get_account to
+
+      if amount.first != :native
+        amount    = [:iso4217] + amount
+        amount[2] = get_account(amount[2])
+        amount[1] = amount[1].ljust(4, "\x00")
+      end
+
+      attrs = {
+        account:     from,
+        destination: to,
+        sequence:    next_sequence(from),
+        amount:      amount,
+      }
+
+      if options[:path]
+        attrs[:path] = options[:path].map{|p| make_currency p}
+      end
+      envelope = Stellar::Transaction.payment(attrs).to_envelope(from)
+
+      submit_transaction envelope do |result|
+        payment_result = result.result.results!.first.tr!.payment_result!
+
+        raise FailedTransaction unless payment_result.code.value >= 0
+      end
+    end
+
+    Contract Symbol, Symbol, String => Any
+    def trust(account, issuer, code)
+      change_trust account, issuer, code, (2**63)-1
+    end    
+
+    Contract Symbol, Symbol, String, Num => Any
+    def change_trust(account, issuer, code, limit)
+      account = get_account account
+
+      tx = Stellar::Transaction.change_trust({
+        account:  account,
+        sequence: next_sequence(account),
+        line:     make_currency([code, issuer]),
+        limit:    limit
+      })
+
+      envelope = tx.to_envelope(account)
+
+      submit_transaction envelope
+    end
+
+    Contract Symbol, Symbol, Currency, Currency, Num, Num => Any
+    def offer(name, account, taker_gets, taker_pays, amount, price)
+      account    = get_account account
+      taker_gets = make_currency taker_gets
+      taker_pays = make_currency taker_pays
+
+      tx = Stellar::Transaction.create_offer({
+        account:  account,
+        sequence: next_sequence(account),
+        taker_gets: taker_gets,
+        taker_pays: taker_pays,
+        amount: amount,
+        price: price,
+      })
+
+      envelope = tx.to_envelope(account)
+
+      submit_transaction envelope do |result|
+        offer = begin
+          co_result = result.result.results!.first.tr!.create_offer_result!
+          co_result.success!.offer.offer!
+        rescue
+          raise FailedTransaction, "Could not extract offer from result:#{result.to_xdr(:base64)}"
+        end
+
+        add_named name, offer
+      end
+    end
+
+    Contract None => Any
+    # 
+    # Triggers a ledger close.  Any unvalidated transaction will
+    # be validated, which will trigger an error if any fail to be validated
+    # 
+    def close_ledger
+      @process.close_ledger
+
+      @unverified.each do |eb|
+        begin
+          envelope, after_confirmation = *eb
+          result = validate_transaction envelope
+          after_confirmation.call(result) if after_confirmation
+        rescue FailedTransaction
+          require 'pry'; binding.pry
+          $stderr.puts "Failed to validate tx: #{Convert.to_hex envelope.tx.hash}"
+          exit 1
+        end
+      end
+
+      # TODO: validate in-flight transactions
+      @unverified.clear
+    end
+
+    private
+    Contract Symbol, Any => Any
+    def add_named(name, object)
+      if @named.has_key?(name)
+        raise ArgumentError, "#{name} is already registered"
+      end
+
+      @named[name] = object
+    end
+
+    Contract Stellar::TransactionEnvelope, Or[nil, Proc] => Any
+    def submit_transaction(envelope, &after_confirmation)
+      hex    = envelope.to_xdr(:hex)
+      @process.submit_transaction hex
+
+      # submit to process
+      @unverified << [envelope, after_confirmation]
+    end
+
+    Contract Symbol => Stellar::KeyPair
+    def get_account(name)
+      @named[name].tap do |found|
+        unless found.is_a?(Stellar::KeyPair)
+          raise ArgumentError, "#{name.inspect} is not account"
+        end
+      end
+    end
+
+    Contract Stellar::KeyPair => Num
+    def next_sequence(account)
+      base_sequence  = @process.sequence_for(account)
+      inflight_count = @unverified.select{|e| e.first.tx.source_account == account.public_key}.length
+      
+      base_sequence + inflight_count + 1
+    end
+
+    Contract Currency => [Symbol, String, Stellar::KeyPair]
+    def make_currency(input)
+      code, issuer = *input
+      code = code.ljust(4, "\x00")
+      issuer = get_account issuer
+
+      [:iso4217, code, issuer]
+    end
+
+    Contract Stellar::TransactionEnvelope => Stellar::TransactionResult
+    def validate_transaction(envelope)
+      raw_hash = envelope.tx.hash
+      hex_hash = Convert.to_hex(raw_hash)
+
+      base64_result = @process.transaction_result(hex_hash)
+      
+      raise "couldn't fine result for #{hex_hash}" if base64_result.blank?
+      
+      raw_result = Convert.from_base64(base64_result)
+
+      pair = Stellar::TransactionResultPair.from_xdr(raw_result)
+      pair.result
+    end
+
+  end
+end

data/lib/stellar_core_commander/version.rb

@@ -0,0 +1,3 @@
+module StellarCoreCommander
+  VERSION = "0.0.1"
+end

data/lib/stellar_core_commander.rb

@@ -0,0 +1,20 @@
+require "stellar_core_commander/version"
+require "active_support/all"
+require "stellar-base"
+require "contracts"
+require "faraday"
+require "faraday_middleware"
+require "fileutils"
+require "open3"
+require "sequel"
+require "pg"
+
+module StellarCoreCommander
+  extend ActiveSupport::Autoload
+
+  autoload :Commander
+  autoload :Process
+  autoload :Transactor
+
+  autoload :Convert
+end

data/stellar_core_commander.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stellar_core_commander/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "stellar_core_commander"
+  spec.version       = StellarCoreCommander::VERSION
+  spec.authors       = ["Scott Fleckenstein"]
+  spec.email         = ["nullstyle@gmail.com"]
+  spec.summary       = %q{A helper gem for scripting stellar-core}
+  spec.homepage      = ""
+  spec.license       = "Apache 2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "stellar-base", "~> 0.0.1"
+  spec.add_dependency "slop", "~> 3.6.0"
+  spec.add_dependency "faraday", "~> 0.9.1"
+  spec.add_dependency "faraday_middleware", "~> 0.9.1"
+  spec.add_dependency "pg", "~> 0.18.1"   
+  spec.add_dependency "sequel", "~> 4.21.0"
+  spec.add_dependency "activesupport", ">= 4.0.0"
+  spec.add_dependency "contracts", "~> 0.9"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry"
+end

data/test.rb

@@ -0,0 +1,11 @@
+require 'stellar_core_commander'
+require 'pry'
+
+bin = File.expand_path("~/src/stellar/stellar-core/bin/stellar-core")
+cmd = StellarCoreCommander::Commander.new(bin)
+
+cmd.cleanup_at_exit!
+p1 = cmd.make_process
+
+
+binding.pry

metadata

@@ -0,0 +1,217 @@
+--- !ruby/object:Gem::Specification
+name: stellar_core_commander
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Scott Fleckenstein
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: stellar-base
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.1
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.21.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.21.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: contracts
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- nullstyle@gmail.com
+executables:
+- scc
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/scc
+- examples/non_native_payment.rb
+- examples/pathed_payment.rb
+- examples/simple_payment.rb
+- lib/stellar_core_commander.rb
+- lib/stellar_core_commander/commander.rb
+- lib/stellar_core_commander/convert.rb
+- lib/stellar_core_commander/process.rb
+- lib/stellar_core_commander/transactor.rb
+- lib/stellar_core_commander/version.rb
+- stellar_core_commander.gemspec
+- test.rb
+homepage: ''
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A helper gem for scripting stellar-core
+test_files: []
+has_rdoc: