stellar-base 0.20.0 → 0.23.0.rc2

data/generated/stellar/path_payment_result_code.rb

@@ -1,47 +0,0 @@
-# This code was automatically generated using xdrgen
-# DO NOT EDIT or your changes may be overwritten
-
-require 'xdr'
-
-# === xdr source ============================================================
-#
-#   enum PathPaymentResultCode
-#   {
-#       // codes considered as "success" for the operation
-#       PATH_PAYMENT_SUCCESS = 0, // success
-#   
-#       // codes considered as "failure" for the operation
-#       PATH_PAYMENT_MALFORMED = -1,          // bad input
-#       PATH_PAYMENT_UNDERFUNDED = -2,        // not enough funds in source account
-#       PATH_PAYMENT_SRC_NO_TRUST = -3,       // no trust line on source account
-#       PATH_PAYMENT_SRC_NOT_AUTHORIZED = -4, // source not authorized to transfer
-#       PATH_PAYMENT_NO_DESTINATION = -5,     // destination account does not exist
-#       PATH_PAYMENT_NO_TRUST = -6,           // dest missing a trust line for asset
-#       PATH_PAYMENT_NOT_AUTHORIZED = -7,     // dest not authorized to hold asset
-#       PATH_PAYMENT_LINE_FULL = -8,          // dest would go above their limit
-#       PATH_PAYMENT_NO_ISSUER = -9,          // missing issuer on one asset
-#       PATH_PAYMENT_TOO_FEW_OFFERS = -10,    // not enough offers to satisfy path
-#       PATH_PAYMENT_OFFER_CROSS_SELF = -11,  // would cross one of its own offers
-#       PATH_PAYMENT_OVER_SENDMAX = -12       // could not satisfy sendmax
-#   };
-#
-# ===========================================================================
-module Stellar
-  class PathPaymentResultCode < XDR::Enum
-    member :path_payment_success,            0
-    member :path_payment_malformed,          -1
-    member :path_payment_underfunded,        -2
-    member :path_payment_src_no_trust,       -3
-    member :path_payment_src_not_authorized, -4
-    member :path_payment_no_destination,     -5
-    member :path_payment_no_trust,           -6
-    member :path_payment_not_authorized,     -7
-    member :path_payment_line_full,          -8
-    member :path_payment_no_issuer,          -9
-    member :path_payment_too_few_offers,     -10
-    member :path_payment_offer_cross_self,   -11
-    member :path_payment_over_sendmax,       -12
-
-    seal
-  end
-end

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/bloom-solutions/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