counterparty_ruby 0.9.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.swp
+*.swo
+*.gem
+doc

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    counterparty_ruby (0.9.0)
+      bitcoin-ruby
+      ffi
+      rest_client
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bitcoin-ruby (0.0.6)
+    diff-lcs (1.2.5)
+    ffi (1.9.6)
+    json (1.8.1)
+    netrc (0.7.9)
+    rake (10.3.2)
+    rdoc (4.2.0)
+      json (~> 1.4)
+    rest_client (1.8.2)
+      netrc (~> 0.7.7)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-its (1.1.0)
+      rspec-core (>= 3.0.0)
+      rspec-expectations (>= 3.0.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  counterparty_ruby!
+  rake
+  rdoc
+  rspec
+  rspec-its

data/README.md

@@ -0,0 +1,197 @@
+counterparty_ruby
+=================
+A ruby gem for communicating with a Counterparty (Bitcoin / XCP) API server.
+
+What's up party people! [Chris DeRose](https://www.chrisderose.com) here, 
+community director of the [Counterparty Foundation](http://counterpartyfoundation.org/), 
+and today we're going to discuss.... Ruby! Or more specifically, how to start using
+counterparty in your ruby and/or ruby on rails app.
+
+This gem is designed to abstract communications with the counterpartyd api 
+server in an ActiveRecord-esque object model. But note that we also support 
+calling the api methods directly via the documented api calls in the offical docs. 
+
+Below you'll see some examples to get you started, but feel free to peruse the
+specs for yet more examples. These examples all assume that you're running a 
+working counterpartyd on the same system that the code is running on, but it's 
+easy to specify another server connection if you'd like. (Just set the 
+Counterparty.connection to a connection object that references the correct API
+server).
+
+We hope you find this useful everyone, let us know if there are any issues, and
+keep us updated on the apps you're building! We're working to make this 
+counterparty spool-up process as simple as possible, so bear with us while we're
+setting everything up. 
+
+![Party On Wayne](http://data.whicdn.com/images/24796384/tumblr_m0ng6rBeWT1qhd0xso1_500_large.jpg)
+
+## Examples
+Documentation on the objects is available via:
+  * [counterparty_ruby's rubydoc](http://www.rubydoc.info/github/brighton36/counterparty_ruby/master), 
+  * [The Counterparty official API guide](https://github.com/CounterpartyXCP/counterpartyd/blob/master/docs/API.rst#read-api-function-reference).
+
+#### Find the first burn
+Here we retrieve burns from the blockchain using ActiveRecord style method calls.
+
+  ```ruby
+  require 'counterparty_ruby'
+
+  Counterparty.production!
+
+  burns = Counterparty::Burn.find order_by: 'tx_hash', order_dir: 'asc', 
+    start_block: 280537, end_block: 280539
+
+  puts "First burned via: %s" % burns.first.source
+  # => 1ADpYypUcnbezuuYpCyRCY7G4KD6a9YXiF
+  ```
+
+#### Find the first burn (Alternative API-like syntax)
+This example achieves the same outcome as the above example, but uses a more 
+json-esque call syntax.
+
+  ```ruby
+  require 'counterparty_ruby'
+
+  # This connects to production mode on localhost:
+  production = Counterparty.connection.new 4000
+
+  # Note that we follow the api reference for calls here:
+  burns = production.get_burns order_by: 'tx_hash', order_dir: 'asc', 
+    start_block: 280537, end_block: 280539
+
+  puts "First burned via: %s" % burns.first.source
+  # => 1ADpYypUcnbezuuYpCyRCY7G4KD6a9YXiF
+  ```
+
+#### Create an Issuance
+Here we create an asset and persist that asset intothe blockchain using ActiveRecord style method calls.
+
+  ```ruby
+  require 'counterparty_ruby'
+
+  # Note that we default to test mode. Too, this example requires that your 
+  # private key for this address exists in the counterparty server's bitcoind 
+  first_asset = Counterparty::Issuance.new( 
+    source: 'msCXwsPVbv1Q1pc5AjXd5TdVwy3a1fSYB2',
+    asset: 'MYFIRSTASSET', 
+    description: "Its party time!",
+    divisible: false,
+    quantity: 100 )
+
+  transaction_id = first_asset.save!                                          
+
+  puts "Transaction %s has been entered into the mempool" % transaction_id
+  ```
+
+#### Create an Issuance (Alternative API-like syntax)
+This example achieves the same outcome as the above example, but uses a more 
+json-esque call syntax.
+
+  ```ruby
+  require 'counterparty_ruby'
+
+  # Note that we default to test mode. Too, this example requires that your 
+  # private key for this address exists in the counterparty server's bitcoind 
+  transaction_id = Counterparty.connection.do_issuance(
+    source: 'msCXwsPVbv1Q1pc5AjXd5TdVwy3a1fSYB2',
+    asset: 'MYFIRSTASSET', 
+    description: "Its party time!",
+    divisible: false,
+    quantity: 100 )
+
+  puts "Transaction %s has been entered into the mempool" % transaction_id
+  ```
+
+#### Broadcast the outcome of an event
+If you're the oracle, tasked with resolving a bet, here's how you would announce
+an outcome to the network.
+
+  ```ruby
+  require 'counterparty_ruby'
+
+  gold_down = Counterparty::Broadcast.new(
+    source: 'msCXwsPVbv1Q1pc5AjXd5TdVwy3a1fSYB2', 
+    fee_fraction: 0.05,
+    text: "Price of gold, 12AM UTC March1. 1=inc 2=dec/const", 
+    timestamp: 1418926641, 
+    value: 2 )
+
+  # Note that in this example, we're passing the private key that corresponds 
+  # to the public key. This allows us to sign transactions without having to  
+  # import the key onto the server's bitcoind. Note that this (currently) does 
+  # pass the key to the counterpartyd server. This behavior may change in later
+  # versions.
+  tx_id = gold_down.save! 'cP7ufwcbZujaa1qkKthLbVZUaP88RS5r9awyXerJE5rAEMTRVmzc'
+
+  puts "Gold was broadcast down in transaction  %s" % tx_id
+  ```
+
+#### Compile, Publish and Execute a Serpent Contract
+This is still beta behavior, and only supported on testnet, but here's a quick
+example of how Smart Contracts are published and executed. Note that we require
+the serpent CLI executable is installed on the running system
+
+  ```ruby
+  require 'open3'
+  require 'counterparty_ruby'
+
+  class Serpent
+    # Be sure to use the version from : https://github.com/ethereum/pyethereum
+    SERPENT='/usr/local/bin/serpent'
+
+    def compile(contract)
+      serpent 'compile', '-s', :stdin_data => contract
+    end
+
+    def encode_datalist(data)
+      serpent 'encode_datalist', data
+    end
+
+    private
+
+    def serpent(*args)
+      options = (args.last.kind_of? Hash) ? args.pop : {}
+      stdout, status = Open3.capture2( ([SERPENT]+args).join(' '), options)
+
+      raise StandardError, "Compile Failed: %s" % status.exitstatus unless status.success?
+
+      stdout.chomp
+    end
+  end
+
+  SOURCE_ADDRESS="msCXwsPVbv1Q1pc5AjXd5TdVwy3a1fSYB2"
+
+  Counterparty.test!
+
+  serpent = Serpent.new
+
+  compiled_script = serpent.compile <<-eos
+    return(msg.data[0]*2)
+  eos
+
+  contract_id = Counterparty::Publish.new( source: SOURCE_ADDRESS, 
+    code_hex: compiled_script, gasprice: 1, startgas: 1000000, endowment: 0, 
+    allow_unconfirmed_inputs: true ).save!
+
+  datalist = serpent.encode_datalist '53'
+
+  execute_id = Counterparty::Execute.new( source: SOURCE_ADDRESS, 
+    contract_id: contract_id, payload_hex: datalist, gasprice: 5, 
+    startgas: 160000, value: 10, allow_unconfirmed_inputs: true ).save!
+
+  puts "Executed Transaction ID: %s" % execute_id
+  ```
+
+## Have questions?
+The _best_ place to start is the [Counterparty API reference](https://github.com/CounterpartyXCP/counterpartyd/blob/master/docs/API.rst#read-api-function-reference).
+You'll soon find that this gem is merely a wrapper around the official 
+counterpartyd json API.
+
+But, if that doesn't help tweet [@derosetech](https://twitter.com/derosetech) 
+and/or check the [Counterparty Forums](https://forums.counterparty.io/) for more 
+help from the community. 
+
+We appreciate your patience if you're having problems, please bear in mind that 
+we're in active development mode. And thank-you for using Counterparty!
+
+![Best Party Ever](http://www.quickmeme.com/img/c8/c8cc224c5b1e8b1baafeba4287d9534add53273bc79572a5fcc8ab8ab2cc19ab.jpg)

data/Rakefile

@@ -0,0 +1,28 @@
+# File: Rakefile
+
+require 'rake'
+require 'rake/packagetask'
+require 'rdoc/task'
+require 'rspec/core/rake_task'
+
+spec = Gem::Specification.load('counterparty_ruby.gemspec')
+
+RDOC_FILES = FileList["README.md", "lib/*.rb", "lib/counterparty/*.rb"]
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = "doc/site/api"
+  rd.rdoc_files.include(RDOC_FILES)
+end
+
+Rake::RDocTask.new(:ri) do |rd|
+  rd.main = "README.md"
+  rd.rdoc_dir = "doc/ri"
+  rd.options << "--ri-system"
+  rd.rdoc_files.include(RDOC_FILES)
+end
+
+RSpec::Core::RakeTask.new('spec')
+
+task :spec => :compile
+

data/counterparty_ruby.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/counterparty/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Chris DeRose"]
+  gem.email         = ["chris@chrisderose.com"]
+  gem.description   = %q{This gem is designed to abstract communications with the counterpartyd api server in an ActiveRecord-esque object model}
+  gem.summary       = %q{An ActiveRecord-esque abstraction of the Counterparty API}
+  gem.homepage      = "https://github.com/brighton36/counterparty_ruby"
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec)/})
+  gem.name          = "counterparty_ruby"
+  gem.require_paths = ["lib"]
+  gem.version       = Counterparty::VERSION
+  gem.required_ruby_version = '>= 1.9'
+  gem.license       = 'LGPL'
+
+  ['rest_client', 'bitcoin-ruby', 'ffi'].each do |dependency|
+    gem.add_runtime_dependency dependency
+  end
+  ['rspec', 'rspec-its', 'rake', 'rdoc'].each do |dependency|
+    gem.add_development_dependency dependency
+  end
+end
+

data/lib/counterparty/connection.rb

@@ -0,0 +1,200 @@
+module Counterparty
+  # This class connects to the Counterparty api. Mostly it's not intended for 
+  # use by library consumers, but there are some helper methods in here for 
+  # those that prefer the Connection.get_burns syntax instead of the 
+  # Counterparty::Burn.find syntax
+  class Connection
+    # The default connection timeout, nil is "no timeout"
+    DEFAULT_TIMEOUT = nil
+
+    attr_accessor :host, :port, :username, :password
+
+    # A response timeout threshold By default, this initializes to -1, 
+    # which means the library will wait indefinitely before timing out
+    attr_writer :timeout
+
+    def initialize(port=14000, username='rpc', password='1234', host='localhost')
+      @host,@port,@username,@password=host.to_s,port.to_i,username.to_s,password.to_s
+      @timeout = DEFAULT_TIMEOUT
+    end
+
+    # The url being connected to for the purpose of an api call
+    def api_url
+      'http://%s:%s@%s:%s/api/' % [@username,@password,@host,@port.to_s]
+    end
+
+    # Returns a signed raw transaction, given a private key
+    def sign_tx(raw_tx, private_key)
+      request 'sign_tx', unsigned_tx_hex: raw_tx, privkey: private_key
+    end
+
+    # Broadcasts a signed transaction onto the bitcoin blockchain
+    def broadcast_tx(signed_tx)
+      request 'broadcast_tx', signed_tx_hex: signed_tx
+    end
+
+    # Issue a request to the counterpartyd server for the given method, with the 
+    # given params.
+    def request(method, params)
+      client = RestClient::Resource.new api_url, :timeout => @timeout
+      response = JSON.parse client.post({ method: method, 
+        params: params, jsonrpc: '2.0', id: '0' }.to_json,
+        user: @username, password: @password, accept: 'json', 
+        content_type: 'json' )
+
+      raise JsonResponseError.new response if response.has_key? 'code'
+      raise ResponseError.new response['error'] if response.has_key? 'error'
+
+      response['result']
+    end
+
+    # This creates the legacy api-format request methods on the connection
+    # argument. It lets us be relatively introspective about how we do this so
+    # as to be future-proof here going forward
+    def self.resource_request(klass) # :nodoc:
+      define_method(klass.to_get_request){ |params| klass.find params }
+      define_method(klass.to_do_request){ |params| klass.create(params).save! }
+      define_method(klass.to_create_request){ |params| klass.create(params).to_raw_tx }
+    end
+
+    # :method: do_balance
+    # # Sends a do_balance call to the counterpartyd server, given the provided params
+
+    # :method: create_balance
+    # # Sends a create_balance call to the counterpartyd server, given the provided params
+
+    # :method: do_bet
+    # # Sends a do_bet call to the counterpartyd server, given the provided params
+
+    # :method: create_bet
+    # # Sends a create_bet call to the counterpartyd server, given the provided params
+
+    # :method: do_betmatch
+    # # Sends a do_betmatch call to the counterpartyd server, given the provided params
+
+    # :method: create_betmatch
+    # # Sends a create_betmatch call to the counterpartyd server, given the provided params
+
+    # :method: do_broadcast
+    # # Sends a do_broadcast call to the counterpartyd server, given the provided params
+
+    # :method: create_broadcast
+    # # Sends a create_broadcast call to the counterpartyd server, given the provided params
+
+    # :method: do_btcpays
+    # # Sends a do_btcpays call to the counterpartyd server, given the provided params
+
+    # :method: create_btcpay
+    # # Sends a create_btcpay call to the counterpartyd server, given the provided params
+
+    # :method: do_burn
+    # # Sends a do_burn call to the counterpartyd server, given the provided params
+
+    # :method: create_burn
+    # # Sends a create_burn call to the counterpartyd server, given the provided params
+
+    # :method: do_callback
+    # # Sends a do_callback call to the counterpartyd server, given the provided params
+
+    # :method: create_callback
+    # # Sends a create_callback call to the counterpartyd server, given the provided params
+
+    # :method: do_cancel
+    # # Sends a do_cancel call to the counterpartyd server, given the provided params
+
+    # :method: create_cancel
+    # # Sends a create_cancel call to the counterpartyd server, given the provided params
+
+    # :method: do_credit
+    # # Sends a do_credit call to the counterpartyd server, given the provided params
+
+    # :method: create_credit
+    # # Sends a create_credit call to the counterpartyd server, given the provided params
+
+    # :method: do_debit
+    # # Sends a do_debit call to the counterpartyd server, given the provided params
+
+    # :method: create_debit
+    # # Sends a create_debit call to the counterpartyd server, given the provided params
+
+    # :method: do_dividend
+    # # Sends a do_dividend call to the counterpartyd server, given the provided params
+
+    # :method: create_dividend
+    # # Sends a create_dividend call to the counterpartyd server, given the provided params
+
+    # :method: do_issuance
+    # # Sends a do_issuance call to the counterpartyd server, given the provided params
+
+    # :method: create_issuance
+    # # Sends a create_issuance call to the counterpartyd server, given the provided params
+
+    # :method: do_order
+    # # Sends a do_order call to the counterpartyd server, given the provided params
+
+    # :method: create_order
+    # # Sends a create_order call to the counterpartyd server, given the provided params
+
+    # :method: do_ordermatch
+    # # Sends a do_ordermatch call to the counterpartyd server, given the provided params
+
+    # :method: create_ordermatch
+    # # Sends a create_ordermatch call to the counterpartyd server, given the provided params
+
+    # :method: do_send
+    # # Sends a do_send call to the counterpartyd server, given the provided params
+
+    # :method: create_send
+    # # Sends a create_send call to the counterpartyd server, given the provided params
+
+    # :method: do_message
+    # # Sends a do_message call to the counterpartyd server, given the provided params
+
+    # :method: create_message
+    # # Sends a create_message call to the counterpartyd server, given the provided params
+
+    # :method: do_callback
+    # # Sends a do_callback call to the counterpartyd server, given the provided params
+
+    # :method: create_callback
+    # # Sends a create_callback call to the counterpartyd server, given the provided params
+
+    # :method: do_betexpiration
+    # # Sends a do_betexpiration call to the counterpartyd server, given the provided params
+
+    # :method: create_betexpiration
+    # # Sends a create_betexpiration call to the counterpartyd server, given the provided params
+
+    # :method: do_orderexpiration
+    # # Sends a do_orderexpiration call to the counterpartyd server, given the provided params
+
+    # :method: create_orderexpiration
+    # # Sends a create_orderexpiration call to the counterpartyd server, given the provided params
+
+    # :method: do_betmatchexpiration
+    # # Sends a do_betmatchexpiration call to the counterpartyd server, given the provided params
+
+    # :method: create_betmatchexpiration
+    # # Sends a create_betmatchexpiration call to the counterpartyd server, given the provided params
+
+    # :method: do_ordermatchexpiration
+    # # Sends a do_ordermatchexpiration call to the counterpartyd server, given the provided params
+
+    # :method: create_ordermatchexpiration
+    # # Sends a create_ordermatchexpiration call to the counterpartyd server, given the provided params
+
+    # Go ahead and setup the defined resources, and throw them into the native-style
+    # api methods:
+    Counterparty.constants.each do |c| 
+      begin
+        klass = Counterparty.const_get(c)
+        if klass.respond_to?(:api_name) && klass != Counterparty::CounterResource
+          self.resource_request klass 
+        end
+      rescue NameError
+        next
+      end
+    end
+
+  end
+end

data/lib/counterparty/raw_tx.rb

@@ -0,0 +1,130 @@
+# This class is mostly used to decode json transactions from raw transactions
+# much of this implementation was inspired from: 
+# https://gist.github.com/shesek/5835695
+class RawTx
+  # This is a map of offset to characters used for decoding base64 strings:
+  BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+  MAX_32BIT_INTEGER=2**32-1
+
+  # Creates a raw transaction from a hexstring
+  def initialize(as_hexstring)
+    @hexstring = as_hexstring.downcase
+    raise ArgumentError, "Unsupported hex" unless /\A[0-9a-f]+\Z/.match @hexstring
+  end
+
+  # Returns this transaction in a standard json format
+  def to_hash(options = {})
+    bytes = @hexstring.scan(/../).collect(&:hex)
+    size = bytes.length
+
+    # Now we start shift elements off the byte stack:
+    version = shift_u32(bytes)
+
+    raise ArgumentError, "Unsupported Version/Tx" unless version == 0x01
+
+    # Parse the inputs:
+    ins = (0...shift_varint(bytes)).collect do
+      hash = bytes.slice!(0,32).reverse.collect{|n| '%02x' % n}.join
+      index,script,seq = shift_u32(bytes),shift_varchar(bytes),shift_u32(bytes)
+
+      # NOTE: We may want to base64 encode the hash, or support this via an 
+      # option : self.class.bytes_to_base64_s(hash).reverse),
+
+      # NOTE: The :seq field isnt actually used right now, so some rawtx decoders
+      # return the varint (like decoder), and some return UINT_MAX (4294967295)
+      { 'txid' => hash, 'vout' => index, 'sequence' => MAX_32BIT_INTEGER,
+        'scriptSig' => {'hex' => hex_stringify(script), 
+          'asm' => disassemble_script(script) } }
+    end
+
+    # Parse outputs:
+    outs = (0...shift_varint(bytes)).collect do |i|
+      value, script = shift_u64(bytes), shift_varchar(bytes)
+
+      { 'value' => self.class.bytes_to_ui(value).to_f/1e8, 'n' => i, 
+        'scriptPubKey' => {'hex' => hex_stringify(script), 
+          'asm' => disassemble_script(script) } }
+    end
+
+    lock_time = shift_u32 bytes
+
+    {'vin' => ins, 'vout' => outs, 'lock_time' => lock_time, 'ver' => version, 
+      'vin_sz' => ins.length, 'vout_sz' => outs.length, 'size' => size}
+  end
+
+  # Convert an array of 4 bit numbers into an unsigned int, 
+  # works for numbers up to 32-bit only
+  def self.nibbles_to_ui(nibbles)
+    raise ArgumentError if nibbles.length > 4
+
+    nibbles.each_with_index.inject(0){ |sum, (b,i)|
+      sum += (b.to_i & 0xff) << (4 * i) }
+  end
+
+  # Convert an array of 8 bit numbers into an unsigned int,
+  # Remember that for each input byte, the most significant nibble comes last.
+  def self.bytes_to_ui(bytes)
+    nibbles = bytes.collect{|b| [b & 0x0f, b >> 4]}.flatten
+    nibbles.each_with_index.inject(0){|sum,(b,i)| sum += b * 16**i}
+  end
+
+  # Convert an array of bytes to a base64 string.
+  def self.bytes_to_base64_s(input_bytes)
+    input_bytes.each_slice(3).collect.with_index{ |bytes,i|
+      # This is the base offset of this 3-byte slice in the sequence:
+      i_triplet = i*3 
+
+      # Here we compose a triplet by or'ing the shifted bytes:
+      triplet = bytes.collect.with_index{|b,j| b << 8*(2-j) }.reduce(:|)
+
+      # And here we convert to chars, unless with equals as nil-padding:
+      0.upto(3).collect do |j| 
+        (i_triplet * 8 + j * 6 <= input_bytes.length * 8) ? 
+          BASE64_CHARS[((triplet >> 6 * (3 - j)) & 0x3F)] : '=' 
+      end
+    }.join
+  end
+
+  private 
+
+  def disassemble_script(bytes)
+    # We don't actually need to reference a hash argument to achieve disassembly:
+    btc_script = Bitcoin::Script.new String.new
+    chunks = btc_script.parse bytes.pack('C*')
+    btc_script.to_string chunks
+  end
+
+  def hex_stringify(nibbles)
+    nibbles.collect{|c| '%02x' % c}.join
+  end
+
+  # https://en.bitcoin.it/wiki/Protocol_specification#Variable_length_string
+  def shift_varchar(bytes)
+    bytes.slice! 0, shift_varint(bytes)
+  end
+
+  # https://en.bitcoin.it/wiki/Protocol_specification#Variable_length_integer
+  def shift_varint(bytes)
+    n = shift_u8 bytes
+    case n
+      when 0xfd then shift_u16 bytes
+      when 0xfe then shift_u32 bytes
+      when 0xff then shift_u64 bytes
+      else n
+    end
+  end
+  
+  # These are numeric byte-shift short-cuts that make for more readable code 
+  # above:
+  [1,2,4].each do |n|
+    define_method('shift_u%s' % [n*8]) do |bytes| 
+      self.class.nibbles_to_ui bytes.slice!(0,n)
+    end
+  end
+
+  # 64 bit requests are an exception, and kept as 8-byte arrays:
+  def shift_u64(bytes)
+    bytes.slice!(0,8)
+  end
+end