xahaud/src/cpp/ripple/ripple.proto

package protocol;

enum MessageType
{
    // core
    mtHELLO                 = 1;
    mtERROR_MSG             = 2;
    mtPING                  = 3;
    mtPROOFOFWORK           = 4;
    mtCLUSTER               = 5;

    // network presence detection
    mtGET_CONTACTS          = 10;
    mtCONTACT               = 11;
    mtGET_PEERS             = 12;
    mtPEERS                 = 13;

    // operations for 'small' nodes
    mtSEARCH_TRANSACTION    = 20;
    mtGET_ACCOUNT           = 21;
    mtACCOUNT               = 22;

    // transaction and ledger processing
    mtTRANSACTION           = 30;
    mtGET_LEDGER            = 31;
    mtLEDGER_DATA           = 32;
    mtPROPOSE_LEDGER        = 33;
    mtSTATUS_CHANGE         = 34;
    mtHAVE_SET              = 35;

    // data replication and synchronization
    mtGET_VALIDATIONS       = 40;
    mtVALIDATION            = 41;
    mtGET_OBJECTS           = 42;
}


// token, iterations, target, challenge = issue demand for proof of work
// token, response = give solution to proof of work
// token, result = report result of pow

message TMProofWork
{
    required string token       = 1;
    optional uint32 iterations  = 2;
    optional bytes target       = 3;
    optional bytes challenge    = 4;
    optional bytes response     = 5;

    enum POWResult
    {
        powrOK          = 0;
        powrREUSED      = 1;
        powrEXPIRED     = 2;    // You took too long solving
        powrTOOEASY     = 3;    // Difficulty went way up, sorry
        powrINVALID     = 4;
        powrDISCONNECT  = 5;    // We are disconnecting
    }
    optional POWResult result   = 6;
}

// Sent on connect
message TMHello
{
    required uint32         protoVersion    = 1;
    required uint32         protoVersionMin = 2;
    required bytes          nodePublic      = 3;
    required bytes          nodeProof       = 4;
    optional string         fullVersion     = 5;
    optional uint64         netTime         = 6;
    optional uint32         ipv4Port        = 7;
    optional uint32         ledgerIndex     = 8;
    optional bytes          ledgerClosed    = 9;  // our last closed ledger
    optional bytes          ledgerPrevious  = 10; // the ledger before the last closed ledger
    optional bool           nodePrivate     = 11; // Request to not forward IP.
    optional TMProofWork    proofOfWork     = 12; // request/provide proof of work
    optional bool           testNet         = 13; // Running as testnet.
}

// The status of a node in our cluster
message TMClusterNode
{
    required bytes           publicKey       = 1;
    required uint32          reportTime      = 2;
    required uint32          nodeLoad        = 3;
    optional string          nodeName        = 4;
    optional string          address         = 5;
}

// The status of all nodes in the cluster
message TMCluster
{
    repeated TMClusterNode   clusterNodes    = 1;
}


// A transaction can have only one input and one output.
// If you want to send an amount that is greater than any single address of yours
// you must first combine coins from one address to another.

enum TransactionStatus
{
    tsNEW               = 1;    // origin node did/could not validate
    tsCURRENT           = 2;    // scheduled to go in this ledger
    tsCOMMITED          = 3;    // in a closed ledger
    tsREJECT_CONFLICT   = 4;
    tsREJECT_INVALID    = 5;
    tsREJECT_FUNDS      = 6;
    tsHELD_SEQ          = 7;
    tsHELD_LEDGER       = 8;    // held for future ledger
}

message TMTransaction
{
    required bytes rawTransaction           = 1;
    required TransactionStatus status       = 2;
    optional uint64 receiveTimestamp        = 3;
    optional bool checkedSignature          = 4;    // no vouches for signature being correct
}


enum NodeStatus
{
    nsCONNECTING    = 1;        // acquiring connections
    nsCONNECTED     = 2;        // convinced we are connected to the real network
    nsMONITORING    = 3;        // we know what the previous ledger is
    nsVALIDATING    = 4;        // we have the full ledger contents
    nsSHUTTING      = 5;        // node is shutting down
}

enum NodeEvent
{
    neCLOSING_LEDGER    = 1;    // closing a ledger because its close time has come
    neACCEPTED_LEDGER   = 2;    // accepting a closed ledger, we have finished computing it
    neSWITCHED_LEDGER   = 3;    // changing due to network consensus
    neLOST_SYNC         = 4;
}

message TMStatusChange
{
    optional NodeStatus newStatus       = 1;
    optional NodeEvent newEvent         = 2;
    optional uint32 ledgerSeq           = 3;
    optional bytes ledgerHash           = 4;
    optional bytes ledgerHashPrevious   = 5;
    optional uint64 networkTime         = 6;
    optional uint32 firstSeq            = 7;
    optional uint32 lastSeq             = 8;
}


// Announce to the network our position on a closing ledger
message TMProposeSet
{
    required uint32 proposeSeq          = 1;
    required bytes currentTxHash        = 2;    // the hash of the ledger we are proposing
    required bytes nodePubKey           = 3;
    required uint32 closeTime           = 4;
    required bytes signature            = 5;    // signature of above fields
    optional bytes previousledger       = 6;
    optional bool checkedSignature      = 7;    // node vouches signature is correct
    repeated bytes addedTransactions    = 10;   // not required if number is large
    repeated bytes removedTransactions  = 11;   // not required if number is large
}

enum TxSetStatus
{
    tsHAVE      = 1;    // We have this set locally
    tsCAN_GET   = 2;    // We have a peer with this set
    tsNEED      = 3;    // We need this set and can't get it
}

message TMHaveTransactionSet
{
    required TxSetStatus status     = 1;
    required bytes hash             = 2;
}


// Used to sign a final closed ledger after reprocessing
message TMValidation
{
    required bytes validation       = 1;        // in SerializedValidation signed form
    optional bool checkedSignature  = 2;        // node vouches signature is correct
}


message TMGetValidations
{
    required uint32 ledgerIndex     = 1;
    repeated bytes hanko            = 2;
    optional uint32 count           = 3; // get random validations
}



message TMContact
{
    required bytes pubKey               = 1;
    required uint32 softwareVersion     = 2;
    required uint32 protoVersion        = 3;
    required uint64 nodeFlags           = 4;
    required uint64 timestamp           = 5;
    repeated bytes nodeInfo             = 6;
    required bytes signature            = 7;
}

// request node information
message TMGetContacts
{
    repeated bytes nodeIDs          = 1; // specific nodes we want
    optional uint32 nodeCount       = 2; // get some random nodes
}

message TMGetPeers
{
    required uint32 doWeNeedThis    = 1;  // yes since you are asserting that the packet size isn't 0 in PackedMessage
}

message TMIPv4EndPoint
{
    required uint32 ipv4            = 1;
    required uint32 ipv4Port        = 2;
}

message TMPeers
{
    repeated TMIPv4EndPoint nodes   = 1;
}


message TMSearchTransaction
{
    required uint32 maxTrans    = 1;
    optional bytes toAccount    = 2;
    optional bytes fromAccount  = 3;
    optional uint32 minLedger   = 4;
    optional bytes fromAcctSeq  = 5;
    repeated bytes transID      = 6;
}

message TMGetAccount
{
    repeated bytes acctID       = 1;
    optional uint32 seq         = 2;
}

message Account
{
    required bytes accountID    = 1;
    required uint64 balance     = 2;
    required uint32 accountSeq  = 3;
    required uint32 ledgerSeq   = 4;
}

message TMAccount
{
    repeated Account accounts   = 1;
    optional uint32 seq         = 2;
}

message TMIndexedObject
{
    optional bytes hash         = 1;
    optional bytes nodeID       = 2;
    optional bytes index        = 3;
    optional bytes data         = 4;
    optional uint32 ledgerSeq   = 5;
}

message TMGetObjectByHash
{
    enum ObjectType {
        otUNKNOWN           = 0;
        otLEDGER            = 1;
        otTRANSACTION       = 2;
        otTRANSACTION_NODE  = 3;
        otSTATE_NODE        = 4;
        otCAS_OBJECT        = 5;
        otFETCH_PACK        = 6;
    }

    required ObjectType type            = 1;
    required bool query                 = 2;    // is this a query or a reply?
    optional uint32 seq                 = 3;    // used to match replies to queries
    optional bytes ledgerHash           = 4;    // the hash of the ledger these queries are for
    optional bool fat                   = 5;    // return related nodes
    repeated TMIndexedObject objects    = 6;    // the specific objects requested
}


message TMLedgerNode
{
    required bytes nodedata         = 1;
    optional bytes nodeid           = 2;    // missing for ledger base data
}

enum TMLedgerInfoType
{
    liBASE          = 0;        // basic ledger info
    liTX_NODE       = 1;        // transaction node
    liAS_NODE       = 2;        // account state node
    liTS_CANDIDATE  = 3;        // candidate transaction set
}

enum TMLedgerType
{
    ltACCEPTED      = 0;
    ltCURRENT       = 1;
    ltCLOSED        = 2;
}

enum TMQueryType
{
    qtINDIRECT      = 0;
}

message TMGetLedger
{
    required TMLedgerInfoType itype = 1;
    optional TMLedgerType ltype     = 2;
    optional bytes ledgerHash       = 3;    // Can also be the transaction set hash if liTS_CANDIDATE
    optional uint32 ledgerSeq       = 4;
    repeated bytes nodeIDs          = 5;
    optional uint64 requestCookie   = 6;
    optional TMQueryType queryType  = 7;
}

enum TMReplyError
{
    reNO_LEDGER                     = 1;    // We don't have the ledger you are asking about
    reNO_NODE                       = 2;    // We don't have any of the nodes you are asking for
}

message TMLedgerData
{
    required bytes ledgerHash       = 1;
    required uint32 ledgerSeq       = 2;
    required TMLedgerInfoType type  = 3;
    repeated TMLedgerNode nodes     = 4;
    optional uint32 requestCookie   = 5;
    optional TMReplyError error     = 6;
}

message TMPing
{
    enum pingType {
        ptPING = 0; // we want a reply
        ptPONG = 1; // this is a reply
    }
    required pingType type      = 1;
    optional uint32 seq         = 2; // detect stale replies, ensure other side is reading
    optional uint64 pingTime    = 3; // know when we think we sent the ping
    optional uint64 netTime     = 4;
}


message TMErrorMsg
{
    optional int32 errorCode    = 1;
    optional string message     = 2;
}

// vim:ts=4