stellar-base 0.0.20 → 0.1.0

data/lib/stellar/operation.rb

@@ -31,7 +31,7 @@ module Stellar
     # in the necessary XDR structs to be included within a
     # transactions `operations` array.
     #
-    # @see Stellar::Currency
+    # @see Stellar::Asset
     #
     # @param [Hash] attributes the attributes to create the operation with
     # @option attributes [Stellar::KeyPair] :destination the receiver of the payment
@@ -40,13 +40,13 @@ module Stellar
     #                              Stellar::PaymentOp body
     def self.payment(attributes={})
       destination = attributes[:destination]
-      currency, amount = extract_amount(attributes[:amount])
+      asset, amount = extract_amount(attributes[:amount])
 
       raise ArgumentError unless destination.is_a?(KeyPair)
 
 
       op             = PaymentOp.new
-      op.currency    = currency
+      op.asset       = asset
       op.amount      = amount
       op.destination = destination.account_id
 
@@ -60,29 +60,29 @@ module Stellar
     # in the necessary XDR structs to be included within a
     # transactions `operations` array.
     #
-    # @see Stellar::Currency
+    # @see Stellar::Asset
     #
     # @param [Hash] attributes the attributes to create the operation with
     # @option attributes [Stellar::KeyPair] :destination the receiver of the payment
     # @option attributes [Array] :amount the amount to pay
-    # @option attributes [Array] :with the source currency and maximum allowed source amount to pay with
-    # @option attributes [Array<Stellar::Currency>] :path the payment path to use
+    # @option attributes [Array] :with the source asset and maximum allowed source amount to pay with
+    # @option attributes [Array<Stellar::Asset>] :path the payment path to use
     #
     # @return [Stellar::Operation] the built operation, containing a
     #                              Stellar::PaymentOp body
     def self.path_payment(attributes={})
       destination             = attributes[:destination]
-      currency, amount        = extract_amount(attributes[:amount])
-      send_currency, send_max = extract_amount(attributes[:with])
-      path                    = (attributes[:path] || []).map{|p| Stellar::Currency.send(*p)}
+      asset, amount           = extract_amount(attributes[:amount])
+      send_asset, send_max    = extract_amount(attributes[:with])
+      path                    = (attributes[:path] || []).map{|p| Stellar::Asset.send(*p)}
 
       raise ArgumentError unless destination.is_a?(KeyPair)
 
       op               = PathPaymentOp.new
-      op.send_currency = send_currency
+      op.send_asset    = send_asset
       op.send_max      = send_max
       op.destination   = destination.account_id
-      op.dest_currency = currency
+      op.dest_asset    = asset
       op.dest_amount   = amount
       op.path          = path
 
@@ -112,13 +112,13 @@ module Stellar
     # transactions `operations` array.
     #
     # @param [Hash] attributes the attributes to create the operation with
-    # @option attributes [Stellar::Currrency] :line the currency to trust
+    # @option attributes [Stellar::Currrency] :line the asset to trust
     # @option attributes [Fixnum] :limit the maximum amount to trust
     #
     # @return [Stellar::Operation] the built operation, containing a
     #                              Stellar::ChangeTrustOp body
     def self.change_trust(attributes={})
-      line  = Currency.send(*attributes[:line])
+      line  = Asset.send(*attributes[:line])
       limit = attributes[:limit]
 
       raise ArgumentError, "Bad :limit #{limit}" unless limit.is_a?(Integer)
@@ -131,8 +131,8 @@ module Stellar
     end
 
     def self.manage_offer(attributes={})
-      taker_pays = Currency.send(*attributes[:taker_pays])
-      taker_gets = Currency.send(*attributes[:taker_gets])
+      taker_pays = Asset.send(*attributes[:taker_pays])
+      taker_gets = Asset.send(*attributes[:taker_gets])
       amount     = attributes[:amount]
       offer_id   = attributes[:offer_id] || 0
       price      = Price.from_f(attributes[:price])
@@ -151,8 +151,8 @@ module Stellar
     end
 
     def self.create_passive_offer(attributes={})
-      taker_pays = Currency.send(*attributes[:taker_pays])
-      taker_gets = Currency.send(*attributes[:taker_gets])
+      taker_pays = Asset.send(*attributes[:taker_pays])
+      taker_gets = Asset.send(*attributes[:taker_gets])
       amount     = attributes[:amount]
       price      = Price.from_f(attributes[:price])
 
@@ -214,7 +214,7 @@ module Stellar
     #
     # @param [Hash] attributes the attributes to create the operation with
     # @option attributes [Stellar::KeyPair]  :trustor
-    # @option attributes [Stellar::Currency] :currency
+    # @option attributes [Stellar::Asset] :asset
     #
     # @return [Stellar::Operation] the built operation, containing a
     #                              Stellar::AllowTrustOp body
@@ -223,17 +223,17 @@ module Stellar
 
       trustor   = attributes[:trustor]
       authorize = attributes[:authorize]
-      currency  = Currency.send(*attributes[:currency])
+      asset     = Asset.send(*attributes[:asset])
 
       raise ArgumentError, "Bad :trustor" unless trustor.is_a?(Stellar::KeyPair)
       raise ArgumentError, "Bad :authorize" unless authorize == !!authorize # check boolean
-      raise ArgumentError, "Bad :currency" unless currency.type == Stellar::CurrencyType.currency_type_alphanum
+      raise ArgumentError, "Bad :asset" unless asset.type == Stellar::AssetType.asset_type_credit_alphanum4
 
-      atc = AllowTrustOp::Currency.new(:currency_type_alphanum, currency.code)
+      atc = AllowTrustOp::Asset.new(:asset_type_credit_alphanum4, asset.code)
 
       op.trustor   = trustor.account_id
       op.authorize = authorize
-      op.currency  = atc
+      op.asset     = atc
 
       return make(attributes.merge({
         body:[:allow_trust, op]
@@ -279,9 +279,9 @@ module Stellar
     private
     def self.extract_amount(a)
       amount   = a.last
-      currency = Stellar::Currency.send(*a[0...-1])
+      asset    = Stellar::Asset.send(*a[0...-1])
 
-      return currency, amount
+      return asset, amount
     end
   end
 end

data/lib/stellar/path_payment_result.rb

@@ -7,8 +7,8 @@ module Stellar
       s = success!
       return s.last.amount if s.offers.blank?
 
-      source_currency = s.offers.first.currency_send
-      source_offers = s.offers.take_while{|o| o.currency_send == source_currency}
+      source_asset = s.offers.first.asset_send
+      source_offers = s.offers.take_while{|o| o.asset_send == source_asset}
 
       source_offers.map(&:amount_send).sum
     end

data/lib/stellar/util/strkey.rb

@@ -0,0 +1,43 @@
+module Stellar
+  module Util
+
+    require 'base32'
+    require 'digest/crc16_xmodem'
+
+    class StrKey
+
+      VERSION_BYTES = {
+        account_id: [ 6 << 3].pack("C"), # Base32-encodes to 'G...'
+        seed:       [18 << 3].pack("C"), # Base32-encodes to 'S...'
+      }
+
+      def self.check_encode(version, byte_str)
+        version_byte = VERSION_BYTES[version]
+        raise ArgumentError, "Invalid version: #{version}" if version_byte.blank?
+        payload = version_byte + byte_str.dup.force_encoding("BINARY")
+        check   = checksum(payload)
+        Base32.encode(payload + check)
+      end
+
+      def self.check_decode(expected_version, str)
+        decoded      = Base32.decode(str) rescue (raise ArgumentError, "Invalid base32 string")
+        version_byte = decoded[0]
+        payload      = decoded[1...-2]
+        check        = decoded[-2..-1]
+        version      = VERSION_BYTES.key(version_byte)
+
+        raise ArgumentError, "Unexpected version: #{version.inspect}" if version != expected_version
+        raise ArgumentError, "Invalid checksum" if check != checksum(decoded[0...-2])
+        payload
+      end
+
+      # return the "XModem CRC16" (CCITT-like, but with 0-init and MSB first)
+      # packed into a string in little-endian order
+      def self.checksum(bytes)
+        crc = Digest::CRC16XModem.checksum(bytes)
+        [crc].pack("S<")
+      end
+
+    end
+  end
+end

data/ruby-stellar-base.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["generated", "lib"]
 
   spec.add_dependency "xdr", "~> 0.0.4"
+  spec.add_dependency "digest-crc"
+  spec.add_dependency "base32"
   spec.add_dependency "rbnacl"
   spec.add_dependency "rbnacl-libsodium", "~> 1.0.3"
   spec.add_dependency "activesupport", "~> 4"

data/spec/lib/stellar/key_pair_spec.rb

@@ -6,19 +6,19 @@ describe Stellar::KeyPair do
   describe ".from_seed" do
     subject{ Stellar::KeyPair.from_seed(seed) }
 
-    context "when provided a base58check encoded seed" do
-      let(:seed){ "s9aaUNPaT9t1x7vCeDzQYvLZDm5XxSUKkwnqQowV6D3kMr678uZ" }
+    context "when provided a strkey encoded seed" do
+      let(:seed){ "SBDA4J4PYZJEXWDTHFZBIGFVF2745BTKDKADWDQF72QXP55BP6XOV3B6" }
       it { should be_a(Stellar::KeyPair) }
     end
 
-    context "provided value is not base58 encoded" do
+    context "provided value is not strkey encoded" do
       let(:seed){ "allmylifemyhearthasbeensearching" }
       it { expect{ subject }.to raise_error(ArgumentError) }
     end
 
-    context "provided value is not base58 encoded as a seed" do
+    context "provided value is not strkey encoded as a seed" do
       let(:raw_seed){ "allmylifemyhearthasbeensearching" }
-      let(:seed){ Stellar::Util::Base58.stellar.check_encode(:account_id, raw_seed) }
+      let(:seed){ Stellar::Util::StrKey.check_encode(:account_id, raw_seed) }
       it { expect{ subject }.to raise_error(ArgumentError) }
     end
   end
@@ -74,19 +74,19 @@ describe Stellar::KeyPair do
   describe ".from_address" do
     subject{ Stellar::KeyPair.from_address(address) }
 
-    context "when provided a base58check encoded account_id" do
-      let(:address){ "gsYRSEQhTffqA9opPepAENCr2WG6z5iBHHubxxbRzWaHf8FBWcu" }
+    context "when provided a strkey encoded account_id" do
+      let(:address){ "GBRAINV4XDXEINVTNN53GOIGTN4B3BK65N6Q2ZBOMXHGHT347OQVNYZQ" }
       it { should be_a(Stellar::KeyPair) }
     end
 
-    context "provided value is not base58 encoded" do
+    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 base58 encoded as an account_id" do
+    context "provided value is not strkey encoded as an account_id" do
       let(:public_key){ "\xFF" * 32 }
-      let(:address){ Stellar::Util::Base58.stellar.check_encode(:seed, public_key) }
+      let(:address){ Stellar::Util::StrKey.check_encode(:seed, public_key) }
       it { expect{ subject }.to raise_error(ArgumentError) }
     end
 
@@ -151,13 +151,13 @@ describe Stellar::KeyPair do
   describe "#address" do
     let(:key_pair){ Stellar::KeyPair.random }
     subject{ key_pair.address }
-    it{ should be_base58_check(:account_id)}
+    it{ should be_strkey(:account_id)}
   end
 
   describe "#seed" do
     let(:key_pair){ Stellar::KeyPair.random }
     subject{ key_pair.seed }
-    it{ should be_base58_check(:seed)}
+    it{ should be_strkey(:seed)}
   end
 
   describe "#sign" do

data/spec/lib/stellar/path_payment_result_spec.rb

@@ -26,7 +26,7 @@ describe Stellar::PathPaymentResult, "#send_amount" do
   context "with simple 1-hop result" do
     let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
     let(:offers) do
-      [Stellar::ClaimOfferAtom.new(currency_send: Stellar::Currency.native, amount_send: 200)]
+      [Stellar::ClaimOfferAtom.new(asset_send: Stellar::Asset.native, amount_send: 200)]
     end
 
     let(:path_success) do
@@ -47,8 +47,8 @@ describe Stellar::PathPaymentResult, "#send_amount" do
     let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
     let(:offers) do
       [
-        Stellar::ClaimOfferAtom.new(currency_send: Stellar::Currency.native, amount_send: 200),
-        Stellar::ClaimOfferAtom.new(currency_send: Stellar::Currency.native, amount_send: 200),
+        Stellar::ClaimOfferAtom.new(asset_send: Stellar::Asset.native, amount_send: 200),
+        Stellar::ClaimOfferAtom.new(asset_send: Stellar::Asset.native, amount_send: 200),
       ]
     end
 
@@ -69,12 +69,12 @@ describe Stellar::PathPaymentResult, "#send_amount" do
 
   context "with multi-hop result that claimed multiple offers" do
     let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
-    let(:otherCurrency){ Stellar::Currency.alphanum("USD", Stellar::KeyPair.random) }
+    let(:otherAsset){ Stellar::Asset.alphanum4("USD", Stellar::KeyPair.random) }
     let(:offers) do
       [
-        Stellar::ClaimOfferAtom.new(currency_send: Stellar::Currency.native, amount_send: 200),
-        Stellar::ClaimOfferAtom.new(currency_send: Stellar::Currency.native, amount_send: 200),
-        Stellar::ClaimOfferAtom.new(currency_send: otherCurrency, amount_send: 200),
+        Stellar::ClaimOfferAtom.new(asset_send: Stellar::Asset.native, amount_send: 200),
+        Stellar::ClaimOfferAtom.new(asset_send: Stellar::Asset.native, amount_send: 200),
+        Stellar::ClaimOfferAtom.new(asset_send: otherAsset, amount_send: 200),
       ]
     end
 

data/spec/lib/stellar/transaction_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Stellar::Transaction do
   subject do
     Stellar::Transaction.new({
-      source_account: Stellar::AccountID.new(:key_types_ed25519, "\x00" * 32),
+      source_account: Stellar::AccountID.new(:key_type_ed25519, "\x00" * 32),
       fee:            10,
       seq_num:        1,
       memo:           Stellar::Memo.new(:memo_none),

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/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/tasks/xdr.rake

@@ -4,14 +4,13 @@ namespace :xdr do
   # 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/overlay/StellarXDR.x",
-    "src/scp/Stellar-SCP.x",
-  ]
+                 "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) }
 

data/xdr/Stellar-SCP.x

@@ -2,7 +2,7 @@
 // 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 "generated/Stellar-types.h"
+%#include "xdr/Stellar-types.h"
 
 namespace stellar
 {

data/xdr/Stellar-ledger-entries.x

@@ -2,7 +2,7 @@
 // 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 "generated/Stellar-types.h"
+%#include "xdr/Stellar-types.h"
 
 namespace stellar
 {
@@ -12,25 +12,33 @@ typedef opaque Thresholds[4];
 typedef string string32<32>;
 typedef uint64 SequenceNumber;
 
-enum CurrencyType
+enum AssetType
 {
-    CURRENCY_TYPE_NATIVE = 0,
-    CURRENCY_TYPE_ALPHANUM = 1
+    ASSET_TYPE_NATIVE = 0,
+    ASSET_TYPE_CREDIT_ALPHANUM4 = 1,
+    ASSET_TYPE_CREDIT_ALPHANUM12 = 2
 };
 
-union Currency switch (CurrencyType type)
+union Asset switch (AssetType type)
 {
-case CURRENCY_TYPE_NATIVE:
+case ASSET_TYPE_NATIVE: // Not credit
     void;
 
-case CURRENCY_TYPE_ALPHANUM:
+case ASSET_TYPE_CREDIT_ALPHANUM4:
     struct
     {
-        opaque currencyCode[4];
+        opaque assetCode[4];
         AccountID issuer;
-    } alphaNum;
+    } alphaNum4;
 
-    // add other currency types here in the future
+case ASSET_TYPE_CREDIT_ALPHANUM12:
+    struct
+    {
+        opaque assetCode[12];
+        AccountID issuer;
+    } alphaNum12;
+
+    // add other asset types here in the future
 };
 
 // price in fractional representation
@@ -69,7 +77,7 @@ enum AccountFlags
     // if set, TrustLines are created with authorized set to "false"
     // requiring the issuer to set it for each TrustLine
     AUTH_REQUIRED_FLAG = 0x1,
-    // if set, the authorized flag in TrustTines can be cleared
+    // if set, the authorized flag in TrustLines can be cleared
     // otherwise, authorization cannot be revoked
     AUTH_REVOCABLE_FLAG = 0x2
 };
@@ -112,7 +120,7 @@ struct AccountEntry
 
 /* TrustLineEntry
     A trust line represents a specific trust relationship with
-    a currency/issuer (limit, authorization)
+    a credit/issuer (limit, authorization)
     as well as the balance.
 */
 
@@ -125,9 +133,9 @@ enum TrustLineFlags
 struct TrustLineEntry
 {
     AccountID accountID; // account this trustline belongs to
-    Currency currency;   // currency (with issuer)
-    int64 balance;       // how much of this currency the user has.
-                         // Currency defines the unit for this;
+    Asset asset;   // type of asset (with issuer)
+    int64 balance;       // how much of this asset the user has.
+                         // Asset defines the unit for this;
 
     int64 limit;  // balance cannot be above this
     uint32 flags; // see TrustLineFlags
@@ -156,10 +164,10 @@ enum OfferEntryFlags
 */
 struct OfferEntry
 {
-    AccountID accountID;
+    AccountID sellerID;
     uint64 offerID;
-    Currency takerGets; // A
-    Currency takerPays; // B
+    Asset selling; // A
+    Asset buying; // B
     int64 amount;       // amount of A
 
     /* price for this offer: