module Stellar

xdr source ============================================================¶ ↑

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;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

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
};

¶ ↑

xdr source ============================================================¶ ↑

union AccountMergeResult switch (AccountMergeResultCode code)
{
case ACCOUNT_MERGE_SUCCESS:
    int64 sourceAccountBalance; // how much got transfered from source account
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum AccountMergeResultCode
{
    // codes considered as "success" for the operation
    ACCOUNT_MERGE_SUCCESS = 0,
    // codes considered as "failure" for the operation
    ACCOUNT_MERGE_MALFORMED = -1,      // can't merge onto itself
    ACCOUNT_MERGE_NO_ACCOUNT = -2,     // destination does not exist
    ACCOUNT_MERGE_IMMUTABLE_SET = -3,  // source account has AUTH_IMMUTABLE set
    ACCOUNT_MERGE_HAS_SUB_ENTRIES = -4 // account has trust lines/offers
};

¶ ↑

xdr source ============================================================¶ ↑

struct AffirmFailOp
{
    uint64 lotID;
    string purpose<1000>;
    AccountID accountID;
};

¶ ↑

xdr source ============================================================¶ ↑

union AffirmFailResult switch (AffirmFailResultCode code)
{
case AFFIRM_FAIL_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum AffirmFailResultCode
{
    AFFIRM_FAIL_SUCCESS = 0,
    AFFIRM_FAIL_ERROR = 1
};

¶ ↑

xdr source ============================================================¶ ↑

struct AffirmPassOp
{
    uint64 lotID; // name of the lot
    string paperHash<1000>;
    string paperLink<1000>;
    AccountID accountID;
};

¶ ↑

xdr source ============================================================¶ ↑

union AffirmPassResult switch (AffirmPassResultCode code)
{
case AFFIRM_PASS_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum AffirmPassResultCode
{
    AFFIRM_PASS_SUCCESS = 0,
    AFFIRM_PASS_ERROR = 1
};

¶ ↑

xdr source ============================================================¶ ↑

struct AllowTrustOp
{
    AccountID trustor;
    union switch (AssetType type)
    {
    // ASSET_TYPE_NATIVE is not allowed
    case ASSET_TYPE_CREDIT_ALPHANUM4:
        opaque assetCode4[4];

    case ASSET_TYPE_CREDIT_ALPHANUM12:
        opaque assetCode12[12];

        // add other asset types here in the future
    }
    asset;

    bool authorize;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (AssetType type)
    {
    // ASSET_TYPE_NATIVE is not allowed
    case ASSET_TYPE_CREDIT_ALPHANUM4:
        opaque assetCode4[4];

    case ASSET_TYPE_CREDIT_ALPHANUM12:
        opaque assetCode12[12];

        // add other asset types here in the future
    }

¶ ↑

xdr source ============================================================¶ ↑

union AllowTrustResult switch (AllowTrustResultCode code)
{
case ALLOW_TRUST_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum AllowTrustResultCode
{
    // codes considered as "success" for the operation
    ALLOW_TRUST_SUCCESS = 0,
    // codes considered as "failure" for the operation
    ALLOW_TRUST_MALFORMED = -1,     // asset is not ASSET_TYPE_ALPHANUM
    ALLOW_TRUST_NO_TRUST_LINE = -2, // trustor does not have a trustline
                                    // source account does not require trust
    ALLOW_TRUST_TRUST_NOT_REQUIRED = -3,
    ALLOW_TRUST_CANT_REVOKE = -4 // source account can't revoke trust
};

¶ ↑

xdr source ============================================================¶ ↑

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
};

¶ ↑

xdr source ============================================================¶ ↑

struct
    {
        opaque assetCode[12]; // 5 to 12 characters
        AccountID issuer;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct
    {
        opaque assetCode[4]; // 1 to 4 characters
        AccountID issuer;
    }

¶ ↑

xdr source ============================================================¶ ↑

enum AssetType
{
    ASSET_TYPE_NATIVE = 0,
    ASSET_TYPE_CREDIT_ALPHANUM4 = 1,
    ASSET_TYPE_CREDIT_ALPHANUM12 = 2
};

¶ ↑

xdr source ============================================================¶ ↑

struct Auth
{
    // Empty message, just to confirm
    // establishment of MAC keys.
    int unused;
};

¶ ↑

xdr source ============================================================¶ ↑

struct AuthCert
{
    Curve25519Public pubkey;
    uint64 expiration;
    Signature sig;
};

¶ ↑

xdr source ============================================================¶ ↑

union AuthenticatedMessage switch (uint32 v)
{
case 0:
    struct
{
   uint64 sequence;
   StellarMessage message;
   HmacSha256Mac mac;
    } v0;
};

¶ ↑

xdr source ============================================================¶ ↑

struct
{
   uint64 sequence;
   StellarMessage message;
   HmacSha256Mac mac;
    }

¶ ↑

xdr source ============================================================¶ ↑

union BucketEntry switch (BucketEntryType type)
{
case LIVEENTRY:
    LedgerEntry liveEntry;

case DEADENTRY:
    LedgerKey deadEntry;
};

¶ ↑

xdr source ============================================================¶ ↑

enum BucketEntryType
{
    LIVEENTRY = 0,
    DEADENTRY = 1
};

¶ ↑

xdr source ============================================================¶ ↑

struct ChangeTrustOp
{
    Asset line;

    // if limit is set to 0, deletes the trust line
    int64 limit;
};

¶ ↑

xdr source ============================================================¶ ↑

union ChangeTrustResult switch (ChangeTrustResultCode code)
{
case CHANGE_TRUST_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum ChangeTrustResultCode
{
    // codes considered as "success" for the operation
    CHANGE_TRUST_SUCCESS = 0,
    // codes considered as "failure" for the operation
    CHANGE_TRUST_MALFORMED = -1,     // bad input
    CHANGE_TRUST_NO_ISSUER = -2,     // could not find issuer
    CHANGE_TRUST_INVALID_LIMIT = -3, // cannot drop limit below balance
                                     // cannot create with a limit of 0
    CHANGE_TRUST_LOW_RESERVE = -4 // not enough funds to create a new trust line
};

¶ ↑

xdr source ============================================================¶ ↑

struct ClaimOfferAtom
{
    // emitted to identify the offer
    AccountID sellerID; // Account that owns the offer
    uint64 offerID;

    // amount and asset taken from the owner
    Asset assetSold;
    int64 amountSold;

    // amount and asset sent to the owner
    Asset assetBought;
    int64 amountBought;
};

¶ ↑

xdr source ============================================================¶ ↑

struct CreateAccountOp
{
    AccountID destination; // account to create
    string32 codeKYC;
};

¶ ↑

xdr source ============================================================¶ ↑

union CreateAccountResult switch (CreateAccountResultCode code)
{
case CREATE_ACCOUNT_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum CreateAccountResultCode
{
    // codes considered as "success" for the operation
    CREATE_ACCOUNT_SUCCESS = 0, // account was created

    // codes considered as "failure" for the operation
    CREATE_ACCOUNT_MALFORMED = -1,   // invalid destination
    CREATE_ACCOUNT_UNDERFUNDED = -2, // not enough funds in source account
    CREATE_ACCOUNT_LOW_RESERVE =
        -3, // would create an account below the min reserve
    CREATE_ACCOUNT_ALREADY_EXIST = -4 // account already exists
};

¶ ↑

xdr source ============================================================¶ ↑

struct CreateBidOp
{
    uint64 lotID; // name of the lot
    uint64 amount;
};

¶ ↑

xdr source ============================================================¶ ↑

union CreateBidResult switch (CreateBidResultCode code)
{
case CREATE_BID_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum CreateBidResultCode
{
    CREATE_BID_SUCCESS = 0,
    CREATE_BID_ERROR = 1
};

¶ ↑

xdr source ============================================================¶ ↑

struct CreateLotOp
{
    string lotName<1000>; // name of the lot
    uint32 type;
    string32 lotCode;
    string lotAddress<1000>;
    uint32 lotBranch;
    string lotLocation<1000>;
    uint64 startPrice;
    uint32 minStep;
    uint32 maxStep;
    uint64 published;
    uint64 aucStarted;
    uint64 duration;
    uint64 pledge;
    string details<1000>;
    AccountID publisherID;
};

¶ ↑

xdr source ============================================================¶ ↑

union CreateLotResult switch (CreateLotResultCode code)
{
case CREATE_LOT_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum CreateLotResultCode
{
    CREATE_LOT_SUCCESS = 0, // lot was created
    CREATE_LOT_ERROR = 1 // lot was created
};

¶ ↑

xdr source ============================================================¶ ↑

struct CreatePassiveOfferOp
{
    Asset selling; // A
    Asset buying;  // B
    int64 amount;  // amount taker gets. if set to 0, delete the offer
    Price price;   // cost of A in terms of B
};

¶ ↑

xdr source ============================================================¶ ↑

enum CryptoKeyType
{
    KEY_TYPE_ED25519 = 0
};

¶ ↑

xdr source ============================================================¶ ↑

struct Curve25519Public
{
        opaque key[32];
};

¶ ↑

xdr source ============================================================¶ ↑

struct Curve25519Secret
{
        opaque key[32];
};

¶ ↑

xdr source ============================================================¶ ↑

struct DecoratedSignature
{
    SignatureHint hint;  // last 4 bytes of the public key, used as a hint
    Signature signature; // actual signature
};

¶ ↑

xdr source ============================================================¶ ↑

struct DontHave
{
    MessageType type;
    uint256 reqHash;
};

¶ ↑

xdr source ============================================================¶ ↑

enum EnvelopeType
{
    ENVELOPE_TYPE_SCP = 1,
    ENVELOPE_TYPE_TX = 2,
    ENVELOPE_TYPE_AUTH = 3
};

¶ ↑

xdr source ============================================================¶ ↑

struct Error
{
    ErrorCode code;
    string msg<100>;
};

¶ ↑

xdr source ============================================================¶ ↑

enum ErrorCode
{
    ERR_MISC = 0, // Unspecific error
    ERR_DATA = 1, // Malformed data
    ERR_CONF = 2, // Misconfiguration error
    ERR_AUTH = 3, // Authentication failure
    ERR_LOAD = 4  // System overloaded
};

¶ ↑

xdr source ============================================================¶ ↑

struct Hello
{
    uint32 ledgerVersion;
    uint32 overlayVersion;
    uint32 overlayMinVersion;
    Hash networkID;
    string versionStr<100>;
    int listeningPort;
    NodeID peerID;
    AuthCert cert;
    uint256 nonce;
};

¶ ↑

xdr source ============================================================¶ ↑

struct HmacSha256Key
{
        opaque key[32];
};

¶ ↑

xdr source ============================================================¶ ↑

struct HmacSha256Mac
{
        opaque mac[32];
};

¶ ↑

xdr source ============================================================¶ ↑

struct InflationPayout // or use PaymentResultAtom to limit types?
{
    AccountID destination;
    int64 amount;
};

¶ ↑

xdr source ============================================================¶ ↑

union InflationResult switch (InflationResultCode code)
{
case INFLATION_SUCCESS:
    InflationPayout payouts<>;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum InflationResultCode
{
    // codes considered as "success" for the operation
    INFLATION_SUCCESS = 0,
    // codes considered as "failure" for the operation
    INFLATION_NOT_TIME = -1
};

¶ ↑

xdr source ============================================================¶ ↑

enum IPAddrType
{
    IPv4 = 0,
    IPv6 = 1
};

¶ ↑

xdr source ============================================================¶ ↑

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;
};

¶ ↑

xdr source ============================================================¶ ↑

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;
    }

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

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;
};

¶ ↑

xdr source ============================================================¶ ↑

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
};

¶ ↑

xdr source ============================================================¶ ↑

enum LedgerEntryType
{
    ACCOUNT = 0,
    TRUSTLINE = 1,
    OFFER = 2,
    LOT = 3,
    PARTICIPANT = 4,
    MESSAGE = 5,
    PROOF = 6
};

¶ ↑

xdr source ============================================================¶ ↑

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;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct LedgerHeaderHistoryEntry
{
    Hash hash;
    LedgerHeader header;

    // reserved for future use
    union switch (int v)
    {
    case 0:
        void;
    }
    ext;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

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;

};

¶ ↑

xdr source ============================================================¶ ↑

struct
    {
        AccountID accountID;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct
    {
        AccountID organizerID;
        uint64 lotID;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct
    {
    AccountID accountID;
    uint64 messageID;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct
    {
        AccountID sellerID;
        uint64 offerID;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct
    {
        AccountID accountID;
        uint64 lotID;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct
    {
        AccountID accountID;
        uint64 proofID;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct
    {
        AccountID accountID;
        Asset asset;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct LedgerSCPMessages
{
    uint32 ledgerSeq;
    SCPEnvelope messages<>;
};

¶ ↑

xdr source ============================================================¶ ↑

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
};

¶ ↑

xdr source ============================================================¶ ↑

enum LedgerUpgradeType
{
    LEDGER_UPGRADE_VERSION = 1,
    LEDGER_UPGRADE_BASE_FEE = 2,
    LEDGER_UPGRADE_MAX_TX_SET_SIZE = 3
};

¶ ↑

xdr source ============================================================¶ ↑

enum LotBranch {
    AGRICULTURE = 1,
    LIVESTOCK = 2
};

¶ ↑

xdr source ============================================================¶ ↑

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;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
    void;
    }

¶ ↑

xdr source ============================================================¶ ↑

enum LotType {
    TERRITORY = 1,
    FACILITY = 2
};

¶ ↑

xdr source ============================================================¶ ↑

enum ManageOfferEffect
{
    MANAGE_OFFER_CREATED = 0,
    MANAGE_OFFER_UPDATED = 1,
    MANAGE_OFFER_DELETED = 2
};

¶ ↑

xdr source ============================================================¶ ↑

struct ManageOfferOp
{
    Asset selling;
    Asset buying;
    int64 amount; // amount being sold. if set to 0, delete the offer
    Price price;  // price of thing being sold in terms of what you are buying

    // 0=create a new offer, otherwise edit an existing offer
    uint64 offerID;
};

¶ ↑

xdr source ============================================================¶ ↑

union ManageOfferResult switch (ManageOfferResultCode code)
{
case MANAGE_OFFER_SUCCESS:
    ManageOfferSuccessResult success;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum ManageOfferResultCode
{
    // codes considered as "success" for the operation
    MANAGE_OFFER_SUCCESS = 0,

    // codes considered as "failure" for the operation
    MANAGE_OFFER_MALFORMED = -1,     // generated offer would be invalid
    MANAGE_OFFER_SELL_NO_TRUST = -2, // no trust line for what we're selling
    MANAGE_OFFER_BUY_NO_TRUST = -3,  // no trust line for what we're buying
    MANAGE_OFFER_SELL_NOT_AUTHORIZED = -4, // not authorized to sell
    MANAGE_OFFER_BUY_NOT_AUTHORIZED = -5,  // not authorized to buy
    MANAGE_OFFER_LINE_FULL = -6,      // can't receive more of what it's buying
    MANAGE_OFFER_UNDERFUNDED = -7,    // doesn't hold what it's trying to sell
    MANAGE_OFFER_CROSS_SELF = -8,     // would cross an offer from the same user
    MANAGE_OFFER_SELL_NO_ISSUER = -9, // no issuer for what we're selling
    MANAGE_OFFER_BUY_NO_ISSUER = -10, // no issuer for what we're buying

    // update errors
    MANAGE_OFFER_NOT_FOUND = -11, // offerID does not match an existing offer

    MANAGE_OFFER_LOW_RESERVE = -12 // not enough funds to create a new Offer
};

¶ ↑

xdr source ============================================================¶ ↑

struct ManageOfferSuccessResult
{
    // offers that got claimed while creating this offer
    ClaimOfferAtom offersClaimed<>;

    union switch (ManageOfferEffect effect)
    {
    case MANAGE_OFFER_CREATED:
    case MANAGE_OFFER_UPDATED:
        OfferEntry offer;
    default:
        void;
    }
    offer;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (ManageOfferEffect effect)
    {
    case MANAGE_OFFER_CREATED:
    case MANAGE_OFFER_UPDATED:
        OfferEntry offer;
    default:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

union Memo switch (MemoType type)
{
case MEMO_NONE:
    void;
case MEMO_TEXT:
    string text<28>;
case MEMO_ID:
    uint64 id;
case MEMO_HASH:
    Hash hash; // the hash of what to pull from the content server
case MEMO_RETURN:
    Hash retHash; // the hash of the tx you are rejecting
};

¶ ↑

xdr source ============================================================¶ ↑

enum MemoType
{
    MEMO_NONE = 0,
    MEMO_TEXT = 1,
    MEMO_ID = 2,
    MEMO_HASH = 3,
    MEMO_RETURN = 4
};

¶ ↑

xdr source ============================================================¶ ↑

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;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
    void;
    }

¶ ↑

xdr source ============================================================¶ ↑

enum MessageType
{
    ERROR_MSG = 0,
    AUTH = 2,
    DONT_HAVE = 3,

    GET_PEERS = 4, // gets a list of peers this guy knows about
    PEERS = 5,

    GET_TX_SET = 6, // gets a particular txset by hash
    TX_SET = 7,

    TRANSACTION = 8, // pass on a tx you have heard about

    // SCP
    GET_SCP_QUORUMSET = 9,
    SCP_QUORUMSET = 10,
    SCP_MESSAGE = 11,
    GET_SCP_STATE = 12,

    // new messages
    HELLO = 13
};

¶ ↑

xdr source ============================================================¶ ↑

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;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

enum OfferEntryFlags
{
    // issuer has authorized account to perform transactions with its credit
    PASSIVE_FLAG = 1
};

¶ ↑

xdr source ============================================================¶ ↑

struct Operation
{
    // sourceAccount is the account used to run the operation
    // if not set, the runtime defaults to "sourceAccount" specified at
    // the transaction level
    AccountID* sourceAccount;

    union switch (OperationType type)
    {
    case CREATE_ACCOUNT:
        CreateAccountOp createAccountOp;
    case PAYMENT:
        PaymentOp paymentOp;
    case PATH_PAYMENT:
        PathPaymentOp pathPaymentOp;
    case MANAGE_OFFER:
        ManageOfferOp manageOfferOp;
    case CREATE_PASSIVE_OFFER:
        CreatePassiveOfferOp createPassiveOfferOp;
    case SET_OPTIONS:
        SetOptionsOp setOptionsOp;
    case CHANGE_TRUST:
        ChangeTrustOp changeTrustOp;
    case ALLOW_TRUST:
        AllowTrustOp allowTrustOp;
    case ACCOUNT_MERGE:
        AccountID destination;
    case INFLATION:
        void;
    case CREATE_LOT:
        CreateLotOp createLotOp;
    case REGISTER_PARTICIPANT:
        RegisterParticipantOp registerParticipantOp;
    case PROVIDE_PROOF:
        ProvideProofOp provideProofOp;
    case SEND_MESSAGE:
        SendMessageOp sendMessageOp;
    case CREATE_BID:
        CreateBidOp createBidOp;
    case AFFIRM_FAIL:
        AffirmFailOp affirmFailOp;
    case AFFIRM_PASS:
        AffirmPassOp affirmPassOp;
    }
    body;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (OperationType type)
    {
    case CREATE_ACCOUNT:
        CreateAccountOp createAccountOp;
    case PAYMENT:
        PaymentOp paymentOp;
    case PATH_PAYMENT:
        PathPaymentOp pathPaymentOp;
    case MANAGE_OFFER:
        ManageOfferOp manageOfferOp;
    case CREATE_PASSIVE_OFFER:
        CreatePassiveOfferOp createPassiveOfferOp;
    case SET_OPTIONS:
        SetOptionsOp setOptionsOp;
    case CHANGE_TRUST:
        ChangeTrustOp changeTrustOp;
    case ALLOW_TRUST:
        AllowTrustOp allowTrustOp;
    case ACCOUNT_MERGE:
        AccountID destination;
    case INFLATION:
        void;
    case CREATE_LOT:
        CreateLotOp createLotOp;
    case REGISTER_PARTICIPANT:
        RegisterParticipantOp registerParticipantOp;
    case PROVIDE_PROOF:
        ProvideProofOp provideProofOp;
    case SEND_MESSAGE:
        SendMessageOp sendMessageOp;
    case CREATE_BID:
        CreateBidOp createBidOp;
    case AFFIRM_FAIL:
        AffirmFailOp affirmFailOp;
    case AFFIRM_PASS:
        AffirmPassOp affirmPassOp;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct OperationMeta
{
    LedgerEntryChanges changes;
};

¶ ↑

xdr source ============================================================¶ ↑

union OperationResult switch (OperationResultCode code)
{
case opINNER:
    union switch (OperationType type)
    {
    case CREATE_ACCOUNT:
        CreateAccountResult createAccountResult;
    case PAYMENT:
        PaymentResult paymentResult;
    case PATH_PAYMENT:
        PathPaymentResult pathPaymentResult;
    case MANAGE_OFFER:
        ManageOfferResult manageOfferResult;
    case CREATE_PASSIVE_OFFER:
        ManageOfferResult createPassiveOfferResult;
    case SET_OPTIONS:
        SetOptionsResult setOptionsResult;
    case CHANGE_TRUST:
        ChangeTrustResult changeTrustResult;
    case ALLOW_TRUST:
        AllowTrustResult allowTrustResult;
    case ACCOUNT_MERGE:
        AccountMergeResult accountMergeResult;
    case INFLATION:
        InflationResult inflationResult;
    case CREATE_LOT:
        CreateLotResult createLotResult;
    case REGISTER_PARTICIPANT:
        RegisterParticipantResult registerParticipantResult;
    case PROVIDE_PROOF:
        ProvideProofResult provideProofResult;
    case SEND_MESSAGE:
        SendMessageResult sendMessageResult;
    case CREATE_BID:
        CreateBidResult createBidResult;
    case AFFIRM_FAIL:
        AffirmFailResult affirmFailResult;
    case AFFIRM_PASS:
        AffirmPassResult affirmPassResult;
    }
    tr;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (OperationType type)
    {
    case CREATE_ACCOUNT:
        CreateAccountResult createAccountResult;
    case PAYMENT:
        PaymentResult paymentResult;
    case PATH_PAYMENT:
        PathPaymentResult pathPaymentResult;
    case MANAGE_OFFER:
        ManageOfferResult manageOfferResult;
    case CREATE_PASSIVE_OFFER:
        ManageOfferResult createPassiveOfferResult;
    case SET_OPTIONS:
        SetOptionsResult setOptionsResult;
    case CHANGE_TRUST:
        ChangeTrustResult changeTrustResult;
    case ALLOW_TRUST:
        AllowTrustResult allowTrustResult;
    case ACCOUNT_MERGE:
        AccountMergeResult accountMergeResult;
    case INFLATION:
        InflationResult inflationResult;
    case CREATE_LOT:
        CreateLotResult createLotResult;
    case REGISTER_PARTICIPANT:
        RegisterParticipantResult registerParticipantResult;
    case PROVIDE_PROOF:
        ProvideProofResult provideProofResult;
    case SEND_MESSAGE:
        SendMessageResult sendMessageResult;
    case CREATE_BID:
        CreateBidResult createBidResult;
    case AFFIRM_FAIL:
        AffirmFailResult affirmFailResult;
    case AFFIRM_PASS:
        AffirmPassResult affirmPassResult;
    }

¶ ↑

xdr source ============================================================¶ ↑

enum OperationResultCode
{
    opINNER = 0, // inner object result is valid

    opBAD_AUTH = -1,  // too few valid signatures / wrong network
    opNO_ACCOUNT = -2 // source account was not found
};

¶ ↑

xdr source ============================================================¶ ↑

enum OperationType
{
    CREATE_ACCOUNT = 0,
    PAYMENT = 1,
    PATH_PAYMENT = 2,
    MANAGE_OFFER = 3,
    CREATE_PASSIVE_OFFER = 4,
    SET_OPTIONS = 5,
    CHANGE_TRUST = 6,
    ALLOW_TRUST = 7,
    ACCOUNT_MERGE = 8,
    INFLATION = 9,
    CREATE_LOT = 10,
    REGISTER_PARTICIPANT = 11,
    PROVIDE_PROOF = 12,
    SEND_MESSAGE = 13,
    CREATE_BID = 14,
    AFFIRM_FAIL = 15,
    AFFIRM_PASS = 16
};

¶ ↑

xdr source ============================================================¶ ↑

struct ParticipantEntry
{
    AccountID accountID;
    uint64 lotID;
    uint32 state;
    uint64 bestBid;
    uint32 bestBidSeq;

    // reserved for future use
    union switch (int v)
    {
    case 0:
    void;
    }
    ext;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
    void;
    }

¶ ↑

xdr source ============================================================¶ ↑

enum ParticipantState {
    APPROVED = 0,
    PENDING = 1,
    PASS = 2,
    FAIL = 3
};

¶ ↑

xdr source ============================================================¶ ↑

struct PathPaymentOp
{
    Asset sendAsset; // asset we pay with
    int64 sendMax;   // the maximum amount of sendAsset to
                     // send (excluding fees).
                     // The operation will fail if can't be met

    AccountID destination; // recipient of the payment
    Asset destAsset;       // what they end up with
    int64 destAmount;      // amount they end up with

    Asset path<5>; // additional hops it must go through to get there
};

¶ ↑

xdr source ============================================================¶ ↑

union PathPaymentResult switch (PathPaymentResultCode code)
{
case PATH_PAYMENT_SUCCESS:
    struct
    {
        ClaimOfferAtom offers<>;
        SimplePaymentResult last;
    } success;
case PATH_PAYMENT_NO_ISSUER:
    Asset noIssuer; // the asset that caused the error
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

struct
    {
        ClaimOfferAtom offers<>;
        SimplePaymentResult last;
    }

¶ ↑

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
};

¶ ↑

xdr source ============================================================¶ ↑

struct PaymentOp
{
    AccountID destination; // recipient of the payment
    Asset asset;           // what they end up with
    int64 amount;          // amount they end up with
};

¶ ↑

xdr source ============================================================¶ ↑

union PaymentResult switch (PaymentResultCode code)
{
case PAYMENT_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum PaymentResultCode
{
    // codes considered as "success" for the operation
    PAYMENT_SUCCESS = 0, // payment successfuly completed

    // codes considered as "failure" for the operation
    PAYMENT_MALFORMED = -1,          // bad input
    PAYMENT_UNDERFUNDED = -2,        // not enough funds in source account
    PAYMENT_SRC_NO_TRUST = -3,       // no trust line on source account
    PAYMENT_SRC_NOT_AUTHORIZED = -4, // source not authorized to transfer
    PAYMENT_NO_DESTINATION = -5,     // destination account does not exist
    PAYMENT_NO_TRUST = -6,       // destination missing a trust line for asset
    PAYMENT_NOT_AUTHORIZED = -7, // destination not authorized to hold asset
    PAYMENT_LINE_FULL = -8,      // destination would go above their limit
    PAYMENT_NO_ISSUER = -9       // missing issuer on asset
};

¶ ↑

xdr source ============================================================¶ ↑

struct PeerAddress
{
    union switch (IPAddrType type)
    {
    case IPv4:
        opaque ipv4[4];
    case IPv6:
        opaque ipv6[16];
    }
    ip;
    uint32 port;
    uint32 numFailures;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (IPAddrType type)
    {
    case IPv4:
        opaque ipv4[4];
    case IPv6:
        opaque ipv6[16];
    }

¶ ↑

xdr source ============================================================¶ ↑

struct Price
{
    int32 n; // numerator
    int32 d; // denominator
};

¶ ↑

xdr source ============================================================¶ ↑

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;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct ProvideProofOp
{
    uint64 lotID; // name of the lot
    uint32 quantity;
    string proof<1000>;
    uint64 bankID;
};

¶ ↑

xdr source ============================================================¶ ↑

union ProvideProofResult switch (ProvideProofResultCode code)
{
case PROVIDE_PROOF_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum ProvideProofResultCode
{
    PROVIDE_PROOF_SUCCESS = 0,
    PROVIDE_PROOF_ERROR = 1
};

¶ ↑

xdr source ============================================================¶ ↑

union PublicKey switch (CryptoKeyType type)
{
case KEY_TYPE_ED25519:
    uint256 ed25519;
};

¶ ↑

xdr source ============================================================¶ ↑

struct RegisterParticipantOp
{
    uint64 lotID; // name of the lot
    AccountID accountID;
    uint64 bestBid;
};

¶ ↑

xdr source ============================================================¶ ↑

union RegisterParticipantResult switch (RegisterParticipantResultCode code)
{
case REGISTER_PARTICIPANT_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum RegisterParticipantResultCode
{
    REGISTER_PARTICIPANT_SUCCESS = 0, // lot was created
    REGISTER_PARTICIPANT_ERROR = 1 // lot was created
};

¶ ↑

xdr source ============================================================¶ ↑

struct SCPBallot
{
    uint32 counter; // n
    Value value;    // x
};

¶ ↑

xdr source ============================================================¶ ↑

struct SCPEnvelope
{
    SCPStatement statement;
    Signature signature;
};

¶ ↑

xdr source ============================================================¶ ↑

union SCPHistoryEntry switch (int v)
{
case 0:
    SCPHistoryEntryV0 v0;
};

¶ ↑

xdr source ============================================================¶ ↑

struct SCPHistoryEntryV0
{
    SCPQuorumSet quorumSets<>; // additional quorum sets used by ledgerMessages
    LedgerSCPMessages ledgerMessages;
};

¶ ↑

xdr source ============================================================¶ ↑

struct SCPNomination
{
    Hash quorumSetHash; // D
    Value votes<>;      // X
    Value accepted<>;   // Y
};

¶ ↑

xdr source ============================================================¶ ↑

struct SCPQuorumSet
{
    uint32 threshold;
    PublicKey validators<>;
    SCPQuorumSet innerSets<>;
};

¶ ↑

xdr source ============================================================¶ ↑

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;                // c.n
            uint32 nH;                // h.n
        } prepare;
    case SCP_ST_CONFIRM:
        struct
        {
            SCPBallot ballot;   // b
            uint32 nPrepared;   // p.n
            uint32 nCommit;     // c.n
            uint32 nH;          // h.n
            Hash quorumSetHash; // D
        } confirm;
    case SCP_ST_EXTERNALIZE:
        struct
        {
            SCPBallot commit;         // c
            uint32 nH;                // h.n
            Hash commitQuorumSetHash; // D used before EXTERNALIZE
        } externalize;
    case SCP_ST_NOMINATE:
        SCPNomination nominate;
    }
    pledges;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (SCPStatementType type)
    {
    case SCP_ST_PREPARE:
        struct
        {
            Hash quorumSetHash;       // D
            SCPBallot ballot;         // b
            SCPBallot* prepared;      // p
            SCPBallot* preparedPrime; // p'
            uint32 nC;                // c.n
            uint32 nH;                // h.n
        } prepare;
    case SCP_ST_CONFIRM:
        struct
        {
            SCPBallot ballot;   // b
            uint32 nPrepared;   // p.n
            uint32 nCommit;     // c.n
            uint32 nH;          // h.n
            Hash quorumSetHash; // D
        } confirm;
    case SCP_ST_EXTERNALIZE:
        struct
        {
            SCPBallot commit;         // c
            uint32 nH;                // h.n
            Hash commitQuorumSetHash; // D used before EXTERNALIZE
        } externalize;
    case SCP_ST_NOMINATE:
        SCPNomination nominate;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct
        {
            SCPBallot ballot;   // b
            uint32 nPrepared;   // p.n
            uint32 nCommit;     // c.n
            uint32 nH;          // h.n
            Hash quorumSetHash; // D
        }

¶ ↑

xdr source ============================================================¶ ↑

struct
        {
            SCPBallot commit;         // c
            uint32 nH;                // h.n
            Hash commitQuorumSetHash; // D used before EXTERNALIZE
        }

¶ ↑

xdr source ============================================================¶ ↑

struct
        {
            Hash quorumSetHash;       // D
            SCPBallot ballot;         // b
            SCPBallot* prepared;      // p
            SCPBallot* preparedPrime; // p'
            uint32 nC;                // c.n
            uint32 nH;                // h.n
        }

¶ ↑

xdr source ============================================================¶ ↑

enum SCPStatementType
{
    SCP_ST_PREPARE = 0,
    SCP_ST_CONFIRM = 1,
    SCP_ST_EXTERNALIZE = 2,
    SCP_ST_NOMINATE = 3
};

¶ ↑

xdr source ============================================================¶ ↑

struct SendMessageOp
{
    uint64 lotID; // name of the lot
    string text<1000>;
    uint64 refMessage;
};

¶ ↑

xdr source ============================================================¶ ↑

union SendMessageResult switch (SendMessageResultCode code)
{
case SEND_MESSAGE_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum SendMessageResultCode
{
    SEND_MESSAGE_SUCCESS = 0, // lot was created
    SEND_MESSAGE_ERROR = 1 // lot was created
};

¶ ↑

xdr source ============================================================¶ ↑

struct SetOptionsOp
{
    AccountID* inflationDest; // sets the inflation destination

    uint32* clearFlags; // which flags to clear
    uint32* setFlags;   // which flags to set

    // account threshold manipulation
    uint32* masterWeight; // weight of the master account
    uint32* lowThreshold;
    uint32* medThreshold;
    uint32* highThreshold;

    string32* homeDomain; // sets the home domain

    // Add, update or remove a signer for the account
    // signer is deleted if the weight is 0
    Signer* signer;
};

¶ ↑

xdr source ============================================================¶ ↑

union SetOptionsResult switch (SetOptionsResultCode code)
{
case SET_OPTIONS_SUCCESS:
    void;
default:
    void;
};

¶ ↑

xdr source ============================================================¶ ↑

enum SetOptionsResultCode
{
    // codes considered as "success" for the operation
    SET_OPTIONS_SUCCESS = 0,
    // codes considered as "failure" for the operation
    SET_OPTIONS_LOW_RESERVE = -1,      // not enough funds to add a signer
    SET_OPTIONS_TOO_MANY_SIGNERS = -2, // max number of signers already reached
    SET_OPTIONS_BAD_FLAGS = -3,        // invalid combination of clear/set flags
    SET_OPTIONS_INVALID_INFLATION = -4,      // inflation account does not exist
    SET_OPTIONS_CANT_CHANGE = -5,            // can no longer change this option
    SET_OPTIONS_UNKNOWN_FLAG = -6,           // can't set an unknown flag
    SET_OPTIONS_THRESHOLD_OUT_OF_RANGE = -7, // bad value for weight/threshold
    SET_OPTIONS_BAD_SIGNER = -8,             // signer cannot be masterkey
    SET_OPTIONS_INVALID_HOME_DOMAIN = -9     // malformed home domain
};

¶ ↑

xdr source ============================================================¶ ↑

struct Signer
{
    AccountID pubKey;
    uint32 weight; // really only need 1byte
};

¶ ↑

xdr source ============================================================¶ ↑

struct SimplePaymentResult
{
    AccountID destination;
    Asset asset;
    int64 amount;
};

¶ ↑

xdr source ============================================================¶ ↑

union StellarMessage switch (MessageType type)
{
case ERROR_MSG:
    Error error;
case HELLO:
    Hello hello;
case AUTH:
    Auth auth;
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;
case GET_SCP_STATE:
    uint32 getSCPLedgerSeq; // ledger seq requested ; if 0, requests the latest
};

¶ ↑

xdr source ============================================================¶ ↑

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;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

enum ThresholdIndexes
{
    THRESHOLD_MASTER_WEIGHT = 0,
    THRESHOLD_LOW = 1,
    THRESHOLD_MED = 2,
    THRESHOLD_HIGH = 3
};

¶ ↑

xdr source ============================================================¶ ↑

struct TimeBounds
{
    uint64 minTime;
    uint64 maxTime;
};

¶ ↑

xdr source ============================================================¶ ↑

struct Transaction
{
    // account used to run the transaction
    AccountID sourceAccount;

    // the fee the sourceAccount will pay
    uint32 fee;

    // sequence number to consume in the account
    SequenceNumber seqNum;

    // validity range (inclusive) for the last ledger close time
    TimeBounds* timeBounds;

    Memo memo;

    Operation operations<100>;

    // reserved for future use
    union switch (int v)
    {
    case 0:
        void;
    }
    ext;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct TransactionEnvelope
{
    Transaction tx;
    DecoratedSignature signatures<20>;
};

¶ ↑

xdr source ============================================================¶ ↑

struct TransactionHistoryEntry
{
    uint32 ledgerSeq;
    TransactionSet txSet;

    // reserved for future use
    union switch (int v)
    {
    case 0:
        void;
    }
    ext;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

struct TransactionHistoryResultEntry
{
    uint32 ledgerSeq;
    TransactionResultSet txResultSet;

    // reserved for future use
    union switch (int v)
    {
    case 0:
        void;
    }
    ext;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

union TransactionMeta switch (int v)
{
case 0:
    OperationMeta operations<>;
};

¶ ↑

xdr source ============================================================¶ ↑

struct TransactionResult
{
    int64 feeCharged; // actual fee charged for the transaction

    union switch (TransactionResultCode code)
    {
    case txSUCCESS:
    case txFAILED:
        OperationResult results<>;
    default:
        void;
    }
    result;

    // reserved for future use
    union switch (int v)
    {
    case 0:
        void;
    }
    ext;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

union switch (TransactionResultCode code)
    {
    case txSUCCESS:
    case txFAILED:
        OperationResult results<>;
    default:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

enum TransactionResultCode
{
    txSUCCESS = 0, // all operations succeeded

    txFAILED = -1, // one of the operations failed (none were applied)

    txTOO_EARLY = -2,         // ledger closeTime before minTime
    txTOO_LATE = -3,          // ledger closeTime after maxTime
    txMISSING_OPERATION = -4, // no operation was specified
    txBAD_SEQ = -5,           // sequence number does not match source account

    txBAD_AUTH = -6,             // too few valid signatures / wrong network
    txINSUFFICIENT_BALANCE = -7, // fee would bring account below reserve
    txNO_ACCOUNT = -8,           // source account not found
    txINSUFFICIENT_FEE = -9,     // fee is too small
    txBAD_AUTH_EXTRA = -10,      // unused signatures attached to transaction
    txINTERNAL_ERROR = -11       // an unknown error occured
};

¶ ↑

xdr source ============================================================¶ ↑

struct TransactionResultPair
{
    Hash transactionHash;
    TransactionResult result; // result for the transaction
};

¶ ↑

xdr source ============================================================¶ ↑

struct TransactionResultSet
{
    TransactionResultPair results<MAX_TX_PER_LEDGER>;
};

¶ ↑

xdr source ============================================================¶ ↑

struct TransactionSet
{
    Hash previousLedgerHash;
    TransactionEnvelope txs<MAX_TX_PER_LEDGER>;
};

¶ ↑

xdr source ============================================================¶ ↑

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;
};

¶ ↑

xdr source ============================================================¶ ↑

union switch (int v)
    {
    case 0:
        void;
    }

¶ ↑

xdr source ============================================================¶ ↑

enum TrustLineFlags
{
    // issuer has authorized account to perform transactions with its credit
    AUTHORIZED_FLAG = 1
};

¶ ↑