stellar-base 0.22.0 → 0.23.0.pre1

data/spec/lib/stellar/transaction_envelope_spec.rb

@@ -1,93 +0,0 @@
-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

@@ -1,132 +0,0 @@
-require "spec_helper"
-
-describe Stellar::Transaction do
-  subject do
-    Stellar::Transaction.new({
-      source_account: Stellar::AccountID.new(:public_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 ".path_payment_strict_receive" do
-    it 'works' do
-      tx = Stellar::Transaction.path_payment_strict_receive({
-        account: Stellar::KeyPair.random,
-        sequence: 1,
-        fee: 100,
-        destination: Stellar::KeyPair.random,
-        with: [:alphanum4, "USD", Stellar::KeyPair.master, 10],
-        amount: [:alphanum4, "EUR", Stellar::KeyPair.master, 9.2],
-      })
-
-      expect(tx.operations.size).to eq(1)
-      expect(tx.operations.first.body.arm).to eql(:path_payment_strict_receive_op)
-    end
-  end
-
-  describe ".path_payment_strict_send" do
-    it 'works' do
-      tx = Stellar::Transaction.path_payment_strict_send({
-        account: Stellar::KeyPair.random,
-        sequence: 1,
-        fee: 100,
-        destination: Stellar::KeyPair.random,
-        with: [:alphanum4, "USD", Stellar::KeyPair.master, 10],
-        amount: [:alphanum4, "EUR", Stellar::KeyPair.master, 9.2],
-      })
-
-      expect(tx.operations.size).to eq(1)
-      expect(tx.operations.first.body.arm).to eql(:path_payment_strict_send_op)
-    end
-  end
-
-  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_pairs) }
-
-
-    context "with a single key pair as a parameter" do
-      let(:key_pairs){ [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
-
-    context "with no keypairs provided as parameters" do
-      let(:key_pairs){ [] }
-
-      it "return a Stellar::TransactionEnvelope" do
-        expect(result).to be_a(Stellar::TransactionEnvelope)
-      end
-
-      it "adds no signatures" do
-        expect(result.signatures.length).to eq(0)
-      end
-    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

@@ -1,54 +0,0 @@
-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")
-      expect(decode :pre_auth_tx, "TBU2RRGLXH3E4VON").to eq_bytes("\x69\xa8\xc4\xcb\xb9\xf6\x4e")
-      expect(decode :hash_x, "XBU2RRGLXH3E4PNW").to eq_bytes("\x69\xa8\xc4\xcb\xb9\xf6\x4e")
-    end
-
-    it "raises an ArgumentError when an invalid version is provided" do
-      expect{ decode :floob, "SAAAAAAAAAADST3M" }.to raise_error(ArgumentError)
-    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")
-      expect(encode :pre_auth_tx, "\x69\xa8\xc4\xcb\xb9\xf6\x4e").to eq_bytes("TBU2RRGLXH3E4VON")
-      expect(encode :hash_x, "\x69\xa8\xc4\xcb\xb9\xf6\x4e").to eq_bytes("XBU2RRGLXH3E4PNW")
-    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

@@ -1,16 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

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

data/tasks/rspec.rake

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

data/tasks/travis.rake

@@ -1 +0,0 @@
-task :travis => %w(spec)

data/tasks/xdr.rake

@@ -1,45 +0,0 @@
-namespace :xdr do
-  xdr_defs = FileList[
-    'xdr/Stellar-types.x',
-    'xdr/Stellar-ledger-entries.x',
-    'xdr/Stellar-transaction.x',
-    'xdr/Stellar-ledger.x',
-    'xdr/Stellar-overlay.x',
-    'xdr/Stellar-SCP.x',
-  ]
-
-  task :update, [:ref] => [:clean, :generate]
-  task :generate => 'generated/stellar-base-generated.rb'
-
-  directory 'xdr'
-  directory 'generated'
-
-  file 'generated/stellar-base-generated.rb' => xdr_defs do |t|
-    require "xdrgen"
-
-    compilation = Xdrgen::Compilation.new(
-      t.sources,
-      output_dir: "generated",
-      namespace:  "stellar-base-generated",
-      language:   :ruby
-    )
-    compilation.compile
-  end
-
-  rule '.x', [:ref] => ['xdr'] do |t, args|
-    args.with_defaults(ref: :master)
-    core_file = github_client.contents("stellar/stellar-core", path: "src/#{t.name}", ref: args.ref)
-    IO.write(t.name, core_file.rels[:download].get.data)
-  end
-  
-  task :clean do
-    rm_rf 'xdr'
-    rm_rf 'generated'
-  end
-
-  def github_client
-    return @github_client if defined?(@github_client)
-    require 'octokit'
-    @github_client = Octokit::Client.new(netrc: true)
-  end
-end

data/xdr/Stellar-SCP.x

@@ -1,86 +0,0 @@
-// 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<>;
-};
-}