open-core 0.3.0

data/spec/lib/stellar/account_flags_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Stellar::AccountFlags do
+  subject{ Stellar::AccountFlags }
+  let(:raw)    { 3 }
+  let(:result) { subject.parse_mask raw }
+
+  it "parses correctly" do
+    expect(subject.parse_mask(1)).to eq([Stellar::AccountFlags.auth_required_flag])
+    expect(subject.parse_mask(2)).to eq([Stellar::AccountFlags.auth_revocable_flag])
+    expect(subject.parse_mask(3)).to eq([Stellar::AccountFlags.auth_required_flag, Stellar::AccountFlags.auth_revocable_flag])
+  end
+
+  it "makes correctly" do
+    expect(subject.make_mask([Stellar::AccountFlags.auth_required_flag])).to eq(1)
+    expect(subject.make_mask([Stellar::AccountFlags.auth_revocable_flag])).to eq(2)
+    expect(subject.make_mask([Stellar::AccountFlags.auth_required_flag, Stellar::AccountFlags.auth_revocable_flag])).to eq(3)
+  end
+end

data/spec/lib/stellar/asset_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Stellar::Asset, ".native" do
+  it "returns a asset instance whose type is 'AssetType.asset_type_native'" do
+    expect(Stellar::Asset.native.type).to eq(Stellar::AssetType.asset_type_native)
+  end
+end
+
+describe Stellar::Asset, ".alphanum4" do
+  it "returns a asset instance whose type is 'AssetType.asset_type_credit_alphanum4'" do
+    result = Stellar::Asset.alphanum4("USD", Stellar::KeyPair.master)
+    expect(result.type).to eq(Stellar::AssetType.asset_type_credit_alphanum4)
+  end
+
+  it "pads the code to 4 bytes, padding on the right and with null bytes" do
+    result = Stellar::Asset.alphanum4("USD", Stellar::KeyPair.master)
+    expect(result.code).to eq("USD\x00")
+  end
+end
+
+describe Stellar::Asset, ".alphanum12" do
+  it "returns a asset instance whose type is 'AssetType.asset_type_credit_alphanum12'" do
+    result = Stellar::Asset.alphanum12("USD", Stellar::KeyPair.master)
+    expect(result.type).to eq(Stellar::AssetType.asset_type_credit_alphanum12)
+  end
+
+  it "pads the code to 12 bytes, padding on the right and with null bytes" do
+    result = Stellar::Asset.alphanum12("USD", Stellar::KeyPair.master)
+    expect(result.code).to eq("USD\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+  end
+end
+
+describe Stellar::Asset, "#code" do
+  it "returns the asset_code for either alphanum4 or alphanum12 assets" do
+    a4 = Stellar::Asset.alphanum4("USD", Stellar::KeyPair.master)
+    a12 = Stellar::Asset.alphanum12("USD", Stellar::KeyPair.master)
+
+    expect(a4.code.strip).to eq("USD")
+    expect(a12.code.strip).to eq("USD")
+  end
+
+  it "raises an error when called on a native asset" do
+    expect{ Stellar::Asset.native.code }.to raise_error(RuntimeError)
+  end
+end

data/spec/lib/stellar/convert_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Stellar::Convert do
+  subject{ Stellar::Convert }
+  let(:raw)   { "\x01\x02\x03\x04" }
+  let(:hex)   { "01020304" }
+  let(:base64){ "AQIDBA==" }
+
+  describe "hex encoding" do
+    it "decodes" do
+      expect(subject.from_hex(hex)).to eq(raw)
+    end
+
+    it "encodes" do
+      expect(subject.to_hex(raw)).to eq(hex)
+    end
+
+    it "round trips" do
+      raw1 = subject.from_hex(hex)
+      hex1 = subject.to_hex(raw1)
+      expect(hex1).to eq(hex)
+
+
+      hex2 = subject.to_hex(raw)
+      raw2 = subject.from_hex(hex2)
+      expect(raw2).to eq(raw)
+    end
+  end
+
+  describe "base64 encoding" do
+    it "decodes" do
+      expect(subject.from_base64(base64)).to eq(raw)
+    end
+
+    it "encodes" do
+      expect(subject.to_base64(raw)).to eq(base64)
+    end
+
+    it "round trips" do
+      raw1 = subject.from_base64(base64)
+      base641 = subject.to_base64(raw1)
+      expect(base641).to eq(base64)
+
+
+      base642 = subject.to_base64(raw)
+      raw2 = subject.from_base64(base642)
+      expect(raw2).to eq(raw)
+    end
+  end
+
+
+  describe "#pk_to_address" do
+    let(:pk_raw){ "\x00" * 32 }
+    let(:pk_account_id){ Stellar::AccountID.new(:key_type_ed25519, pk_raw)}
+
+    it "converts a Stellar::AccountID into an address using StrKey.check_encode(:account_id)" do
+      address = Stellar::Util::StrKey.check_encode(:account_id, pk_raw)
+      expect(subject.pk_to_address(pk_account_id)).to eql(address)
+    end
+  end
+end

data/spec/lib/stellar/key_pair_spec.rb

@@ -0,0 +1,238 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Stellar::KeyPair do
+
+  describe ".from_seed" do
+    subject{ Stellar::KeyPair.from_seed(seed) }
+
+    context "when provided a strkey encoded seed" do
+      let(:seed){ "SBDA4J4PYZJEXWDTHFZBIGFVF2745BTKDKADWDQF72QXP55BP6XOV3B6" }
+      it { should be_a(Stellar::KeyPair) }
+    end
+
+    context "provided value is not strkey encoded" do
+      let(:seed){ "allmylifemyhearthasbeensearching" }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+    context "provided value is not strkey encoded as a seed" do
+      let(:raw_seed){ "allmylifemyhearthasbeensearching" }
+      let(:seed){ Stellar::Util::StrKey.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 strkey encoded account_id" do
+      let(:address){ "GBRAINV4XDXEINVTNN53GOIGTN4B3BK65N6Q2ZBOMXHGHT347OQVNYZQ" }
+      it { should be_a(Stellar::KeyPair) }
+    end
+
+    context "provided value is not strkey encoded" do
+      let(:address){ "some address" }
+      it { expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+    context "provided value is not strkey encoded as an account_id" do
+      let(:public_key){ "\xFF" * 32 }
+      let(:address){ Stellar::Util::StrKey.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 ".master" do
+    subject{ Stellar::KeyPair.master }
+
+    it "returns a keypair whose raw_seed is the current_network_id" do
+      expect(subject.raw_seed).to eql(Stellar.current_network_id)
+    end
+  end
+
+  describe "#raw_public_key" do
+    let(:key_pair){ Stellar::KeyPair.random }
+    subject{ key_pair.raw_public_key }
+
+    it { should be_a(String) }
+    it { should have_length(32) }
+  end
+
+  describe "#public_key" do
+    let(:key_pair){ Stellar::KeyPair.random }
+    subject{ key_pair.public_key }
+
+    it { should be_a(Stellar::PublicKey) }
+  end
+
+  describe "#account_id" do
+    let(:key_pair){ Stellar::KeyPair.random }
+    subject{ key_pair.account_id }
+
+    it { should be_a(Stellar::AccountID) }
+
+    it "contains the public key" do
+        expect(subject.ed25519!).to eql(key_pair.raw_public_key)
+    end
+  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 "#signature_hint" do
+    let(:key_pair){ Stellar::KeyPair.random }
+    subject{ key_pair.signature_hint }
+
+    it { should be_a(String) }
+    it { should have_length(4) }
+
+    it "is the last 4 bytes of the encoded account_id" do
+      expected = key_pair.account_id.to_xdr[-4..-1]
+      expect(subject).to eql(expected)
+    end
+  end
+
+  describe "#address" do
+    let(:key_pair){ Stellar::KeyPair.random }
+    subject{ key_pair.address }
+    it{ should be_strkey(:account_id)}
+  end
+
+  describe "#seed" do
+    let(:key_pair){ Stellar::KeyPair.random }
+    subject{ key_pair.seed }
+    it{ should be_strkey(: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/networks_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+describe Stellar, ".default_network=" do
+
+  before(:each){ Stellar.default_network = "foo" }
+  after(:each){ Stellar.default_network = nil }
+
+  it "sets the value returned by current_network " do
+    expect(Stellar.current_network).to eql("foo")
+  end
+
+end
+
+describe Stellar, ".current_network" do
+
+  after(:each){ Stellar.default_network = nil }
+
+  it "returns the public network absent any other configuration" do
+    expect(Stellar.current_network).to eql(Stellar::Networks::PUBLIC)
+  end
+
+  it "returns the default network if configured and not within a call to on_network" do
+    Stellar.default_network = "foo"
+    expect(Stellar.current_network).to eql("foo")
+  end
+
+  it "returns the network as specified by on_network, even when a default is set" do
+    Stellar.default_network = "foo"
+
+    Stellar.on_network "bar" do
+      expect(Stellar.current_network).to eql("bar")
+    end
+
+    expect(Stellar.current_network).to eql("foo")
+  end
+end
+
+describe Stellar, ".current_network_id" do
+  it "returns the sha256 of the current_network" do
+    expect(Stellar.current_network_id).to eql(Digest::SHA256.digest(Stellar.current_network))
+  end
+end
+
+describe Stellar, ".on_network" do
+
+  after(:each){ Thread.current["stellar_network_passphrase"] = nil }
+
+
+  it "sets the current_network and a thread local" do
+    Stellar.on_network "bar" do
+      expect(Stellar.current_network).to eql("bar")
+      expect(Thread.current["stellar_network_passphrase"]).to eql("bar")
+    end
+  end
+
+
+  it "nests" do
+    Stellar.on_network "foo" do
+      expect(Stellar.current_network).to eql("foo")
+      Stellar.on_network "bar" do
+        expect(Stellar.current_network).to eql("bar")
+      end
+      expect(Stellar.current_network).to eql("foo")
+    end
+  end
+
+
+  it "resets the network value when an error is raised" do
+    begin
+      Stellar.on_network "foo" do
+        raise "kablow"
+      end
+    rescue
+      expect(Stellar.current_network).to_not eql("foo")
+    end
+  end
+end

data/spec/lib/stellar/path_payment_result_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+
+describe Stellar::PathPaymentResult, "#send_amount" do
+
+
+  context "when the result is not successful" do
+    subject{ Stellar::PathPaymentResult.new(:path_payment_malformed) }
+
+    it "raises an exception if the result is not successful" do
+      expect{ subject.send_amount }.to raise_error(XDR::ArmNotSetError)
+    end
+  end
+
+  context "when the result has no claimed offers" do
+    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
+    let(:path_success){ Stellar::PathPaymentResult::Success.new(last: simple_success) }
+
+    subject{ Stellar::PathPaymentResult.new(:path_payment_success, path_success) }
+
+    it "returns the amount from the 'last' component" do
+      expect(subject.send_amount).to eql(100)
+    end
+  end
+
+
+  context "with simple 1-hop result" do
+    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
+    let(:offers) do
+      [Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200)]
+    end
+
+    let(:path_success) do
+      Stellar::PathPaymentResult::Success.new({
+        offers: offers,
+        last:   simple_success,
+      })
+    end
+
+    subject{ Stellar::PathPaymentResult.new(:path_payment_success, path_success) }
+
+    it "returns the amount from the ClaimOfferAtom" do
+      expect(subject.send_amount).to eql(200)
+    end
+  end
+
+  context "with 1-hop result that claimed multiple offers" do
+    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
+    let(:offers) do
+      [
+        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
+        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
+      ]
+    end
+
+    let(:path_success) do
+      Stellar::PathPaymentResult::Success.new({
+        offers: offers,
+        last:   simple_success,
+      })
+    end
+
+    subject{ Stellar::PathPaymentResult.new(:path_payment_success, path_success) }
+
+    it "returns the summed amount from the ClaimOfferAtoms" do
+      expect(subject.send_amount).to eql(400)
+    end
+  end
+
+
+  context "with multi-hop result that claimed multiple offers" do
+    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
+    let(:otherAsset){ Stellar::Asset.alphanum4("USD", Stellar::KeyPair.random) }
+    let(:offers) do
+      [
+        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
+        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
+        Stellar::ClaimOfferAtom.new(asset_bought: otherAsset, amount_bought: 200),
+      ]
+    end
+
+    let(:path_success) do
+      Stellar::PathPaymentResult::Success.new({
+        offers: offers,
+        last:   simple_success,
+      })
+    end
+
+    subject{ Stellar::PathPaymentResult.new(:path_payment_success, path_success) }
+
+    it "returns the summed amount from the ClaimOfferAtoms" do
+      expect(subject.send_amount).to eql(400)
+    end
+  end
+
+end