stellar-base 0.22.0 → 0.23.0.pre1

data/examples/offer.rb

@@ -1,75 +0,0 @@
-#!/usr/bin/env ruby
-
-# This is an example of using the higher level "payment" wrapper. Notice
-# that we are using KeyPair instead of the raw rbnacl keys and that we need
-# not build the entire heirarchy of xdr object manually.
-#
-# You can see where these helpers are defined in the files underneath /lib,
-# which is where we extend the xdrgen generated source files with our higher
-# level api.
-#
-# NOTE: due to the way that sequence number for a new account are set, this
-# example is pretty cumbersome to run.  It is only used for illustrative purposes
-# of the flow
-
-require 'stellar-base'
-require 'faraday'
-require 'faraday_middleware'
-
-$server = Faraday.new(url: "http://localhost:39132") do |conn|
-  conn.response :json
-  conn.adapter Faraday.default_adapter
-end
-
-def submit(key, tx)
-  b64      = tx.to_envelope(key).to_xdr(:base64)
-  response = $server.get('tx', blob: b64)
-  p response.body
-end
-
-master      = Stellar::KeyPair.master
-destination = Stellar::KeyPair.master
-
-submit master, Stellar::Transaction.payment({
-  account:     master,
-  destination: destination,
-  sequence:    1,
-  amount:      [:native, 2000]
-})
-
-# NOTE: after this step, you need to get the sequence number for destination
-# Which is based off of the ledger sequence number it was funded in.
-gets # pause to get the account's sequence from the hayashi db
-
-destination_sequence = FILL_ME_IN
-# destination_sequence = 17179869185
-
-submit destination, Stellar::Transaction.change_trust({
-  account:    destination,
-  sequence:   destination_sequence,
-  line:       [:alphanum4, "USD\x00", master],
-  limit:      1000
-})
-
-submit destination, Stellar::Transaction.change_trust({
-  account:    destination,
-  sequence:   destination_sequence + 1,
-  line:       [:alphanum4, "EUR\x00", master],
-  limit:      1000
-})
-
-submit master, Stellar::Transaction.payment({
-  account:     master,
-  destination: destination,
-  sequence:    destination_sequence + 2,
-  amount:      [:alphanum4, "USD\x00", master, 1000]
-})
-
-submit master, Stellar::Transaction.manage_offer({
-  account:    destination,
-  sequence:   destination_sequence + 3,
-  selling:    [:alphanum4, "USD\x00", usd_gateway],
-  buying:     [:alphanum4, "EUR\x00", eur_gateway],
-  amount:     100,
-  price:      2.0,
-})

data/examples/transaction_merge.rb

@@ -1,23 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'stellar-base'
-
-master      = Stellar::KeyPair.master
-destination = Stellar::KeyPair.master
-
-tx1 = Stellar::Transaction.payment({
-  account:     master,
-  destination: destination,
-  sequence:    1,
-  amount:      [:native, 20]
-})
-
-tx2 = Stellar::Transaction.payment({
-  account:     master,
-  destination: destination,
-  sequence:    2,
-  amount:      [:native, 20]
-})
-
-hex = tx1.merge(tx2).to_envelope(master).to_xdr(:base64)
-puts hex

data/ruby-stellar-base.gemspec

@@ -1,34 +0,0 @@
-# coding: utf-8
-require_relative './lib/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-base"
-  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", "~> 3.0.0"
-  spec.add_dependency "digest-crc"
-  spec.add_dependency "base32"
-  spec.add_dependency "rbnacl", ">= 6.0"
-  spec.add_dependency "activesupport", ">= 5.0.0"
-
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 12.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/account_flags_spec.rb

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

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

@@ -1,61 +0,0 @@
-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(:public_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

@@ -1,251 +0,0 @@
-# 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 "#signer_key" do
-    let(:key_pair){ Stellar::KeyPair.random }
-    subject{ key_pair.signer_key }
-
-    it { should be_a(Stellar::SignerKey) }
-
-    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