stellar-base 0.0.18 → 0.0.19

data/lib/stellar/transaction_envelope.rb

@@ -15,7 +15,7 @@ module Stellar
       hash = tx.hash
       return false if signatures.empty?
 
-      key_index = key_pairs.index_by(&:public_key_hint)
+      key_index = key_pairs.index_by(&:signature_hint)
       
       signatures.all? do |sig| 
         key_pair = key_index[sig.hint]

data/ruby-stellar-base.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["generated", "lib"]
 
-  spec.add_dependency "xdr", "~> 0.0.3"
+  spec.add_dependency "xdr", "~> 0.0.4"
   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

@@ -25,7 +25,7 @@ describe Stellar::KeyPair do
 
   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) }
@@ -101,14 +101,32 @@ describe Stellar::KeyPair do
     end
   end
 
-  describe "#public_key" do
+  describe "#raw_public_key" do
     let(:key_pair){ Stellar::KeyPair.random }
-    subject{ key_pair.public_key }
+    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 }
@@ -117,6 +135,19 @@ describe Stellar::KeyPair do
     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 }
@@ -130,7 +161,7 @@ describe Stellar::KeyPair do
   end
 
   describe "#sign" do
-    let(:message) { "hello" } 
+    let(:message) { "hello" }
     subject{ key_pair.sign(message) }
 
     context "when the key_pair has no private key" do
@@ -158,26 +189,26 @@ describe Stellar::KeyPair do
 
   describe "#verify" do
     let(:key_pair)  { Stellar::KeyPair.random }
-    let(:message)   { "hello" } 
+    let(:message)   { "hello" }
     subject         { key_pair.verify(signature, message) }
 
     context "when the signature is correct" do
-      let(:signature) { key_pair.sign(message) } 
+      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") } 
+      let(:signature) { key_pair.sign("some other message") }
       it{ should be_falsey }
     end
 
     context "when the signature is invalid" do
-      let(:signature) { "food" } 
+      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) } 
+      let(:signature) { Stellar::KeyPair.random.sign(message) }
       it{ should be_falsey }
     end
 

data/spec/lib/stellar/transaction_envelope_spec.rb

@@ -13,7 +13,7 @@ describe Stellar::TransactionEnvelope do
   end
 
   let(:envelope){ transaction.to_envelope(*signers) }
-  
+
   describe "#signed_correctly?" do
     subject{ envelope.signed_correctly?(*verifiers) }
 
@@ -82,7 +82,7 @@ describe Stellar::TransactionEnvelope do
         it{ should be_falsey }
       end
     end
-    
+
   end
 
   describe "#hash" do

data/spec/lib/stellar/transaction_spec.rb

@@ -3,23 +3,23 @@ require "spec_helper"
 describe Stellar::Transaction do
   subject do
     Stellar::Transaction.new({
-      source_account: "\x00" * 32,
+      source_account: Stellar::AccountID.new(:key_types_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 "#sign" do
     let(:result){ subject.sign(key_pair) }
 
-    it "returns a signature of SHA256(xdr form of the transaction)" do
-      xdr      = subject.to_xdr
-      hash     = Digest::SHA256.digest(xdr)
+    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
@@ -35,7 +35,7 @@ describe Stellar::Transaction do
     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.public_key_hint)
+      expect(result.signatures.first.hint).to eq(key_pair.signature_hint)
       expect(result.signatures.first.signature).to eq(subject.sign(key_pair))
     end
   end

data/tasks/xdr.rake

@@ -4,21 +4,25 @@ 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/xdr/Stellar-transaction.x",
-    "src/xdr/Stellar-types.x",
     "src/overlay/StellarXDR.x",
-    "src/scp/SCPXDR.x",
+    "src/scp/Stellar-SCP.x",
   ]
 
+  LOCAL_XDR_PATHS = HAYASHI_XDR.map{ |src| "xdr/" + File.basename(src) }
+
   task :update => [:download, :generate]
 
   task :download do
     require 'octokit'
     require 'base64'
-    
+    FileUtils.rm_rf "xdr/"
+    FileUtils.mkdir_p "xdr"
+
     client = Octokit::Client.new(:netrc => true)
 
     HAYASHI_XDR.each do |src|
@@ -36,13 +40,12 @@ namespace :xdr do
     require 'fileutils'
     FileUtils.rm_rf "generated"
 
-    paths = Pathname.glob("xdr/**/*.x")
     compilation = Xdrgen::Compilation.new(
-      paths, 
-      output_dir: "generated", 
+      LOCAL_XDR_PATHS,
+      output_dir: "generated",
       namespace:  "stellar-base-generated",
       language:   :ruby
     )
     compilation.compile
   end
-end
+end

data/xdr/Stellar-SCP.x

@@ -0,0 +1,87 @@
+// 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 "generated/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;                // n_c
+            uint32 nP;                // n_P
+        } prepare;
+    case SCP_ST_CONFIRM:
+        struct
+        {
+            Hash quorumSetHash; // D
+            uint32 nPrepared;   // n_p
+            SCPBallot commit;   // c
+            uint32 nP;          // n_P
+        } confirm;
+    case SCP_ST_EXTERNALIZE:
+        struct
+        {
+            SCPBallot commit; // c
+            uint32 nP;        // n_P
+            // not from the paper, but useful to build tooling to
+            // traverse the graph based off only the latest statement
+            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<>;
+};
+}

data/xdr/Stellar-ledger-entries.x

@@ -7,6 +7,49 @@
 namespace stellar
 {
 
+typedef PublicKey AccountID;
+typedef opaque Thresholds[4];
+typedef string string32<32>;
+typedef uint64 SequenceNumber;
+
+enum CurrencyType
+{
+    CURRENCY_TYPE_NATIVE = 0,
+    CURRENCY_TYPE_ALPHANUM = 1
+};
+
+union Currency switch (CurrencyType type)
+{
+case CURRENCY_TYPE_NATIVE:
+    void;
+
+case CURRENCY_TYPE_ALPHANUM:
+    struct
+    {
+        opaque currencyCode[4];
+        AccountID issuer;
+    } alphaNum;
+
+    // add other currency types here in the future
+};
+
+// price in fractional representation
+struct Price
+{
+    int32 n; // numerator
+    int32 d; // denominator
+};
+
+// the 'Thresholds' type is packed uint8_t values
+// defined by these indexes
+enum ThresholdIndexes
+{
+    THRESHOLD_MASTER_WEIGHT = 0,
+    THRESHOLD_LOW = 1,
+    THRESHOLD_MED = 2,
+    THRESHOLD_HIGH = 3
+};
+
 enum LedgerEntryType
 {
     ACCOUNT = 0,
@@ -16,7 +59,7 @@ enum LedgerEntryType
 
 struct Signer
 {
-    uint256 pubKey;
+    AccountID pubKey;
     uint32 weight; // really only need 1byte
 };
 
@@ -50,13 +93,21 @@ struct AccountEntry
     AccountID* inflationDest; // Account to vote during inflation
     uint32 flags;             // see AccountFlags
 
+    string32 homeDomain; // can be used for reverse federation and memo lookup
+
     // fields used for signatures
     // thresholds stores unsigned bytes: [weight of master|low|medium|high]
     Thresholds thresholds;
 
-    string32 homeDomain; // can be used for reverse federation and memo lookup
-
     Signer signers<20>; // possible signers for this account
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
 };
 
 /* TrustLineEntry
@@ -80,8 +131,15 @@ struct TrustLineEntry
 
     int64 limit;  // balance cannot be above this
     uint32 flags; // see TrustLineFlags
-};
 
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
+};
 
 enum OfferEntryFlags
 {
@@ -111,17 +169,33 @@ struct OfferEntry
     */
     Price price;
     uint32 flags; // see OfferEntryFlags
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
 };
 
 union LedgerEntry switch (LedgerEntryType type)
 {
 case ACCOUNT:
     AccountEntry account;
-
 case TRUSTLINE:
     TrustLineEntry trustLine;
-
 case OFFER:
     OfferEntry offer;
 };
+
+// list of all envelope types used in the application
+// those are prefixes used when building signatures for
+// the respective envelopes
+enum EnvelopeType
+{
+    ENVELOPE_TYPE_SCP = 1,
+    ENVELOPE_TYPE_TX = 2
+};
+
 }

data/xdr/Stellar-ledger.x

@@ -7,18 +7,42 @@
 namespace stellar
 {
 
+typedef opaque UpgradeType<128>;
+
+/* StellarValue is the value used by SCP to reach consensus on a given ledger
+*/
+struct StellarValue
+{
+    Hash txSetHash;   // transaction set to apply to previous ledger
+    uint64 closeTime; // network close time
+
+    // upgrades to apply to the previous ledger (usually empty)
+    // this is a vector of encoded 'LedgerUpgrade' so that nodes can drop
+    // unknown steps during consensus if needed.
+    // see notes below on 'LedgerUpgrade' for more detail
+    UpgradeType upgrades<4>;
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
+};
+
 /* The LedgerHeader is the highest level structure representing the
  * state of a ledger, cryptographically linked to previous ledgers.
 */
 struct LedgerHeader
 {
+    uint32 ledgerVersion;    // the protocol version of the ledger
     Hash previousLedgerHash; // hash of the previous ledger header
-    Hash txSetHash;          // the tx set that was SCP confirmed
+    StellarValue scpValue;   // what consensus agreed to
     Hash txSetResultHash;    // the TransactionResultSet that led to this ledger
     Hash bucketListHash;     // hash of the ledger state
 
     uint32 ledgerSeq; // sequence number of this ledger
-    uint64 closeTime; // network close time
 
     int64 totalCoins; // total number of stroops in existence
 
@@ -27,11 +51,41 @@ struct LedgerHeader
 
     uint64 idPool; // last used global ID, used for generating objects
 
-    int32 baseFee;     // base fee per operation in stroops
-    int32 baseReserve; // account base reserve in stroops
+    uint32 baseFee;     // base fee per operation in stroops
+    uint32 baseReserve; // account base reserve in stroops
 
-    Hash skipList[4];  // hashes of ledgers in the past. allows you to jump back
-                       // in time without walking the chain back ledger by ledger
+    Hash skipList[4]; // hashes of ledgers in the past. allows you to jump back
+                      // in time without walking the chain back ledger by ledger
+                      // each slot contains the oldest ledger that is mod of
+                      // either 50  5000  50000 or 500000 depending on index
+                      // skipList[0] mod(50), skipList[1] mod(5000), etc
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
+};
+
+/* Ledger upgrades
+note that the `upgrades` field from StellarValue is normalized such that
+it only contains one entry per LedgerUpgradeType, and entries are sorted
+in ascending order
+*/
+enum LedgerUpgradeType
+{
+    LEDGER_UPGRADE_VERSION = 1,
+    LEDGER_UPGRADE_BASE_FEE = 2
+};
+
+union LedgerUpgrade switch (LedgerUpgradeType type)
+{
+case LEDGER_UPGRADE_VERSION:
+    uint32 newLedgerVersion; // update ledgerVersion
+case LEDGER_UPGRADE_BASE_FEE:
+    uint32 newBaseFee; // update baseFee
 };
 
 /* Entries used to define the bucket list */
@@ -76,10 +130,11 @@ case DEADENTRY:
 
 // Transaction sets are the unit used by SCP to decide on transitions
 // between ledgers
+const MAX_TX_PER_LEDGER = 5000;
 struct TransactionSet
 {
     Hash previousLedgerHash;
-    TransactionEnvelope txs<5000>;
+    TransactionEnvelope txs<MAX_TX_PER_LEDGER>;
 };
 
 struct TransactionResultPair
@@ -91,7 +146,7 @@ struct TransactionResultPair
 // TransactionResultSet is used to recover results between ledgers
 struct TransactionResultSet
 {
-    TransactionResultPair results<5000>;
+    TransactionResultPair results<MAX_TX_PER_LEDGER>;
 };
 
 // Entries below are used in the historical subsystem
@@ -100,18 +155,42 @@ struct TransactionHistoryEntry
 {
     uint32 ledgerSeq;
     TransactionSet txSet;
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
 };
 
 struct TransactionHistoryResultEntry
 {
     uint32 ledgerSeq;
     TransactionResultSet txResultSet;
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
 };
 
 struct LedgerHeaderHistoryEntry
 {
     Hash hash;
     LedgerHeader header;
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
 };
 
 // represents the meta in the transaction table history