auction-ruby-base 0.1.1

data/spec/lib/stellar/price_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Stellar::Price, "#from_f" do
+  subject{ Stellar::Price }
+  let(:seed){ 225571644875421139403973254661022579608 } #generated using Random.new
+  let(:random){ Random.new(seed) } 
+  let(:iterations){ ENV["SMOKE_ITERATIONS"].present? ? ENV["SMOKE_ITERATIONS"].to_i : 2000}
+
+  it "withstands a random smoke test" do
+    iterations.times do |i|
+      expected = random.rand
+      actual_p = subject.from_f(expected)
+      actual = actual_p.to_f
+
+      expect(actual).to be_within(0.000000001).of(actual)
+      expect(actual_p.n).to be <= Stellar::Price::MAX_PRECISION
+      expect(actual_p.d).to be <= Stellar::Price::MAX_PRECISION
+    end
+  end
+
+  it "works with bigdecimal" do
+      whole      = random.rand(1_000_000)
+      fractional = random.rand(10_000_000) # seven significant digits available for fractional
+      
+      expected = BigDecimal.new("#{whole}.#{fractional}")
+      actual_p = subject.from_f(expected)
+      actual = BigDecimal.new(actual_p.n) / BigDecimal.new(actual_p.d) 
+
+      expect(actual).to be_within(BigDecimal.new("0.000000001")).of(actual)
+      expect(actual_p.n).to be <= Stellar::Price::MAX_PRECISION
+      expect(actual_p.d).to be <= Stellar::Price::MAX_PRECISION
+  end
+
+end

data/spec/lib/stellar/thresholds_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Stellar::Thresholds, ".parse" do
+  subject{ Stellar::Thresholds }
+  let(:raw)    { "\x01\x02\x03\x04" }
+  let(:result) { subject.parse raw }
+
+  it "sets master_weight as the 1st byte" do
+    expect(result[:master_weight]).to eq(1)
+  end
+
+  it "sets low as the 2nd byte" do
+    expect(result[:low]).to eq(2)
+  end
+
+  it "sets medium as the 3rd byte" do
+    expect(result[:medium]).to eq(3)
+  end
+
+  it "sets high as the 4th byte" do
+    expect(result[:high]).to eq(4)
+  end
+end
+
+describe Stellar::Thresholds, ".make" do
+  subject{ Stellar::Thresholds }
+  let(:good){{master_weight: 1, low: 2, medium: 3, high: 4}}
+
+  it "works" do
+    expect(subject.make(good)).to eq("\x01\x02\x03\x04")
+  end
+
+  it "errors unless all components are provided" do
+    expect{ subject.make(good.except(:master_weight)) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.except(:low)) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.except(:medium)) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.except(:high)) }.to raise_error(ArgumentError)
+  end
+
+  it "errors unless all components are numbers" do
+    expect{ subject.make(good.merge(master_weight: "hello")) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.merge(low: "hello")) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.merge(medium: "hello")) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.merge(high: "hello")) }.to raise_error(ArgumentError)
+  end
+
+  it "errors unless all components are in (0..255)" do
+    expect{ subject.make(good.merge(master_weight: -1)) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.merge(master_weight: 256)) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.merge(low: -1)) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.merge(low: 256)) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.merge(medium: -1)) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.merge(medium: 256)) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.merge(high: -1)) }.to raise_error(ArgumentError)
+    expect{ subject.make(good.merge(high: 256)) }.to raise_error(ArgumentError)
+  end
+
+  it "ignores additional keys" do
+    expect{ subject.make(good.merge(foo: "a string")) }.not_to raise_error
+  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,83 @@
+require "spec_helper"
+
+describe Stellar::Transaction do
+  subject do
+    Stellar::Transaction.new({
+      source_account: Stellar::AccountID.new(:key_type_ed25519, "\x00" * 32),
+      fee:            10,
+      seq_num:        1,
+      memo:           Stellar::Memo.new(:memo_none),
+      ext:            Stellar::Transaction::Ext.new(0),
+      operations:     [
+        Stellar::Operation.new(body: Stellar::Operation::Body.new(:inflation))
+      ]
+    })
+  end
+  let(:key_pair){ Stellar::KeyPair.random }
+
+  describe "#sign" do
+    let(:result){ subject.sign(key_pair) }
+
+    it "returns a signature of SHA256(signature_base of the transaction)" do
+      hash     = Digest::SHA256.digest(subject.signature_base)
+      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.signature_hint)
+      expect(result.signatures.first.signature).to eq(subject.sign(key_pair))
+    end
+  end
+
+  describe "#signature_base" do
+
+    it "is prefixed with the current network id" do
+      expect(subject.signature_base).to start_with(Stellar.current_network_id)
+    end
+
+    it "includes the envelope type" do
+      expect(subject.signature_base[32...36]).to eql("\x00\x00\x00\x02")
+    end
+
+  end
+
+  describe ".for_account's memo assignment" do
+    let(:attrs){{account: Stellar::KeyPair.random, sequence: 1}}
+
+    def make(memo)
+      tx = Stellar::Transaction.for_account(attrs.merge(memo: memo))
+      tx.memo
+    end
+
+    it "sets to an ID memo when a number is provided" do
+      expect(make(3)).to eql(Stellar::Memo.new(:memo_id, 3))
+    end
+
+    it "sets to an text memo when a number is provided" do
+      expect(make("hello")).to eql(Stellar::Memo.new(:memo_text, "hello"))
+    end
+
+    it "uses the provided value directly if already a memo" do
+      expect(make(Stellar::Memo.new(:memo_text, "hello"))).to eql(Stellar::Memo.new(:memo_text, "hello"))
+    end
+
+
+    it "allows a 2-element array as shorthand" do
+      expect(make([:id, 3])).to eql(Stellar::Memo.new(:memo_id, 3))
+      expect(make([:text, "h"])).to eql(Stellar::Memo.new(:memo_text, "h"))
+      expect(make([:hash, "h"])).to eql(Stellar::Memo.new(:memo_hash, "h"))
+      expect(make([:return, "h"])).to eql(Stellar::Memo.new(:memo_return, "h"))
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Stellar::Util::StrKey do
+
+subject{ Stellar::Util::StrKey }
+
+  describe "#check_decode" do
+    it "properly decodes" do
+      expect(decode :seed, "SAAAAAAAAAADST3H").to eq_bytes("\x00\x00\x00\x00\x00\x00\x39")
+      expect(decode :account_id, "GD777777777764TU").to eq_bytes("\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
+      expect(decode :account_id, "GBQWWBFLRP3BXZD5").to eq_bytes("\x61\x6b\x04\xab\x8b\xf6\x1b")
+    end
+
+    it "raises an ArgumentError if the decoded version byte does not match the expected value" do
+      expect{ decode :seed, "GD777777777764TU" }.to raise_error(ArgumentError)
+      expect{ decode :account_id, "SAAAAAAAAAADST3M" }.to raise_error(ArgumentError)
+    end
+
+    it "raises an ArgumentError if the decoded value cannot be validated by the checksum" do
+      expect{decode :seed, "SAAAAAAAAAADST3M"}.to raise_error(ArgumentError)
+    end
+
+    def decode(version, bytes)
+      subject.check_decode(version, bytes)
+    end
+  end
+
+  describe"#check_encode" do
+    it "properly encodes" do
+      expect(encode :seed, "\x00\x00\x00\x00\x00\x00\x39").to eq("SAAAAAAAAAADST3H")
+      expect(encode :account_id, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF").to eq("GD777777777764TU")
+      expect(encode :account_id, "\x61\x6b\x04\xab\x8b\xf6\x1b").to eq("GBQWWBFLRP3BXZD5")
+    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_strkey.rb

@@ -0,0 +1,9 @@
+RSpec::Matchers.define :be_strkey do |version_byte|
+  match do |actual|
+    begin
+      Stellar::Util::StrKey.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 @@
+task :travis => %w(spec)

data/tasks/xdr.rake

@@ -0,0 +1,50 @@
+namespace :xdr do
+
+  # As Hayashi adds more .x files, we'll need to update this array
+  # Prior to launch, we should be separating our .x files into a separate
+  # repo, and should be able to improve this integration.
+  HAYASHI_XDR = [
+                 "src/xdr/Stellar-types.x",
+                 "src/xdr/Stellar-ledger-entries.x",
+                 "src/xdr/Stellar-transaction.x",
+                 "src/xdr/Stellar-ledger.x",
+                 "src/xdr/Stellar-overlay.x",
+                 "src/xdr/Stellar-SCP.x",
+                ]
+
+  LOCAL_XDR_PATHS = HAYASHI_XDR.map{ |src| "xdr/" + File.basename(src) }
+
+  task :update => [:download, :generate]
+
+  task :download do
+    require 'octokit'
+    require 'base64'
+    FileUtils.rm_rf "xdr/"
+    FileUtils.mkdir_p "xdr"
+
+    client = Octokit::Client.new(:netrc => true)
+
+    HAYASHI_XDR.each do |src|
+      local_path = "xdr/" + File.basename(src)
+      encoded    = client.contents("stellar/stellar-core", path: src).content
+      decoded    = Base64.decode64 encoded
+
+      IO.write(local_path, decoded)
+    end
+  end
+
+  task :generate do
+    require "pathname"
+    require "xdrgen"
+    require 'fileutils'
+    FileUtils.rm_rf "generated"
+
+    compilation = Xdrgen::Compilation.new(
+      LOCAL_XDR_PATHS,
+      output_dir: "generated",
+      namespace:  "stellar-base-generated",
+      language:   :ruby
+    )
+    compilation.compile
+  end
+end

data/xdr/Stellar-SCP.x

@@ -0,0 +1,86 @@
+// Copyright 2015 Stellar Development Foundation and contributors. Licensed
+// under the Apache License, Version 2.0. See the COPYING file at the root
+// of this distribution or at http://www.apache.org/licenses/LICENSE-2.0
+
+%#include "xdr/Stellar-types.h"
+
+namespace stellar
+{
+
+typedef opaque Value<>;
+
+struct SCPBallot
+{
+    uint32 counter; // n
+    Value value;    // x
+};
+
+enum SCPStatementType
+{
+    SCP_ST_PREPARE = 0,
+    SCP_ST_CONFIRM = 1,
+    SCP_ST_EXTERNALIZE = 2,
+    SCP_ST_NOMINATE = 3
+};
+
+struct SCPNomination
+{
+    Hash quorumSetHash; // D
+    Value votes<>;      // X
+    Value accepted<>;   // Y
+};
+
+struct SCPStatement
+{
+    NodeID nodeID;    // v
+    uint64 slotIndex; // i
+
+    union switch (SCPStatementType type)
+    {
+    case SCP_ST_PREPARE:
+        struct
+        {
+            Hash quorumSetHash;       // D
+            SCPBallot ballot;         // b
+            SCPBallot* prepared;      // p
+            SCPBallot* preparedPrime; // p'
+            uint32 nC;                // c.n
+            uint32 nH;                // h.n
+        } prepare;
+    case SCP_ST_CONFIRM:
+        struct
+        {
+            SCPBallot ballot;   // b
+            uint32 nPrepared;   // p.n
+            uint32 nCommit;     // c.n
+            uint32 nH;          // h.n
+            Hash quorumSetHash; // D
+        } confirm;
+    case SCP_ST_EXTERNALIZE:
+        struct
+        {
+            SCPBallot commit;         // c
+            uint32 nH;                // h.n
+            Hash commitQuorumSetHash; // D used before EXTERNALIZE
+        } externalize;
+    case SCP_ST_NOMINATE:
+        SCPNomination nominate;
+    }
+    pledges;
+};
+
+struct SCPEnvelope
+{
+    SCPStatement statement;
+    Signature signature;
+};
+
+// supports things like: A,B,C,(D,E,F),(G,H,(I,J,K,L))
+// only allows 2 levels of nesting
+struct SCPQuorumSet
+{
+    uint32 threshold;
+    PublicKey validators<>;
+    SCPQuorumSet innerSets<>;
+};
+}