auction-ruby-base 0.1.1

data/xdr/Stellar-ledger-entries.x

@@ -0,0 +1,351 @@
+// 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 "xdr/Stellar-types.h"
+
+namespace stellar
+{
+
+typedef PublicKey AccountID;
+typedef opaque Thresholds[4];
+typedef string string32<32>;
+typedef uint64 SequenceNumber;
+
+enum AssetType
+{
+    ASSET_TYPE_NATIVE = 0,
+    ASSET_TYPE_CREDIT_ALPHANUM4 = 1,
+    ASSET_TYPE_CREDIT_ALPHANUM12 = 2
+};
+
+union Asset switch (AssetType type)
+{
+case ASSET_TYPE_NATIVE: // Not credit
+    void;
+
+case ASSET_TYPE_CREDIT_ALPHANUM4:
+    struct
+    {
+        opaque assetCode[4]; // 1 to 4 characters
+        AccountID issuer;
+    } alphaNum4;
+
+case ASSET_TYPE_CREDIT_ALPHANUM12:
+    struct
+    {
+        opaque assetCode[12]; // 5 to 12 characters
+        AccountID issuer;
+    } alphaNum12;
+
+    // add other asset 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,
+    TRUSTLINE = 1,
+    OFFER = 2,
+    LOT = 3,
+    PARTICIPANT = 4,
+    MESSAGE = 5,
+    PROOF = 6
+};
+
+struct Signer
+{
+    AccountID pubKey;
+    uint32 weight; // really only need 1byte
+};
+
+enum AccountFlags
+{ // masks for each flag
+
+    // Flags set on issuer accounts
+    // 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 TrustLines can be cleared
+    // otherwise, authorization cannot be revoked
+    AUTH_REVOCABLE_FLAG = 0x2,
+    // Once set, causes all AUTH_* flags to be read-only
+    AUTH_IMMUTABLE_FLAG = 0x4
+};
+
+/* 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 for 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;
+
+    Signer signers<20>; // possible signers for this account
+
+    string32 codeKYC;
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
+};
+
+/* ProofEntry
+
+*/
+
+struct ProofEntry
+{
+    AccountID accountID;
+    uint64 lotID;
+    uint64 proofID;
+    uint64 bankID;
+    uint32 quantity;
+
+    string proof<1000>;
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
+};
+
+/* TrustLineEntry
+    A trust line represents a specific trust relationship with
+    a credit/issuer (limit, authorization)
+    as well as the balance.
+*/
+
+enum TrustLineFlags
+{
+    // issuer has authorized account to perform transactions with its credit
+    AUTHORIZED_FLAG = 1
+};
+
+struct TrustLineEntry
+{
+    AccountID accountID; // account this trustline belongs to
+    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
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
+};
+
+enum OfferEntryFlags
+{
+    // issuer has authorized account to perform transactions with its credit
+    PASSIVE_FLAG = 1
+};
+
+/* 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 sellerID;
+    uint64 offerID;
+    Asset selling; // A
+    Asset buying;  // 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;
+    uint32 flags; // see OfferEntryFlags
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
+};
+
+
+/* LotEntry
+
+*/
+
+enum LotType {
+    TERRITORY = 1,
+    FACILITY = 2
+};
+
+enum LotBranch {
+    AGRICULTURE = 1,
+    LIVESTOCK = 2
+};
+
+struct LotEntry
+{
+    AccountID organizerID;
+    uint64 lotID;
+    string lotName<1000>;
+    uint32 type;
+    string32 lotCode;
+    string lotAddress<1000>;
+    uint32 lotBranch;
+    string lotLocation<1000>;
+    uint64 startPrice;
+    uint64 bestPrice;
+    uint32 minStep;
+    uint32 maxStep;
+    uint64 published;
+    uint64 aucStarted;
+    uint64 duration;
+    uint64 pledge;
+    AccountID publisherID;
+    string details<1000>;
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+    void;
+    }
+    ext;
+};
+
+enum ParticipantState {
+    APPROVED = 0,
+    PENDING = 1,
+    PASS = 2,
+    FAIL = 3
+};
+/* ParticipantEntry
+
+*/
+struct ParticipantEntry
+{
+    AccountID accountID;
+    uint64 lotID;
+    uint32 state;
+    uint64 bestBid;
+    uint32 bestBidSeq;
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+    void;
+    }
+    ext;
+};
+
+/* MessageEntry
+
+*/
+struct MessageEntry
+{
+    uint64 messageID;
+    AccountID accountID;
+    string text<1000>;
+    uint64 lotID;
+    uint64 refMessageID;
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+    void;
+    }
+    ext;
+};
+
+struct LedgerEntry
+{
+    uint32 lastModifiedLedgerSeq; // ledger the LedgerEntry was last changed
+
+    union switch (LedgerEntryType type)
+    {
+    case ACCOUNT:
+        AccountEntry account;
+    case TRUSTLINE:
+        TrustLineEntry trustLine;
+    case OFFER:
+        OfferEntry offer;
+    case LOT:
+        LotEntry lot;
+    case PARTICIPANT:
+        ParticipantEntry participant;
+    case MESSAGE:
+        MessageEntry message;
+    case PROOF:
+        ProofEntry proof;
+    }
+    data;
+
+    // reserved for future use
+    union switch (int v)
+    {
+    case 0:
+        void;
+    }
+    ext;
+};
+
+// 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,
+    ENVELOPE_TYPE_AUTH = 3
+};
+}

data/xdr/Stellar-ledger.x

@@ -0,0 +1,288 @@
+// 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 "xdr/Stellar-transaction.h"
+
+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
+    // max size is dictated by number of upgrade types (+ room for future)
+    UpgradeType upgrades<6>;
+
+    // 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
+    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
+
+    int64 totalCoins; // total number of stroops in existence.
+                      // 10,000,000 stroops in 1 XLM
+
+    int64 feePool;       // fees burned since last inflation run
+    uint32 inflationSeq; // inflation sequence number
+
+    uint64 idPool; // last used global ID, used for generating objects
+
+    uint32 baseFee;     // base fee per operation in stroops
+    uint32 baseReserve; // account base reserve in stroops
+
+    uint32 maxTxSetSize; // maximum size a transaction set can be
+
+    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,
+    LEDGER_UPGRADE_MAX_TX_SET_SIZE = 3
+};
+
+union LedgerUpgrade switch (LedgerUpgradeType type)
+{
+case LEDGER_UPGRADE_VERSION:
+    uint32 newLedgerVersion; // update ledgerVersion
+case LEDGER_UPGRADE_BASE_FEE:
+    uint32 newBaseFee; // update baseFee
+case LEDGER_UPGRADE_MAX_TX_SET_SIZE:
+    uint32 newMaxTxSetSize; // update maxTxSetSize
+};
+
+/* Entries used to define the bucket list */
+
+union LedgerKey switch (LedgerEntryType type)
+{
+case ACCOUNT:
+    struct
+    {
+        AccountID accountID;
+    } account;
+
+case TRUSTLINE:
+    struct
+    {
+        AccountID accountID;
+        Asset asset;
+    } trustLine;
+
+case OFFER:
+    struct
+    {
+        AccountID sellerID;
+        uint64 offerID;
+    } offer;
+case LOT:
+    struct
+    {
+        AccountID organizerID;
+        uint64 lotID;
+    } lot;
+case PARTICIPANT:
+    struct
+    {
+        AccountID accountID;
+        uint64 lotID;
+    } participant;
+case MESSAGE:
+    struct
+    {
+    AccountID accountID;
+    uint64 messageID;
+    } message;
+case PROOF:
+    struct
+    {
+        AccountID accountID;
+        uint64 proofID;
+    } proof;
+
+};
+
+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
+const MAX_TX_PER_LEDGER = 5000;
+struct TransactionSet
+{
+    Hash previousLedgerHash;
+    TransactionEnvelope txs<MAX_TX_PER_LEDGER>;
+};
+
+struct TransactionResultPair
+{
+    Hash transactionHash;
+    TransactionResult result; // result for the transaction
+};
+
+// TransactionResultSet is used to recover results between ledgers
+struct TransactionResultSet
+{
+    TransactionResultPair results<MAX_TX_PER_LEDGER>;
+};
+
+// Entries below are used in the historical subsystem
+
+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;
+};
+
+// historical SCP messages
+
+struct LedgerSCPMessages
+{
+    uint32 ledgerSeq;
+    SCPEnvelope messages<>;
+};
+
+// note: ledgerMessages may refer to any quorumSets encountered
+// in the file so far, not just the one from this entry
+struct SCPHistoryEntryV0
+{
+    SCPQuorumSet quorumSets<>; // additional quorum sets used by ledgerMessages
+    LedgerSCPMessages ledgerMessages;
+};
+
+// SCP history file is an array of these
+union SCPHistoryEntry switch (int v)
+{
+case 0:
+    SCPHistoryEntryV0 v0;
+};
+
+// represents the meta in the transaction table history
+
+// STATE is emitted every time a ledger entry is modified/deleted
+// and the entry was not already modified in the current ledger
+
+enum LedgerEntryChangeType
+{
+    LEDGER_ENTRY_CREATED = 0, // entry was added to the ledger
+    LEDGER_ENTRY_UPDATED = 1, // entry was modified in the ledger
+    LEDGER_ENTRY_REMOVED = 2, // entry was removed from the ledger
+    LEDGER_ENTRY_STATE = 3    // value of the entry
+};
+
+union LedgerEntryChange switch (LedgerEntryChangeType type)
+{
+case LEDGER_ENTRY_CREATED:
+    LedgerEntry created;
+case LEDGER_ENTRY_UPDATED:
+    LedgerEntry updated;
+case LEDGER_ENTRY_REMOVED:
+    LedgerKey removed;
+case LEDGER_ENTRY_STATE:
+    LedgerEntry state;
+};
+
+typedef LedgerEntryChange LedgerEntryChanges<>;
+
+struct OperationMeta
+{
+    LedgerEntryChanges changes;
+};
+
+union TransactionMeta switch (int v)
+{
+case 0:
+    OperationMeta operations<>;
+};
+}