stellar-base 0.0.1

data/lib/stellar/util/base58.rb

@@ -0,0 +1,127 @@
+module Stellar
+  module Util
+    class Base58
+      STELLAR_ALPHABET = "gsphnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCr65jkm8oFqi1tuvAxyz"
+      BITCOIN_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+      BASE             = 58
+
+      # TODO: improve the conversion to bitstring, perhaps `Fixnum#to_byte`?
+      VERSION_BYTES = {
+        none:       [1].pack("C").encode("BINARY"),
+        account_id: [0].pack("C").encode("BINARY"),
+        seed:       [33].pack("C").encode("BINARY"),
+      }
+
+      def self.stellar
+        Thread.current[:stellar_base58] ||= new(STELLAR_ALPHABET)
+      end
+
+      def self.bitcoin
+        Thread.current[:bitcoin_base58] ||= new(BITCOIN_ALPHABET)
+      end
+
+      def initialize(alphabet)
+        raise ArgumentError, "Invalid alphabet length" if alphabet.length != BASE
+        @alphabet = alphabet
+      end
+
+      def encode(byte_str)
+        return "" if byte_str.nil? || byte_str.empty?
+
+        leading_zeros = byte_str.each_byte.take_while{|b| b == 0}.length
+        int           = bytes_to_int(byte_str) # step 1
+
+        encode_int(int, leading_zeros)
+      end
+
+      def check_encode(version, byte_str)
+        version_byte = VERSION_BYTES[version]
+        raise ArgumentError, "Invalid version: #{version}" if version_byte.blank?
+
+        payload = version_byte + byte_str.dup.force_encoding("BINARY")
+        check   = checksum(payload)
+        encode(payload + check)
+      end
+
+      def decode(str)
+        leading_zeros = str.each_char.take_while{|c| c == @alphabet[0]}.length
+
+        ("\x00" * leading_zeros) + decode_int(str)
+      end
+
+      def check_decode(expected_version, str)
+        decoded      = decode(str)
+        version_byte = decoded[0]
+        payload      = decoded[1...-4]
+        check        = decoded[-4..-1]
+        version      = VERSION_BYTES.key(version_byte)
+
+        raise ArgumentError, "Unexpected version: #{version.inspect}" if version != expected_version
+        raise ArgumentError, "Invalid checksum" if check != checksum(decoded[0...-4])
+        payload
+      end
+
+      def checksum(bytes)
+        inner = Digest::SHA256.digest(bytes)
+        Digest::SHA256.digest(inner)[0...4]
+      end
+
+      private
+      def encode_int(int, leading_zeros=0)
+        # algorithm:
+        # 1. convert the bytes to a bignum
+        # 2. turn the bignum into a array of digits, least significant first
+        # 3. add any leading zero bytes as leading 0 digits
+        # 4. alphabatize the digits based upon the chosen alphabet
+        # 5. reverse the alphabetized digits (to get most significant digit first)
+
+        digits = []
+
+        # step 2
+        while int > 0
+          int, rem = int.divmod(BASE)
+          digits.push rem
+        end
+
+        # step 3
+        leading_zeros.times{ digits.push 0 }
+
+        digits
+          .map{|d| @alphabet[d]} # step 4
+          .reverse # step 5
+          .join
+      end
+
+      def decode_int(str)
+        int = str.reverse.each_char.with_index.inject(0) do |result, (digit, index)|
+                digit_val = @alphabet.index(digit)
+                raise ArgumentError, "#{digit} is not a valid base58 digit" if digit_val.nil?
+                result + (digit_val * (BASE**index))
+              end
+
+        int_to_bytes(int)
+      end
+
+      def bytes_to_int(bytes)
+        bytes.unpack("C*").inject do |result, byte|
+          result <<= 8
+          result + byte
+        end
+      end
+
+      def int_to_bytes(int)
+        return "\x00" if int == 0
+
+        bytes   = []
+        current = int
+
+        while current > 0
+          bytes.unshift(current & 0xFF)
+          current >>= 8
+        end
+
+        bytes.pack("C*")
+      end
+    end
+  end
+end

data/lib/stellar-base.rb

@@ -0,0 +1,23 @@
+require 'xdr'
+require 'rbnacl'
+require 'digest/sha2'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/kernel/reporting'
+
+# See ../generated for code-gen'ed files
+
+silence_warnings do
+  require 'stellar-base-generated'
+end
+Stellar.load_all!
+
+# extensions onto the generated files must be loaded manually, below
+
+require_relative './stellar/change_trust_op'
+require_relative './stellar/currency'
+require_relative './stellar/key_pair'
+require_relative './stellar/payment_op'
+require_relative './stellar/transaction'
+require_relative './stellar/transaction_envelope'
+require_relative './stellar/util/base58'

data/ruby-stellar-base.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stellar/base/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "stellar-base"
+  spec.version       = Stellar::Base::VERSION
+  spec.authors       = ["Scott Fleckenstein"]
+  spec.email         = ["scott@stellar.org"]
+  spec.summary       = %q{Stellar client library: XDR}
+  spec.homepage      = "https://github.com/stellar/ruby-stellar-vase"
+  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 = ["generated", "lib"]
+
+  spec.add_dependency "xdr"
+  spec.add_dependency "rbnacl"
+  spec.add_dependency "activesupport", "~> 4"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "xdrgen"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "octokit"
+  spec.add_development_dependency "netrc"
+  spec.add_development_dependency "yard"
+
+end

data/spec/lib/stellar/key_pair_spec.rb

@@ -0,0 +1,199 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Stellar::KeyPair do
+
+  describe ".from_seed" do
+    subject{ Stellar::KeyPair.from_seed(seed) }
+
+    context "when provided a base58check encoded seed" do
+      let(:seed){ "s9aaUNPaT9t1x7vCeDzQYvLZDm5XxSUKkwnqQowV6D3kMr678uZ" }
+      it { should be_a(Stellar::KeyPair) }
+    end
+
+    context "provided value is not base58 encoded" do
+      let(:seed){ "allmylifemyhearthasbeensearching" }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+    context "provided value is not base58 encoded as a seed" do
+      let(:raw_seed){ "allmylifemyhearthasbeensearching" }
+      let(:seed){ Stellar::Util::Base58.stellar.check_encode(:account_id, raw_seed) }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+  end
+
+  describe ".from_raw_seed" do
+    subject{ Stellar::KeyPair.from_raw_seed(raw_seed) }
+    
+    context "when the provided value is a 32-byte string" do
+      let(:raw_seed){ "allmylifemyhearthasbeensearching" }
+      it { should be_a(Stellar::KeyPair) }
+    end
+
+    context "when the provided value is < 32-byte string" do
+      let(:raw_seed){ "\xFF" * 31 }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+    context "when the provided value is > 32-byte string" do
+      let(:raw_seed){ "\xFF" * 33 }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+    context "when the provided value is a 32 character, but > 32 byte string (i.e. multi-byte characters)" do
+      let(:raw_seed){ "ü" + ("\x00" * 31) }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+  end
+
+  describe ".from_public_key" do
+    subject{ Stellar::KeyPair.from_public_key(key) }
+
+    context "when the provided value is a 32-byte string" do
+      let(:key){ "\xFF" * 32 }
+      it { should be_a(Stellar::KeyPair) }
+    end
+
+    context "when the provided value is < 32-byte string" do
+      let(:key){ "\xFF" * 31 }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+    context "when the provided value is > 32-byte string" do
+      let(:key){ "\xFF" * 33 }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+    context "when the provided value is a 32 character, but > 32 byte string (i.e. multi-byte characters)" do
+      let(:key){ "ü" + ("\x00" * 31) }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+  end
+
+  describe ".from_address" do
+    subject{ Stellar::KeyPair.from_address(address) }
+
+    context "when provided a base58check encoded account_id" do
+      let(:address){ "gsYRSEQhTffqA9opPepAENCr2WG6z5iBHHubxxbRzWaHf8FBWcu" }
+      it { should be_a(Stellar::KeyPair) }
+    end
+
+    context "provided value is not base58 encoded" do
+      let(:address){ "some address" }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+    context "provided value is not base58 encoded as an account_id" do
+      let(:public_key){ "\xFF" * 32 }
+      let(:address){ Stellar::Util::Base58.stellar.check_encode(:seed, public_key) }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+  end
+
+  describe ".random" do
+    subject{ Stellar::KeyPair.random }
+
+    it "returns a new KeyPair every time" do
+      other = Stellar::KeyPair.random
+      expect(subject.raw_seed == other.raw_seed).to eq(false)
+    end
+  end
+
+  describe "#public_key" do
+    let(:key_pair){ Stellar::KeyPair.random }
+    subject{ key_pair.public_key }
+
+    it { should be_a(String) }
+    it { should have_length(32) }
+  end
+
+  describe "#raw_seed" do
+    let(:key_pair){ Stellar::KeyPair.random }
+    subject{ key_pair.raw_seed }
+
+    it { should be_a(String) }
+    it { should have_length(32) }
+  end
+
+  describe "#address" do
+    let(:key_pair){ Stellar::KeyPair.random }
+    subject{ key_pair.address }
+    it{ should be_base58_check(:account_id)}
+  end
+
+  describe "#seed" do
+    let(:key_pair){ Stellar::KeyPair.random }
+    subject{ key_pair.seed }
+    it{ should be_base58_check(:seed)}
+  end
+
+  describe "#sign" do
+    let(:message) { "hello" } 
+    subject{ key_pair.sign(message) }
+
+    context "when the key_pair has no private key" do
+      let(:key_pair){ Stellar::KeyPair.from_public_key("\x00" * 32)}
+
+      it{ expect{ subject }.to raise_error("no private key") }
+    end
+
+    context "when the key_pair has both public/private keys" do
+      let(:key_pair){ Stellar::KeyPair.from_raw_seed("\x00" * 32)}
+
+      it { should have_length(64) }
+
+      it "should be a ed25519 signature" do
+        verification = key_pair.rbnacl_verify_key.verify(subject, message)
+        expect(verification).to be_truthy
+      end
+
+      context "when the message is nil" do
+        let(:message){ nil }
+        it { expect{subject}.to raise_error(TypeError) }
+      end
+    end
+  end
+
+  describe "#verify" do
+    let(:key_pair)  { Stellar::KeyPair.random }
+    let(:message)   { "hello" } 
+    subject         { key_pair.verify(signature, message) }
+
+    context "when the signature is correct" do
+      let(:signature) { key_pair.sign(message) } 
+      it{ should be_truthy }
+    end
+
+    context "when the signature is incorrect" do
+      let(:signature) { key_pair.sign("some other message") } 
+      it{ should be_falsey }
+    end
+
+    context "when the signature is invalid" do
+      let(:signature) { "food" } 
+      it{ should be_falsey }
+    end
+
+    context "when the signature is from a different key" do
+      let(:signature) { Stellar::KeyPair.random.sign(message) } 
+      it{ should be_falsey }
+    end
+
+  end
+
+  describe "#sign?" do
+    subject{ key_pair.sign? }
+
+    context "when the key_pair has no private key" do
+      let(:key_pair){ Stellar::KeyPair.from_public_key("\x00" * 32)}
+      it{ should eq(false) }
+    end
+
+    context "when the key_pair has both public/private keys" do
+      let(:key_pair){ Stellar::KeyPair.from_raw_seed("\x00" * 32)}
+      it{ should eq(true) }
+    end
+  end
+end

data/spec/lib/stellar/transaction_envelope_spec.rb

@@ -0,0 +1,93 @@
+require "spec_helper"
+
+describe Stellar::TransactionEnvelope do
+  let(:sender)  { Stellar::KeyPair.random }
+  let(:receiver){ Stellar::KeyPair.random }
+  let(:transaction) do
+    Stellar::Transaction.payment({
+      account:     sender,
+      destination: receiver,
+      sequence:    1,
+      amount:      [:native, 20000000]
+    })
+  end
+
+  let(:envelope){ transaction.to_envelope(*signers) }
+  
+  describe "#signed_correctly?" do
+    subject{ envelope.signed_correctly?(*verifiers) }
+
+    context "when unsigned" do
+      let(:signers)  { [] }
+      let(:verifiers){ [sender] }
+
+      it{ should be_falsey }
+    end
+
+    context "when signed by a single account" do
+      let(:signers)  { [sender] }
+      let(:verifiers){ signers }
+
+      context "and signed correctly" do
+        it{ should be_truthy }
+      end
+
+      context "and the signature is corrupted" do
+        before(:each){ envelope.signatures.first.signature = "\xFF" * 32}
+        it{ should be_falsey }
+      end
+
+      context "and the signature is from a different message" do
+        before(:each){ envelope.signatures = [sender.sign_decorated("hello")]}
+        it{ should be_falsey }
+      end
+
+      context "and the key for the signing account is not provided" do
+        let(:verifiers){ [] }
+        it{ should be_falsey }
+      end
+
+      context "and the key for the signing account is wrong" do
+        let(:verifiers){ [receiver] }
+        it{ should be_falsey }
+      end
+    end
+
+    context "when signed by a multiple accounts" do
+      let(:alternate_signer){ Stellar::KeyPair.random }
+      let(:signers)  { [sender, alternate_signer] }
+      let(:verifiers){ signers }
+
+      context "and all public keys are provided" do
+        it{ should be_truthy }
+      end
+
+      context "and all public keys are provided, with additional unused keys provided" do
+        let(:verifiers){ signers + [Stellar::KeyPair.random] }
+        it{ should be_truthy }
+      end
+
+      context "and not all public keys for the signers are provided" do
+        let(:verifiers){ [alternate_signer] }
+        it{ should be_falsey }
+      end
+
+      context "and one of the signatures is corrupted" do
+        before(:each){ envelope.signatures.last.signature = "\xFF" * 32}
+        it{ should be_falsey }
+      end
+
+      context "and the signature is from a different message" do
+        before(:each){ envelope.signatures = signers.map{|s| s.sign_decorated("hello")}}
+        it{ should be_falsey }
+      end
+    end
+    
+  end
+
+  describe "#hash" do
+    let(:signers)  { [sender] }
+    subject{ envelope.hash }
+    it{ should eq(Digest::SHA256.digest envelope.to_xdr)}
+  end
+end

data/spec/lib/stellar/transaction_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Stellar::Transaction do
+  subject do
+    Stellar::Transaction.new({
+      source_account: "\x00" * 32,
+      max_fee:        10,
+      seq_num:        1,
+      max_ledger:     10,
+      min_ledger:     0,
+      operations:     [
+        Stellar::Operation.new(body: Stellar::Operation::Body.new(:inflation, 1))
+      ]
+    })
+  end
+  let(:key_pair){ Stellar::KeyPair.random }
+  
+  describe "#sign" do
+    let(:result){ subject.sign(key_pair) }
+
+    it "returns a signature of SHA256(xdr form of the transaction)" do
+      xdr      = subject.to_xdr
+      hash     = Digest::SHA256.digest(xdr)
+      expected = key_pair.sign(hash)
+      expect(result).to eq(expected)
+    end
+  end
+
+  describe  "#to_envelope" do
+    let(:result){ subject.to_envelope(key_pair) }
+
+    it "return a Stellar::TransactionEnvelope" do
+      expect(result).to be_a(Stellar::TransactionEnvelope)
+    end
+
+    it "correctly signs the transaction" do
+      expect(result.signatures.length).to eq(1)
+      expect(result.signatures.first).to be_a(Stellar::DecoratedSignature)
+      expect(result.signatures.first.hint).to eq(key_pair.public_key_hint)
+      expect(result.signatures.first.signature).to eq(subject.sign(key_pair))
+    end
+  end
+end

data/spec/lib/stellar/util/base58_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Stellar::Util::Base58 do
+  subject{ Stellar::Util::Base58.new(Stellar::Util::Base58::BITCOIN_ALPHABET) }
+
+  describe "#decode" do
+    it "properly encodes" do
+      expect(decode "z").to eq_bytes("\x39")
+      expect(decode "111z").to eq_bytes("\x00\x00\x00\x39")
+      expect(decode "2UzHL").to eq_bytes("\xFF\xFF\xFF")
+    end
+
+    it "raises an ArgumentError when the string cantains an invalid character" do
+      expect{ decode "OOO" }.to raise_error(ArgumentError)
+      expect{ decode "\xFF" }.to raise_error(ArgumentError)
+      expect{ decode "\x00" }.to raise_error(ArgumentError)
+    end
+
+    def decode(bytes)
+      subject.decode(bytes)
+    end
+  end
+
+  describe "#check_decode" do
+    it "properly decodes" do
+      expect(decode :none, "cKyAv51").to eq_bytes("\x39")
+      expect(decode :seed, "RN3BaguaZ6Mi").to eq_bytes("\x00\x00\x00\x39")
+      expect(decode :account_id, "1Ahg1iQXoss").to eq_bytes("\xFF\xFF\xFF")
+    end
+
+    it "raises an ArgumentError if the decoded version byte does not match the expected value" do
+      expect{ decode :none, "1Ahg1iQXoss" }.to raise_error(ArgumentError)
+      expect{ decode :seed, "cKyAv51" }.to raise_error(ArgumentError)
+      expect{ decode :account_id, "RN3BaguaZ6Mi" }.to raise_error(ArgumentError)
+    end
+
+    it "raises an ArgumentError if the decoded value cannot be validated by the checksum" do
+      expect{decode :seed, "RN3BaguaZ6MM"}.to raise_error(ArgumentError)
+    end
+
+    def decode(version, bytes)
+      subject.check_decode(version, bytes)
+    end
+  end
+
+  describe"#encode" do
+    it "properly encodes" do
+      expect(encode "\x39").to eq("z")
+      expect(encode "\x00\x00\x00\x39").to eq("111z")
+      expect(encode "\xFF\xFF\xFF").to eq("2UzHL")
+    end
+
+    def encode(bytes)
+      subject.encode(bytes)
+    end
+  end
+
+  describe"#check_encode" do
+    it "properly encodes" do
+      expect(encode :none, "\x39").to eq("cKyAv51")
+      expect(encode :seed, "\x00\x00\x00\x39").to eq("RN3BaguaZ6Mi")
+      expect(encode :account_id, "\xFF\xFF\xFF").to eq("1Ahg1iQXoss")
+    end
+
+    it "raises an ArgumentError when an invalid version is provided" do
+      expect{ encode :floob, "\x39" }.to raise_error(ArgumentError)
+    end
+
+    def encode(version, bytes)
+      subject.check_encode(version, bytes)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'simplecov'
+SimpleCov.start
+
+require 'pry'
+require 'stellar-base'
+
+SPEC_ROOT = File.dirname(__FILE__)
+
+Dir["#{SPEC_ROOT}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+
+end

data/spec/support/matchers/be_base58_check.rb

@@ -0,0 +1,9 @@
+RSpec::Matchers.define :be_base58_check do |version_byte|
+  match do |actual|
+    begin
+      Stellar::Util::Base58.stellar.check_decode(version_byte, actual)
+    rescue ArgumentError
+      false
+    end
+  end
+end

data/spec/support/matchers/eq_bytes.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :eq_bytes do |expected|
+  match do |actual|
+    expected.force_encoding("ASCII-8BIT") == actual.force_encoding("ASCII-8BIT")
+  end
+end

data/spec/support/matchers/have_length.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :have_length do |length|
+  match do |actual|
+    actual.length == length
+  end
+end

data/tasks/rspec.rake

@@ -0,0 +1,6 @@
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => :spec
+rescue LoadError
+end

data/tasks/travis.rake

@@ -0,0 +1,9 @@
+file "lib/libsodium.so" => :build_libsodium do
+  cp $LIBSODIUM_PATH, "lib/libsodium.so"
+end
+
+task "ci:sodium" => "lib/libsodium.so"
+
+task :travis => %w(ci:sodium spec)
+
+CLEAN.add "lib/libsodium.*"