stellar-base 0.0.1

data/tasks/xdr.rake

@@ -0,0 +1,48 @@
+namespace :xdr do
+
+  # As Hayashi adds more .x files, we'll need to update this array
+  # 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-ledger-entries.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",
+  ]
+
+  task :update => [:download, :generate]
+
+  task :download do
+    require 'octokit'
+    require 'base64'
+    
+    client = Octokit::Client.new(:netrc => true)
+
+    HAYASHI_XDR.each do |src|
+      local_path = "xdr/" + File.basename(src)
+      encoded    = client.contents("stellar/stellar-core", path: src).content
+      decoded    = Base64.decode64 encoded
+
+      IO.write(local_path, decoded)
+    end
+  end
+
+  task :generate do
+    require "pathname"
+    require "xdrgen"
+    require 'fileutils'
+    FileUtils.rm_rf "generated"
+
+    paths = Pathname.glob("xdr/**/*.x")
+    compilation = Xdrgen::Compilation.new(
+      paths, 
+      output_dir: "generated", 
+      namespace:  "stellar-base-generated",
+      language:   :ruby
+    )
+    compilation.compile
+  end
+end

data/xdr/SCPXDR.x

@@ -0,0 +1,61 @@
+
+namespace stellar
+{
+
+typedef opaque Signature[64];
+typedef opaque Hash[32];
+typedef opaque uint256[32];
+typedef unsigned int uint32;
+typedef unsigned hyper uint64;
+typedef opaque Value<>;
+typedef opaque Evidence<>;
+
+struct SCPBallot
+{
+    uint32 counter; // n
+    Value value;    // x
+};
+
+enum SCPStatementType
+{
+    PREPARING = 0,
+    PREPARED = 1,
+    COMMITTING = 2,
+    COMMITTED = 3
+};
+
+struct SCPStatement
+{
+    uint64 slotIndex;   // i
+    SCPBallot ballot;   // b
+    Hash quorumSetHash; // D
+
+    union switch (SCPStatementType type)
+    {
+    case PREPARING:
+        struct
+        {
+            SCPBallot excepted<>; // B_c
+            SCPBallot* prepared;  // p
+        } prepare;
+    case PREPARED:
+    case COMMITTING:
+    case COMMITTED:
+        void;
+    }
+    pledges;
+};
+
+struct SCPEnvelope
+{
+    uint256 nodeID; // v
+    SCPStatement statement;
+    Signature signature;
+};
+
+struct SCPQuorumSet
+{
+    uint32 threshold;
+    Hash validators<>;
+};
+}

data/xdr/Stellar-ledger-entries.x

@@ -0,0 +1,105 @@
+// 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
+{
+
+enum LedgerEntryType
+{
+    ACCOUNT = 0,
+    TRUSTLINE = 1,
+    OFFER = 2
+};
+
+struct Signer
+{
+    uint256 pubKey;
+    uint32 weight; // really only need 1byte
+};
+
+enum AccountFlags
+{ // masks for each flag
+    AUTH_REQUIRED_FLAG = 0x1
+};
+
+/* AccountEntry
+
+    Main entry representing a user in Stellar. All transactions are performed
+    using an account.
+
+    Other ledger entries created require an account.
+
+*/
+
+struct AccountEntry
+{
+    AccountID accountID;      // master public key for this account
+    int64 balance;            // in stroops
+    SequenceNumber seqNum;    // last sequence number used for this account
+    uint32 numSubEntries;     // number of sub-entries this account has
+                              // drives the reserve
+    AccountID* inflationDest; // Account to vote during inflation
+    uint32 flags;             // see AccountFlags
+
+    // fields used for signatures
+    // thresholds stores unsigned bytes: [weight of master|low|medium|high]
+    Thresholds thresholds;
+
+    Signer signers<20>; // possible signers for this account
+};
+
+/* TrustLineEntry
+    A trust line represents a specific trust relationship with
+    a currency/issuer (limit, authorization)
+    as well as the balance.
+*/
+
+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;
+
+    int64 limit;     // balance cannot be above this
+    bool authorized; // issuer has authorized account to hold its credit
+};
+
+/* OfferEntry
+    An offer is the building block of the offer book, they are automatically
+    claimed by payments when the price set by the owner is met.
+
+    For example an Offer is selling 10A where 1A is priced at 1.5B
+
+*/
+struct OfferEntry
+{
+    AccountID accountID;
+    uint64 offerID;
+    Currency takerGets; // A
+    Currency takerPays; // B
+    int64 amount;       // amount of A
+
+    /* price for this offer:
+        price of A in terms of B
+        price=AmountB/AmountA=priceNumerator/priceDenominator
+        price is after fees
+    */
+    Price price;
+};
+
+union LedgerEntry switch (LedgerEntryType type)
+{
+case ACCOUNT:
+    AccountEntry account;
+
+case TRUSTLINE:
+    TrustLineEntry trustLine;
+
+case OFFER:
+    OfferEntry offer;
+};
+}

data/xdr/Stellar-ledger.x

@@ -0,0 +1,117 @@
+// 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-transaction.h"
+
+namespace stellar
+{
+
+/* The LedgerHeader is the highest level structure representing the
+ * state of a ledger, cryptographically linked to previous ledgers.
+*/
+struct LedgerHeader
+{
+    Hash previousLedgerHash; // hash of the previous ledger header
+    Hash txSetHash;          // the tx set that was SCP confirmed
+    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
+
+    int64 feePool;       // fees burned since last inflation run
+    uint32 inflationSeq; // inflation sequence number
+
+    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
+};
+
+/* Entries used to define the bucket list */
+
+union LedgerKey switch (LedgerEntryType type)
+{
+case ACCOUNT:
+    struct
+    {
+        AccountID accountID;
+    } account;
+
+case TRUSTLINE:
+    struct
+    {
+        AccountID accountID;
+        Currency currency;
+    } trustLine;
+
+case OFFER:
+    struct
+    {
+        AccountID accountID;
+        uint64 offerID;
+    } offer;
+};
+
+enum BucketEntryType
+{
+    LIVEENTRY = 0,
+    DEADENTRY = 1
+};
+
+union BucketEntry switch (BucketEntryType type)
+{
+case LIVEENTRY:
+    LedgerEntry liveEntry;
+
+case DEADENTRY:
+    LedgerKey deadEntry;
+};
+
+// Transaction sets are the unit used by SCP to decide on transitions
+// between ledgers
+struct TransactionSet
+{
+    Hash previousLedgerHash;
+    TransactionEnvelope txs<5000>;
+};
+
+struct TransactionResultPair
+{
+    Hash transactionHash;
+    TransactionResult result; // result for the transaction
+};
+
+// TransactionResultSet is used to recover results between ledgers
+struct TransactionResultSet
+{
+    TransactionResultPair results<5000>;
+};
+
+// Entries below are used in the historical subsystem
+struct TransactionMeta
+{
+    BucketEntry entries<>;
+};
+
+struct TransactionHistoryEntry
+{
+    uint32 ledgerSeq;
+    TransactionSet txSet;
+};
+
+struct TransactionHistoryResultEntry
+{
+    uint32 ledgerSeq;
+    TransactionResultSet txResultSet;
+};
+
+struct LedgerHeaderHistoryEntry
+{
+    Hash hash;
+    LedgerHeader header;
+};
+}

data/xdr/Stellar-overlay.x

@@ -0,0 +1,100 @@
+// 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-ledger.h"
+
+namespace stellar
+{
+
+struct StellarBallotValue
+{
+    Hash txSetHash;
+    uint64 closeTime;
+    uint32 baseFee;
+};
+
+struct StellarBallot
+{
+    uint256 nodeID;
+    Signature signature;
+    StellarBallotValue value;
+};
+
+struct Error
+{
+    int code;
+    string msg<100>;
+};
+
+struct Hello
+{
+    int protocolVersion;
+    string versionStr<100>;
+    int listeningPort;
+    opaque peerID[32];
+};
+
+struct PeerAddress
+{
+    opaque ip[4];
+    uint32 port;
+    uint32 numFailures;
+};
+
+enum MessageType
+{
+    ERROR_MSG = 0,
+    HELLO = 1,
+    DONT_HAVE = 2,
+
+    GET_PEERS = 3, // gets a list of peers this guy knows about
+    PEERS = 4,
+
+    GET_TX_SET = 5, // gets a particular txset by hash
+    TX_SET = 6,
+
+    TRANSACTION = 7, // pass on a tx you have heard about
+
+    // SCP
+    GET_SCP_QUORUMSET = 8,
+    SCP_QUORUMSET = 9,
+    SCP_MESSAGE = 10
+};
+
+struct DontHave
+{
+    MessageType type;
+    uint256 reqHash;
+};
+
+union StellarMessage switch (MessageType type)
+{
+case ERROR_MSG:
+    Error error;
+case HELLO:
+    Hello hello;
+case DONT_HAVE:
+    DontHave dontHave;
+case GET_PEERS:
+    void;
+case PEERS:
+    PeerAddress peers<>;
+
+case GET_TX_SET:
+    uint256 txSetHash;
+case TX_SET:
+    TransactionSet txSet;
+
+case TRANSACTION:
+    TransactionEnvelope transaction;
+
+// SCP
+case GET_SCP_QUORUMSET:
+    uint256 qSetHash;
+case SCP_QUORUMSET:
+    SCPQuorumSet qSet;
+case SCP_MESSAGE:
+    SCPEnvelope envelope;
+};
+}