package ripple;

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

// 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.
}


// 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