diff --git a/src/SerializedLedger.cpp b/src/SerializedLedger.cpp
index 3ae422ec79..937673d2ee 100644
--- a/src/SerializedLedger.cpp
+++ b/src/SerializedLedger.cpp
@@ -1,3 +1,52 @@
 
 #include "SerializedLedger.h"
 
+SerializedLedger::SerializedLedger(SerializerIterator& sit, const uint256& index)
+	: STObject("LedgerEntry"), mIndex(index)
+{
+	uint16 type=sit.get16();
+	mFormat=getLgrFormat(static_cast<LedgerEntryType>(type));
+	if(mFormat==NULL) throw std::runtime_error("invalid ledger entry type");
+	mType=mFormat->t_type;
+	mVersion.setValue(type);
+	mObject=STObject(mFormat->elements, sit, "Entry");
+}
+
+SerializedLedger::SerializedLedger(LedgerEntryType type) : STObject("LedgerEntry"), mType(type)
+{
+	mFormat=getLgrFormat(type);
+	if(mFormat==NULL) throw std::runtime_error("invalid ledger entry type");
+	mVersion.setValue(static_cast<uint16>(mFormat->t_type));
+	mObject=STObject(mFormat->elements, "Entry");
+}
+
+std::string SerializedLedger::getFullText() const
+{
+	std::string ret="\"";
+	ret+=mIndex.GetHex();
+	ret+="\" = { ";
+	ret+=mFormat->t_name;
+	ret+=", ";
+	ret+=mObject.getFullText();
+	ret+="}";
+	return ret;
+}
+
+std::string SerializedLedger::getText() const
+{
+	std::string ret="{";
+	ret+=mIndex.GetHex();
+	ret+=mVersion.getText();
+	ret+=mObject.getText();
+	ret+="}";
+	return ret;
+}
+
+bool SerializedLedger::isEquivalent(const SerializedType& t) const
+{ // locators are not compared
+	const SerializedLedger* v=dynamic_cast<const SerializedLedger*>(&t);
+	if(!v) return false;
+	if(mType != v->mType) return false;
+	if(mObject != v->mObject) return false;
+	return true;
+}
diff --git a/src/SerializedLedger.h b/src/SerializedLedger.h
index 4bdc7d8d4a..3cca93bec4 100644
--- a/src/SerializedLedger.h
+++ b/src/SerializedLedger.h
@@ -10,21 +10,59 @@ public:
 	typedef boost::shared_ptr<SerializedLedger> pointer;
 
 protected:
+	uint256 mIndex;
 	LedgerEntryType mType;
 	STUInt16 mVersion;
 	STObject mObject;
 	LedgerEntryFormat* mFormat;
 
 public:
-	SerializedLedger(SerializerIterator& sit);
+	SerializedLedger(SerializerIterator& sit, const uint256& index);
 	SerializedLedger(LedgerEntryType type);
 
 	int getLength() const { return mVersion.getLength() + mObject.getLength(); }
-	SerializedTypeID getType() const { return STI_LEDGERENTRY; }
-    SerializedLedger* duplicate() const { return new SerializedLedger(*this); }
-    std::string getFullText() const;
-    std::string getText() const;
-    void add(Serializer& s) const { mVersion.add(s); mObject.add(s); }
+	SerializedTypeID getSType() const { return STI_LEDGERENTRY; }
+	SerializedLedger* duplicate() const { return new SerializedLedger(*this); }
+	std::string getFullText() const;
+	std::string getText() const;
+	void add(Serializer& s) const { mVersion.add(s); mObject.add(s); }
+	virtual bool isEquivalent(const SerializedType& t) const;
+
+	const uint256& getIndex() const { return mIndex; }
+	void setIndex(const uint256& i) { mIndex=i; }
+
+	LedgerEntryType getType() const { return mType; }
+	uint16 getVersion() const { return mVersion.getValue(); }
+	LedgerEntryFormat* getFormat() { return mFormat; }
+
+	int getIFieldIndex(SOE_Field field) const { return mObject.getFieldIndex(field); }
+	int getIFieldCount() const { return mObject.getCount(); }
+	const SerializedType& peekIField(SOE_Field field) const { return mObject.peekAtField(field); }
+	SerializedType& getIField(SOE_Field field) { return mObject.getField(field); }
+
+	std::string getIFieldString(SOE_Field field) const { return mObject.getFieldString(field); }
+	unsigned char getIFieldU8(SOE_Field field) const { return mObject.getValueFieldU8(field); }
+	uint16 getIFieldU16(SOE_Field field) const { return mObject.getValueFieldU16(field); }
+	uint32 getIFieldU32(SOE_Field field) const { return mObject.getValueFieldU32(field); }
+	uint64 getIFieldU64(SOE_Field field) const { return mObject.getValueFieldU64(field); }
+	uint160 getIFieldH160(SOE_Field field) const { return mObject.getValueFieldH160(field); }
+	uint256 getIFieldH256(SOE_Field field) const { return mObject.getValueFieldH256(field); }
+	std::vector<unsigned char> getIFieldVL(SOE_Field field) const { return mObject.getValueFieldVL(field); }
+	std::vector<TaggedListItem> getIFieldTL(SOE_Field field) const { return mObject.getValueFieldTL(field); }
+	void setIFieldU8(SOE_Field field, unsigned char v) { return mObject.setValueFieldU8(field, v); }
+	void setIFieldU16(SOE_Field field, uint16 v) { return mObject.setValueFieldU16(field, v); }
+	void setIFieldU32(SOE_Field field, uint32 v) { return mObject.setValueFieldU32(field, v); }
+	void setIFieldU64(SOE_Field field, uint32 v) { return mObject.setValueFieldU64(field, v); }
+	void setIFieldH160(SOE_Field field, const uint160& v) { return mObject.setValueFieldH160(field, v); }
+	void setIFieldH256(SOE_Field field, const uint256& v) { return mObject.setValueFieldH256(field, v); }
+	void setIFieldVL(SOE_Field field, const std::vector<unsigned char>& v)
+		{ return mObject.setValueFieldVL(field, v); }
+	void setIFieldTL(SOE_Field field, const std::vector<TaggedListItem>& v)
+		{ return mObject.setValueFieldTL(field, v); }
+
+	bool getIFieldPresent(SOE_Field field) const { return mObject.isFieldPresent(field); }
+	void makeIFieldPresent(SOE_Field field) { return mObject.makeFieldPresent(field); }
+	void makeIFieldAbsent(SOE_Field field) { return mObject.makeFieldAbsent(field); }
 
 
 };