epm 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 71968fbf0b3c65f40ed5f98a9340c3de0b6c9f57
+  data.tar.gz: d8be28a9138e03c27ade4091e79aa6c4558ef3a3
+SHA512:
+  metadata.gz: b63fc02ea393ff5a9d09590231193b41daa16756e792c627936a27375996e4692df19b807e50dc3e783adf17386c0ee72cb30ea0b0161772c08861f6b1113438
+  data.tar.gz: c7cff450ec22cc08ea6a98e509127ffdf8b4313f8c129a292a3f0422f5b858fdbb52c18769054ce8a22a233f77d45fc22cce12bf02464bfa4d4f5ed519dcc40d

data/.gitignore

@@ -0,0 +1,19 @@
+.ruby*
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+coverage

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+  - "2.1.1"
+  - jruby-19mode
+  - jruby-20mode
+
+notifications:
+  email:
+    on_failure: change
+  slack:
+    rooms:
+      - douglas:CkaMdC9JhYYG1NVbRXnu6xLc#general
+      - douglas:CkaMdC9JhYYG1NVbRXnu6xLc#infrastructure

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Watershed Legal Service, PLLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+In other words, don't be a jerk.

data/README.md

@@ -0,0 +1,166 @@
+# Introduction
+
+EPM is a package (provision?) manager. It is meant to simplify the management of git hosted repositories which contain Ethereum standard or customized contracts. This package manager should work in the way which most package managers operate -- with the addition that it will be able to interact with the Ethereum BlockChain.
+
+In addition to installing, uninstalling, updating, and upgrading your packages for you, the Gem will also act as a hub for different Ethereum contract building, testing, simulating, and deploying mechanisms.
+
+The package manager builds in a standard tipping system which is -- by convention -- built to allow tipping of the EPM system as well as the other tools which developers use to build, test, and deploy their contracts onto the Ethereum BlockChain. The tipping system is on by default as a mechanism to assist in further development of Ethereum contract deployment products. It can, of course, be turned off (this is open source software).
+
+# Installing
+
+This is a Ruby gem and will require that you have Ruby on your system (unless and until someone ports this to Python or Node). Once you have ensured that you have Ruby on your system, `gem install epm`.
+
+# Using
+
+The gem is a command line tool. All of the commands are built to run primarily from the command line. Of course the gem will integrate as a Ruby gem into your Ruby application, but primarily it is meant to work from the command line.
+
+## Contract Tools Features
+
+`epm install` -- used like brew install to install a particular Ethereum tool. Use in conjuction with the `-l` or `--local` flag to install the tool as the local tool only for this particular project. Otherwise will install the tool as a global user tool.
+
+`epm uninstall` -- used like brew uninstall to uninstall a particular Ethereum tool. Same restrictions for the `-l` or `--local` flag as with `epm install` are applicable to `epm uninstall`.
+
+`epm upgrade` -- used like brew upgrade to upgrade a particular Ethereum tool. Same restrictions for the `-l` or `--local` flag as with `epm install` are applicable to `epm upgrade`.
+
+`epm list` -- list installable tools.
+
+`epm list-installed` -- list currently installed tools.
+
+## Package Management Features
+
+`epm pull` -- will pull contract provisions, contracts, or packages of contracts based on the contract definition files in the project folder. If used without calling any contract definition file after `epm pull` will pull all the necessary components for all of the contract definition files viewable from the project root. If used with a contract definition file after `epm pull` will pull all the necessary components for the contract definition file.
+
+`epm push` -- will push contract provisions, contracts, or packages of contracts assembled in the project root to the repository noted in the local configuration file's `repository` setting
+
+`epm update` -- will pull updates to the contract provisions, contracts, or packages of contracts based on the contract definition files in the project folder. Can be used with or without a contract definition file as with `epm pull`.
+
+## Contract Workflow Features
+
+`epm make` -- used to pull Ethereum provisions, contracts, or packaged and build out the application or package(s) in this project based on the contract definition files. If used without calling a particular contract definition file after `epm make` will make all the contract definition files visible from the project root (which is where epm make should be called from). If used with a particular contract definition file after `epm make` will only make that particular contract definition.
+
+`epm test` -- used to test Ethereum contracts based upon the tester included in the global or local configuration file.
+
+`epm simulate` -- used to simulate Ethereum contracts or sets of contracts based upon the simulator included in the global or locla configuration file.
+
+`epm deploy` -- used to deploy contracts to the Ethereum blockchain.
+
+`epm update-deployed` -- used to send a command to currently running contracts on the Ethereum blockchain to update themselves based on the git diff between the most recent commit of the project repository and the current commit when the contracts were deployed to the blockchain.
+
+`epm destroy` -- used to send a suicide command to all of the contracts in the Ethereum blockchain which are derived from the project root.
+
+## EPM Self-Reflective Features
+
+`epm configure-local` -- open the local configuration file in the default editor.
+
+`epm configure-global` -- open the global configuration file in the default editor.
+
+`epm self-update` -- update the EPM tool to the latest version.
+
+`epm implode` -- remove EPM entirely.
+
+## Package Management Features
+
+`epm install` --
+
+`epm pull` --
+
+`epm push` --
+
+`epm destroy` --
+
+`epm update` --
+
+`epm list` --
+
+## Contract Workflow Features
+
+`epm make` --
+
+`epm test` --
+
+`epm simulate` --
+
+`epm deploy` --
+
+# Configuration Options
+
+EPM uses what should be a fairly approachable two configuration layers approach to managing configurations. The first level which the gem will look at will be the `~/.epm/config.epm` file. These are the user global configurations. The global configurations will be overwritten by local configuration files in the config.epm file of the root directory of the project you are working on (for the time being epm should be called from this directory). The config.epm file is a [TOML](https://github.com/mojombo/toml) formated configuration file with the following options.
+
+## Global Configuration Options
+
+`editor` -- String denoting the path which EPM should call in order to edit the contract. Default: shell environment's editor.
+
+`linter` -- String denoting the path which EPM should call in order to lint a contract. Default: ???
+
+`tester` -- String denoting the path which EPM should call in order to run your test suite. Default: ???
+
+`simulator` -- String denoting the path which EPM should call in order to start the simulator. Default: ???
+
+`compiler` -- String denoting the path which EPM should call in order to compile the contract into the byte language for deployment to the Ethereum BlockChain. Default: ???
+
+`blacklisted-repos` -- Array of strings denoting github or other git repos which are Blacklisted. Default: []
+
+`deployer-keys` -- String denoting the public key of the deploying coder|lawyer -- which some or all contracts can use to ensure a tip is sent to the deployer.
+
+`infrastructure-keys` -- Array of strings denoting the public keys of the testers, linters, simulators, package managers, and other infrastructure which the deployer used to assist in the deployment of the contract. Strings should be in the form `KEY:AMOUNT:MESSAGE` where KEY is the public hash which the contract will send the tip and where AMOUNT is the **percentage** of the tip which will go to this key. MESSAGE is the signing message of the tip and is optional.
+
+## Local Configuration Options
+
+The local configuration options include *all* of the global configuration options, and local configuration options will override the global configuration options. In addition, there are a few local configuration options which are not read by the global config file.
+
+`name` -- String denoting the name of the package. If the package contains one contract the package and the contract will be the same thing. If the package contains more than one contract then the package will include all of the contracts.
+
+`author` -- String denoting the author of the package.
+
+`author-address` -- String denoting the Ethereum address of the author of the package (used for tipping system when others reuse the contract or package).
+
+`repository` -- String denoting the remote git repository for the package. When the user calls `epm push` EPM will send the package to this address.
+
+# Contract and Package Definition Files
+
+EPM uses contract definition files to build and maintain contracts. Contract definition files are TOML files.
+
+## Package Definition Files
+
+Define the contracts used in the package and the relationships between them. TODO.
+
+## Contract Definition Files -- Shortform
+
+The shortform contract definition allows coder|lawyers to pull in \*.ethereum-contract files to the working folder to be tested, simulated, and deployed from established git repositories.
+
+EPM will pull from any git repository, but it will default to github repositories, so when you send it the following repository: `watershedlegal/ethereum-boilerplate-prefaces` it will know that that is a github address. If you would like to add a private repository or a bitbucket or any other repository simply add the full address to the line. If the repository contains multiple `.ethereum-contract` files and you only want one of those files, you can state the contract you want EPM to pull into the working directory by specifying that instead of the repository in the `XXXXXXX.ethereum-definition` file.
+
+The `XXXX.ethereum-definition` file will simply be a list of the repositories or contract files which EPM should import into the working directory's repo folder. After that it will be up to the coder|lawyer to build the contracts into a working network or meta contract, test, simulate, and deploy.
+
+## Contract Definition Files -- Longform
+
+The longform contract definition allows coder|lawyers to pull in pieces of contracts from different sources and have EPM attempt to assemble a cohesive contract in which the lawyer|coder can then edit before linting, testing, simulating, and deploying.
+
+As with the shortform contract definitions, EPM will pull from any repository based on the rules described above. Addresses may point to the entire repository, in which case EPM will pull in all \*.ethereum-provision files. If only one file is wanted for the preface section, that file path can be specified after the repository address. In addition, if only certain line numbers of a certain file are desired to be pulled in then EPM will know to look for that when you add the following string: `REPONAME/FILEPATH:STARTLINE_ENDLINE` where STARTLINE and ENDLINE are the line numbers which you would like to be pulled in.
+
+The contract definition file is also a TOML formatted configuration file. There are three sections to the contract definition file (which by convention should be XXXXX.ethereum-definition where XXXX is the name of the contract):
+
+1. `provisions` -- Array of strings denoting the repository addresses which EPM will pull from and formulate into the main provisions of this contract.
+2. `constants` -- Array of KEY:VALUE pairs which set the constant values after building a contract.
+3. `tip-amount` -- Integer denoting the amount of ether to be distributed to the infrastructure network which helped you build and deploy this contract or system of contracts.
+4. `constants` -- Array of KEY:VALUE pairs which set the constant values after building a contract.
+5. `tip-amount` -- Integer denoting the amount of ether to be distributed to the infrastructure network which helped you build and deploy this contract or system of contracts.
+
+# Roadmap / TODO
+
+- [ ] Everything
+
+# Contributing
+
+1. Fork the repository.
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Add Tests (and feel free to help here since I don't (yet) really know how to do that.).
+4. Commit your changes (`git commit -am 'Add some feature'`).
+5. Push to the branch (`git push origin my-new-feature`).
+6. Create new Pull Request.
+
+# License
+
+MIT License - (c) 2014 - Watershed Legal Services, PLLC. All copyrights are owned by [Watershed Legal Services, PLLC](http://watershedlegal.com).
+
+See License file.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/epm

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+#
+# == USAGE
+#  epm subcommand [file]
+require '../lib/epm.rb'
+# args = ARGV
+# EPM::parse args
+
+require 'commander/import'
+
+program :version, EPM.version
+program :description, 'Ethereum Package Manager assists in the management of Ethereum Packages and Tools to ease developers workflows.'
+
+##
+## Package Workflow Commands
+##
+command :compile do |c|
+  c.syntax = 'epm compile'
+  c.description = 'Compile an ethereum contract and return the byte code array.'
+  c.action do |args|
+    result = EPM.compile(args)
+    result.each{|l| print l + "\n"}
+  end
+end
+
+command :create do |c|
+  c.syntax = 'epm create'
+  c.description = 'Compile an ethereum contract and deploy to the blockchain.'
+  c.action do |args|
+    result = EPM.create(args)
+    result.each{|l| print l + "\n"}
+  end
+end
+
+command :deploy do |c|
+  c.syntax = 'epm deploy'
+  c.description = 'Compile and deploy a system of contracts to the blockchain. See gem README for EPM package-definition file syntax.'
+  c.action do |args|
+    EPM.deploy(args)
+  end
+end
+
+##
+## EPM Tools
+##
+command :transact do |c|
+  c.syntax = 'epm transact'
+  c.description = 'Send a transaction to a contract. Note this is to work with contracts, it will not (by default) send ether.'
+  c.action do |args|
+    print "Transaction Sent.\n"
+  end
+end
+
+command :query do |c|
+  c.syntax = 'epm query'
+  c.description = 'Query a storage position of a contract currently on the blockchain.'
+  c.action do |args|
+    print EPM.query(args) + "\n"
+  end
+end
+
+command :start do |c|
+  c.syntax = 'epm start'
+  c.description = 'Start your default ethereum server.'
+  c.action do
+    print "Please be patient, this will take a few seconds.\n"
+    EPM.start
+    print "Server has started.\n"
+  end
+end
+
+command :stop do |c|
+  c.syntax = 'epm stop'
+  c.description = 'Stop your default ethereum server.'
+  c.action do
+    EPM.stop
+    print "Server has stopped.\n"
+  end
+end
+
+command :restart do |c|
+  c.syntax = 'epm restart'
+  c.summary = ''
+  c.description = 'Restart your default ethereum server.'
+  c.action do
+    print "Please be patient, this will take a few seconds.\n"
+    EPM.restart
+    print "Server has been restarted.\n"
+  end
+end

data/epm.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'epm/version'
+
+Gem::Specification.new do |s|
+  s.name              = "epm"
+  s.version           = VERSION
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = "Ethereum Contracts Package Manager."
+  s.homepage          = "https://github.com/ethereum-package-manager/epm"
+  s.authors           = [ "Casey Kuhlman" ]
+  s.email             = "caseykuhlman@watershedlegal.com"
+
+  s.date              = Time.now.strftime('%Y-%m-%d')
+  s.has_rdoc          = false
+
+  s.files             = `git ls-files`.split($/)
+  s.executables       = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files        = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths     = ["lib"]
+
+  s.add_dependency    "commander", "~> 4.1.6"
+
+  s.description       = <<desc
+  This gem is designed to assist in distribution, dissemination, compilation, and deployment of Ethereum contracts.
+desc
+end

data/lib/epm.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+# std_lib
+require 'fileutils'
+require 'tempfile'
+require 'shellwords'
+require 'json'
+require 'net/http'
+require 'uri'
+require 'optparse'
+
+# this gem
+Dir[File.dirname(__FILE__) + '/epm/*.rb'].each {|file| require file }
+
+module EPM
+  extend self
+
+  def compile args
+    output = []
+    until args.empty?
+      file = args.shift
+      settings = setup
+      output << EPM::Compile.new(file, settings).compile
+    end
+    output
+  end
+
+  def create args
+    output = []
+    until args.empty?
+      file = args.shift
+      settings = setup
+      output << EPM::Create.new(file, settings).deploy
+    end
+    output
+  end
+
+  def deploy args
+    output = []
+    until args.empty?
+      file = args.shift
+      settings = setup
+      output << EPM::Deploy.new(file, settings).deploy_package
+    end
+    output
+  end
+
+  def transact args
+    recipient = args.shift
+    data = args
+    settings = setup
+    EPM::Transact.new(recipient, data, settings).transact
+  end
+
+  def query args
+    address = args.shift
+    position = args.shift
+    settings = setup
+    EPM::Query.new(address, position, settings).query
+  end
+
+  def version
+    return VERSION
+  end
+
+  def start
+    EPM::Server.start
+  end
+
+  def stop
+    EPM::Server.stop
+  end
+
+  def restart
+    EPM::Server.stop
+    EPM::Server.start
+  end
+
+  def setup
+    return EPM::Settings.check
+  end
+end

data/lib/epm/compile.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+module EPM
+  class Compile
+    def initialize file, settings={}
+      @file     = EPM::FileHelpers.file_guard file
+      @settings = settings
+    end
+
+    def compile
+      if @file
+        if File.extname(@file) == '.lll'
+          return compile_lll
+        elsif File.extname(@file) == ('.mu' || '.mut')
+          return compile_mutan
+        elsif File.extname(@file) == ('.se' || '.ser')
+          return compile_serpent
+        end
+      end
+    end
+
+    def compile_lll
+      contract = `#{@settings["path-to-lllc"]} #{@file}`
+      contract.chomp!
+      contract = EPM::HexData.hex_guard contract
+      return contract
+    end
+
+    def compile_serpent
+      contract = `#{@settings['path-to-serpent']} #{Shellwords.escape(@file)}`
+      contract.chomp!
+      return EPM::HexData.hex_guard contract
+    end
+
+    def compile_mutan
+      contract = `#{@settings['path-to-mutan']} #{Shellwords.escape(@file)}`
+      contract.chomp!
+      return EPM::HexData.hex_guard contract
+    end
+  end
+end

data/lib/epm/create.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+module EPM
+  class Create
+    def initialize file, settings={}
+      if file
+        @uri      = URI.parse "http://localhost:#{settings['json-port']}"
+        @settings = settings
+        @contract = EPM::Compile.new(file, @settings).compile
+      end
+    end
+
+    def deploy
+      if @settings['preferred-client'] == 'cpp'
+        params = {
+          'sec' => @settings["address-private-key"],
+          'xEndowment' => '',
+          'bCode' => @contract,
+          'xGas' => '100000',
+          'xGasPrice' => '100000000000000'
+        }
+        post_body   = { 'method' => 'create', 'params' => params, 'id' => 'epm-rpc', "jsonrpc" => "2.0" }.to_json
+      elsif @settings['preferred-client'] == ('go' || 'ethereal')
+        params = {
+          'body' => @contract,
+          'value' => '',
+          'gas' => '100000',
+          'gasprice' => '100000000000000'
+        }
+        post_body   = { 'method' => 'EthereumApi.Create', 'params' => params, 'id' => 'epm-rpc', 'jsonrpc' => '2.0'}.to_json
+      end
+      return EPM::Server.http_post_request @uri, post_body
+    end
+  end
+end

data/lib/epm/deploy.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+
+module EPM
+  class Deploy
+    def initialize def_file, settings={}
+      @dirname  = File.dirname(File.absolute_path(def_file))
+      @log_file = File.join(ENV['HOME'], '.epm', 'deployed-log.csv')
+      @settings = settings
+      @brain    = {}
+      @def_file = def_file
+    end
+
+    def deploy_package
+      if @def_file
+        commands = File.readlines @def_file
+        commands = commands.reject{|cmd| cmd[/\A#/] || cmd[/\A$/]}.map{|cmd| cmd.gsub("\n",'')}
+        commands = commands.inject([]) do |arr,ele|
+          ele[/\A\S+/] ? arr << [ele] : arr[-1] << ele.strip.split(' => ')
+          arr
+        end
+        commands.each do |cmd|
+          dowit = cmd.shift
+          case dowit
+          when 'deploy:'
+            deploy cmd.shift
+            sleep 1
+          when 'modify-deploy:'
+            modify_deploy cmd
+            sleep 1
+          when 'transact:'
+            transact cmd.shift
+            sleep 1
+          when 'query:'
+            query cmd.shift
+          when 'log:'
+            log cmd.shift
+          when 'set:'
+            set_var cmd.shift
+          end
+        end
+      end
+    end
+
+    def deploy command
+      deploy_k = command.shift
+      k_name = command.shift
+      p "Deploying #{deploy_k} with name of #{k_name.gsub(/(\{|\})/,'')}."
+      k_address = EPM::Create.new(File.join(@dirname, deploy_k), @settings).deploy
+      @brain[k_name] = k_address
+      p "#{k_name} => #{k_address}"
+    end
+
+    def modify_deploy command
+      deploy_k = command[0].shift
+      deploy_k = EPM::FileHelpers.file_guard(File.join(@dirname, deploy_k))
+      k_name = command[0].shift
+      dump = command.shift
+      until command.empty?
+        cmd = command.shift
+        to_replace = cmd.shift
+        replacer = cmd.shift
+        until ! replacer[/(\{\{.*?\}\})/]
+          replacer.gsub!($1, @brain[$1])
+        end
+        k_value = File.read deploy_k
+        k_value = k_value.gsub "#{to_replace}", "#{replacer}"
+        File.open(deploy_k, 'w'){|f| f.write k_value}
+      end
+      p "After modifying, am deploying #{deploy_k} with name of #{k_name.gsub(/(\{|\})/,'')}."
+      k_address = EPM::Create.new(deploy_k, @settings).deploy
+      @brain[k_name] = k_address
+      p "#{k_name} => #{k_address}"
+    end
+
+    def transact command
+      recipient = command.shift
+      until ! recipient[/(\{\{.*?\}\})/]
+        recipient.gsub!($1, @brain[$1])
+      end
+      data = command.shift
+      until ! data[/(\{\{.*?\}\})/]
+        data.gsub!($1,@brain[$1])
+      end
+      data = data.split(' ')
+      p "Sending #{recipient} the data: #{data}."
+      EPM::Transact.new(recipient, data, @settings).transact
+    end
+
+    def query command
+      contract = command.shift
+      address = command.shift
+      name = command.shift
+      until ! contract[/(\{\{.*?\}\})/]
+        contract.gsub!($1,@brain[$1])
+      end
+      until ! address[/(\{\{.*?\}\})/]
+        address.gsub!($1,@brain[$1])
+      end
+      p "Querying #{contract} at: #{address}."
+      storage = EPM::Query.new(contract, address, @settings).query
+      p "#{contract}:#{address} => #{storage}"
+      @brain[name] = storage
+    end
+
+    def log command
+      address = command.shift
+      name = command.shift
+      until ! address[/(\{\{.*?\}\})/]
+        address.gsub!($1,@brain[$1])
+      end
+      until ! name[/(\{\{.*?\}\})/]
+        name.gsub!($1,@brain[$1])
+      end
+      log_entry = [address, name].join(',')
+      p "Logging [#{address},#{name}]"
+      `echo #{log_entry} >> #{@log_file}`
+    end
+
+    def set_var command
+      key = command.shift
+      value = command.shift
+      p "Setting #{key} to #{value}"
+      @brain[key] = value
+    end
+  end
+end

data/lib/epm/query.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+module EPM
+  class Query
+    def initialize address, position, settings={}
+      @uri      = URI.parse "http://localhost:#{settings['json-port']}"
+      @settings = settings
+      @address  = EPM::HexData.hex_guard address
+      @position = EPM::HexData.hex_guard position
+    end
+
+    def query
+      if @settings['preferred-client'] == 'cpp'
+        params = {
+          'a' => @address,
+          'x' => @position
+        }
+        post_body = { 'method' => 'storageAt', 'params' => params, 'id' => 'epm-rpc', "jsonrpc" => "2.0" }.to_json
+      elsif @settings['preferred-client'] == ('go' || 'ethereal')
+        params = {
+          'address' => @address,
+          'key' => @position
+        }
+        post_body = { 'method' => 'EthereumApi.GetStorageAt', 'params' => params, 'id' => 'epm-rpc', "jsonrpc" => "2.0" }.to_json
+      end
+      return EPM::Server.http_post_request @uri, post_body
+    end
+  end
+end

data/lib/epm/transact.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+module EPM
+  class Transact
+    def initialize recipient, data, settings={}
+      @uri       = URI.parse "http://localhost:#{settings['json-port']}"
+      @settings  = settings
+      @recipient = EPM::HexData.hex_guard recipient
+      @data      = EPM::HexData.construct_data data
+    end
+
+    def transact
+      if @settings['preferred-client'] == 'cpp'
+        params = {
+          'sec' => @settings["address-private-key"],
+          'xValue' => '',
+          'aDest' => @recipient,
+          'bData' => @data,
+          'xGas' => '100000',
+          'xGasPrice' => '100000000000000'
+        }
+        post_body = { 'method' => 'transact', 'params' => params, 'id' => 'epm-rpc', "jsonrpc" => "2.0" }.to_json
+      elsif @settings['preferred-client'] == ('go' || 'ethereal')
+        params = {
+          'recipient' => @recipient,
+          'value' => '',
+          'gas' => '100000',
+          'gasprice' => '100000000000000',
+          'body' => @data,
+        }
+        post_body = { 'method' => 'EthereumApi.Transact', 'params' => params, 'id' => 'epm-rpc', "jsonrpc" => "2.0" }.to_json
+      end
+      return EPM::Server.http_post_request @uri, post_body
+    end
+  end
+end

data/lib/epm/utils.rb

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+
+module EPM
+  module Server
+    extend self
+
+    def start debug=false
+      settings = EPM::Settings.check
+      if debug
+        debug = ''
+      else
+        debug = '>> /dev/null'
+      end
+
+      unless is_eth_running?
+        case settings['preferred-client']
+        when 'cpp'
+          server = "#{settings["path-to-eth"]} --json-rpc-port #{settings['json-port']} -r #{settings["remote"]} -d #{settings["directory"]} -m off -l #{settings["eth-listen-port"]} -c #{settings["name"]} -s #{settings["address-private-key"]} #{debug}"
+        when 'go'
+          server = "#{settings['path-to-go-ethereum']}"
+        when 'ethereal'
+          server = "#{settings['path-to-ethereal']}"
+        end
+        pid = spawn server
+        sleep 7
+      end
+      return pid
+    end
+
+    def stop
+      if is_eth_running?
+        processes = eth_processes.map{|e| e.split(' ')[1]}
+        processes.each{|p| `kill #{p}`}
+      end
+    end
+
+    def is_eth_running?
+      eth = eth_processes
+      return (! eth.empty?)
+    end
+
+    def eth_processes
+     a = `ps ux`.split("\n").select{|e| e[/eth --json-rpc-port/]}
+     # a << `ps ux`.split("\n").select{|e| e[/ethereum/]}
+     a << `ps ux`.split("\n").select{|e| e[/ethereal/]}
+     a = a.flatten
+     return a
+    end
+
+    def http_post_request uri, post_body
+      unless is_eth_running?
+        p "Ethereum RPC Server is not running. Starting now. Please be patient for it to load."
+        start
+      end
+      http    = Net::HTTP.new uri.host, uri.port
+      request = Net::HTTP::Post.new uri.request_uri
+      request.content_type = 'application/json'
+      request.body = post_body
+      result = JSON.parse(http.request(request).body)['result']
+      return result
+    end
+  end
+
+  module Settings
+    extend self
+
+    def check
+      install_setup_file unless have_setup_file
+      return load_settings
+    end
+
+    def have_setup_file
+      settings_file = File.join(ENV['HOME'], '.epm', 'epm-rpc.json')
+      File.exists? settings_file
+    end
+
+    def install_setup_file
+      settings_example = File.join(File.dirname(__FILE__), '..', '..', 'settings', 'epm-rpc.json')
+      settings_file = File.join(ENV['HOME'], '.epm', 'epm-rpc.json')
+      unless Dir.exists? File.dirname settings_file
+        FileUtils.mkdir(File.dirname settings_file)
+      end
+      FileUtils.cp settings_example, settings_file
+    end
+
+    def install_log_file
+      log_file = File.join(ENV['HOME'], '.epm', 'deployed-log.csv')
+      unless File.exists? log_file
+        File.open(log_file, "w") {}
+      end
+      return log_file
+    end
+
+    def load_settings
+      settings_file = File.join(ENV['HOME'], '.epm', 'epm-rpc.json')
+      settings = JSON.parse(File.read(settings_file))
+      log_file = install_log_file
+      settings["log_file"] = log_file
+      return settings
+    end
+  end
+
+  module HexData
+    extend self
+
+    def hex_guard data
+      if data[0..1] != "0x"
+        data = "0x" + data
+      end
+      return data
+    end
+
+    def construct_data deconstructed_data
+      data = "0x"
+      deconstructed_data.each do |bits|
+        if bits[0..1] == "0x"
+          piece = bits[2..-1]
+          piece = piece.rjust(64,'0')
+        else
+          piece = bits.unpack('c*').map{|s| s.to_s(16)}.join('')
+          piece = piece.ljust(64,'0')
+        end
+        data << piece
+      end
+      return data
+    end
+  end
+
+  module FileHelpers
+    extend self
+
+    def file_guard file
+      contents = File.read file
+      dir = File.dirname(File.absolute_path(file))
+      unless dir == '/tmp'
+        include_pattern = /(\(include \")(\..*)(\"\))/
+        if contents[include_pattern]
+          included = File.join(dir, $2)
+          included = $1 + included + $3
+          contents.gsub!(include_pattern, included)
+        end
+        save_temp_file contents, file
+      else
+        return file
+      end
+    end
+
+    def save_temp_file contents, file
+      tmp = Tempfile.new ['epm', File.extname(file)]
+      File.open(tmp, 'w'){|f| f.write contents}
+      return tmp.path
+    end
+  end
+end

data/lib/epm/version.rb

@@ -0,0 +1 @@
+VERSION = "0.3.1"

data/settings/epm-rpc.json

@@ -0,0 +1,17 @@
+{
+  "path-to-ruby": "ruby",
+  "path-to-eth": "/opt/cpp-ethereum/build/eth/eth", // cpp client
+  "path-to-ethereal": "ethereal",
+  "path-to-go-ethereum": "ethereum",
+  "path-to-lllc": "/opt/cpp-ethereum/build/lllc/lllc",
+  "path-to-mutan": "mutan",
+  "path-to-serpent": "serpent",
+  "preferred-client": "cpp", // can also use `go` <- which will run go headless or `ethereal` <- qt go client.
+  "json-port": "9090",
+  "remote": "remote",  // this would typically be the default peer server for your client variant
+  "directory": "~/.ethereum", // in cpp world Aleth defaults to this so change to a different directory to run eth headless in
+  "eth-listen-port": "30303", // see the comment above
+  "name": "name", // this is the client name
+  "address-public-key": "0xact",
+  "address-private-key": "0xsec"
+}

data/spec/fixtures/test.lll

@@ -0,0 +1,15 @@
+{
+    (include "./test2.lll")
+    (def 'DOUG 0x9c0182658c9d57928b06d3ee20bb2b619a9cbf7b)
+    (def 'BAindicator 0x10)
+    [[BAindicator]]0x88554646BA
+    [[69]] (caller)
+    [[0xDEADBEEF]]DOUG
+    (return 0 (lll
+      (when (= (caller) @@69)
+        (for {} (< @i (calldatasize)) [i](+ @i 64)
+          [[ (calldataload @i) ]] (calldataload (+ @i 32))
+        )
+      )
+    0))
+}

data/spec/fixtures/test.package-definition

@@ -0,0 +1,16 @@
+# Package Name:       EPM Test
+# Package Author:     Casey Kuhlman
+# Package Email:      casey@projectdouglas.org
+# Package Repository: https://github.com/ethereum-package-manager/epm
+
+deploy:
+  test.lll => {{DOUG}}
+modify-deploy:
+  test.lll => {{rep}}
+  (def 'DOUG 0x9c0182658c9d57928b06d3ee20bb2b619a9cbf7b) => (def 'DOUG {{DOUG}})
+transact:
+  {{DOUG}} => rep {{rep}}
+query:
+  {{DOUG}} => 0x7265700000000000000000000000000000000000000000000000000000000000 => {{KEYVALSTORE}}
+log:
+  {{KEYVALSTORE}} => {{rep}}

data/spec/fixtures/test2.lll

@@ -0,0 +1,3 @@
+{
+    [[0x12]]0xFFFFFFF
+}

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: epm
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Casey Kuhlman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.6
+description: |2
+    This gem is designed to assist in distribution, dissemination, compilation, and deployment of Ethereum contracts.
+email: caseykuhlman@watershedlegal.com
+executables:
+- epm
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/epm
+- epm.gemspec
+- lib/epm.rb
+- lib/epm/compile.rb
+- lib/epm/create.rb
+- lib/epm/deploy.rb
+- lib/epm/query.rb
+- lib/epm/transact.rb
+- lib/epm/utils.rb
+- lib/epm/version.rb
+- settings/epm-rpc.json
+- spec/fixtures/test.lll
+- spec/fixtures/test.package-definition
+- spec/fixtures/test2.lll
+homepage: https://github.com/ethereum-package-manager/epm
+licenses: []
+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: Ethereum Contracts Package Manager.
+test_files:
+- spec/fixtures/test.lll
+- spec/fixtures/test.package-definition
+- spec/fixtures/test2.lll