Start tying all these classes together:

2025-11-20 11:05:54 +00:00 · 2011-11-18 11:23:06 -08:00
parent 4096bad636
commit fa60ccd2df
8 changed files with 159 additions and 121 deletions
--- a/Account.h
+++ b/Account.h
@@ -14,6 +14,7 @@ public:
  bool CheckSignRaw(const std::vector<unsigned char> &toSign,
    const std::vector<unsigned char> &signature) const;
  const uint160& GetAddress(void) const { return mAddress; }
+  CKey& peekPubKey() { return pubKey; }
 };

 #endif
--- a/SHAMap.cpp
+++ b/SHAMap.cpp
@@ -91,7 +91,7 @@ SHAMapLeafNode::pointer SHAMap::getLeaf(const SHAMapNode &id, const uint256& has
 	if(leaf != SHAMapLeafNode::pointer()) return leaf;

 	std::vector<unsigned char> rawNode;					// is it in backing store
-	if(!fetchNode(hash, id, rawNode)) return leaf;
+	if(!fetchNode(hash, id, rawNode)) return SHAMapLeafNode::pointer();

 	Serializer s(rawNode);	
 	leaf=SHAMapLeafNode::pointer(new SHAMapLeafNode(id));
@@ -120,7 +120,7 @@ SHAMapInnerNode::pointer SHAMap::getInner(const SHAMapNode &id, const uint256& h
 	if(node != SHAMapInnerNode::pointer()) return node;
 	
 	std::vector<unsigned char> rawNode;
-	if(!fetchNode(hash, id, rawNode)) return node;
+	if(!fetchNode(hash, id, rawNode)) return SHAMapInnerNode::pointer();

 	node=SHAMapInnerNode::pointer(new SHAMapInnerNode(id, rawNode));
 	if(node->getNodeHash()!=hash)
@@ -279,6 +279,23 @@ void SHAMapItem::dump()
 	std::cerr << "SHAMapItem(" << mTag.GetHex() << ") " << mData.size() << "bytes" << std::endl;
 }

+// overloads for backed maps
+bool SHAMap::fetchNode(const uint256 &, const SHAMapNode &, std::vector<unsigned char> &)
+{
+	return false;
+}
+
+bool SHAMap::writeNode(const uint256 &, const SHAMapNode &, const std::vector<unsigned char> &)
+{
+	return true;
+}
+
+void SHAMap::badNode(const uint256 &, const SHAMapNode &)
+{
+	return;
+}
+    
+
 void SHAMap::dump()
 {
 }
@@ -297,3 +314,4 @@ void TestSHAMap()
 
 sMap.dump();
 }
+
--- a/SHAMap.h
+++ b/SHAMap.h
@@ -2,11 +2,9 @@
 #define __SHAMAP__

 #include <list>
-#include <set>
 #include <map>

 #include <boost/shared_ptr.hpp>
-#include <boost/bimap.hpp>
 #include <boost/enable_shared_from_this.hpp>

 #include "uint256.h"
@@ -33,9 +31,9 @@ public:
 	static const int rootDepth=0;
 	static const int leafDepth=10;

-	SHAMapNode(int depth, const uint256 &hash);
+	SHAMapNode(int depth, const uint256& hash);
 	int getDepth() const		{ return mDepth; }
-	const uint256 &getNodeID()	{ return mNodeID; }
+	const uint256& getNodeID()	{ return mNodeID; }

 	bool isRoot() const			{ return mDepth==0; }
 	bool isLeaf() const			{ return mDepth==leafDepth; }
@@ -45,19 +43,19 @@ public:

 	SHAMapNode getParentNodeID()	{ return SHAMapNode(mDepth-1, mNodeID); }
 	SHAMapNode getChildNodeID(int m);
-	int selectBranch(const uint256 &hash);
+	int selectBranch(const uint256& hash);

-	bool operator<(const SHAMapNode &) const;
-	bool operator>(const SHAMapNode &) const;
-	bool operator==(const SHAMapNode &) const;
-	bool operator!=(const SHAMapNode &) const;
-	bool operator<=(const SHAMapNode &) const;
-	bool operator>=(const SHAMapNode &) const;
+	bool operator<(const SHAMapNode&) const;
+	bool operator>(const SHAMapNode&) const;
+	bool operator==(const SHAMapNode&) const;
+	bool operator!=(const SHAMapNode&) const;
+	bool operator<=(const SHAMapNode&) const;
+	bool operator>=(const SHAMapNode&) const;

 	virtual void dump(void);

 	static void ClassInit();
-	static uint256 getNodeID(int depth, const uint256 &hash);
+	static uint256 getNodeID(int depth, const uint256& hash);
 };


@@ -71,15 +69,15 @@ private:
 	std::vector<unsigned char> mData;

 public:
-	SHAMapItem(const uint256 &tag); // tag is data
-	SHAMapItem(const uint256 &tag, const std::vector<unsigned char>& data);
+	SHAMapItem(const uint256& tag); // tag is data
+	SHAMapItem(const uint256& tag, const std::vector<unsigned char>& data);
 	SHAMapItem(const std::vector<unsigned char>& data); // tag by hash

 	const uint256& getTag(void) const { return mTag; }
 	std::vector<unsigned char> getData(void) const { return mData; }
 	const std::vector<unsigned char>& peekData(void) const { return mData; }

-	void updateData(const std::vector<unsigned char> &data) { mData=data; }
+	void updateData(const std::vector<unsigned char>& data) { mData=data; }

 	bool operator<(const SHAMapItem& i) const		{ return mTag<i.mTag; }
 	bool operator>(const SHAMapItem& i) const		{ return mTag>i.mTag; }
@@ -113,7 +111,7 @@ private:
 protected:
 	bool addUpdateItem(SHAMapItem::pointer);
 	bool delItem(const SHAMapItem::pointer i) { delItem(i->getTag()); }
-	bool delItem(const uint256 &tag);
+	bool delItem(const uint256& tag);

 public:
 	SHAMapLeafNode(const SHAMapNode& nodeID);
@@ -124,8 +122,8 @@ public:
 	bool isEmpty() const			{ return mItems.empty(); }
 	int getItemCount() const		{ return mItems.size(); }

-	bool hasItem(const uint256 &item) const;
-	SHAMapItem::pointer findItem(const uint256 &tag);
+	bool hasItem(const uint256& item) const;
+	SHAMapItem::pointer findItem(const uint256& tag);
 	SHAMapItem::pointer firstItem();
 	SHAMapItem::pointer lastItem();
 	SHAMapItem::pointer nextItem(SHAMapItem::pointer);
@@ -152,7 +150,7 @@ protected:

 public:
 	SHAMapInnerNode(const SHAMapNode& id);
-	SHAMapInnerNode(const SHAMapNode& id, const std::vector<unsigned char> &contents);
+	SHAMapInnerNode(const SHAMapNode& id, const std::vector<unsigned char>& contents);

 	virtual bool isPopulated(void) const { return true; }

@@ -189,8 +187,8 @@ protected:
 	SHAMapLeafNode::pointer walkToLeaf(const uint256& id, bool create,
 		std::vector<SHAMapInnerNode::pointer>& path);

-	SHAMapLeafNode::pointer getLeaf(const SHAMapNode &id, const uint256& hash);
-	SHAMapInnerNode::pointer getInner(const SHAMapNode &id, const uint256& hash);
+	SHAMapLeafNode::pointer getLeaf(const SHAMapNode& id, const uint256& hash);
+	SHAMapInnerNode::pointer getInner(const SHAMapNode& id, const uint256& hash);

 	SHAMapItem::pointer firstBelow(SHAMapInnerNode::pointer);
 	SHAMapItem::pointer lastBelow(SHAMapInnerNode::pointer);
@@ -202,24 +200,24 @@ public:
 	ScopedLock Lock() const { return ScopedLock(mLock); }

 	// inner node access functions
-	bool hasInnerNode(const SHAMapNode &id);
+	bool hasInnerNode(const SHAMapNode& id);
 	bool giveInnerNode(SHAMapInnerNode::pointer);
 	SHAMapInnerNode::pointer getInnerNode(const SHAMapNode &);

 	// leaf node access functions
-	bool hasLeafNode(const SHAMapNode &id);
+	bool hasLeafNode(const SHAMapNode& id);
 	bool giveLeafNode(SHAMapLeafNode::pointer);
 	SHAMapLeafNode::pointer getLeafNode(const SHAMapNode &);

 	// generic node functions
-	std::vector<unsigned char> getRawNode(const SHAMapNode &id);
+	std::vector<unsigned char> getRawNode(const SHAMapNode& id);
 	bool addRawNode(const SHAMapNode& nodeID, std::vector<unsigned char> rawNode);

 	// normal hash access functions
 	bool hasItem(const uint256& id);
 	bool delItem(const uint256& id);
 	bool addItem(SHAMapItem::pointer item);
-	SHAMapItem::pointer getItem(const uint256 &id);
+	SHAMapItem::pointer getItem(const uint256& id);

 	// traverse functions
 	SHAMapItem::pointer firstItem();
@@ -228,18 +226,18 @@ public:
 	SHAMapItem::pointer prevItem(const SHAMapItem &);

 	// comparison/sync functions
-	void getMissingNodes(std::vector<SHAMapNode> &nodeHashes, int max);
-	void getMissingObjects(std::vector<uint256> &objectHashes, int max);
-	bool getNodeFat(const SHAMapNode &node, std::vector<uint256> &nodeHashes, int max);
-	bool getNodeFat(const uint256 &hash, std::vector<uint256> &nodeHashes, int max);
+	void getMissingNodes(std::vector<SHAMapNode>& nodeHashes, int max);
+	void getMissingObjects(std::vector<uint256>& objectHashes, int max);
+	bool getNodeFat(const SHAMapNode& node, std::vector<uint256>& nodeHashes, int max);
+	bool getNodeFat(const uint256& hash, std::vector<uint256>& nodeHashes, int max);
 	bool addKnownNode(const std::vector<unsigned char>& rawNode);

 	int flushDirty(int maxNodes);

 	// overloads for backed maps
-	virtual bool fetchNode(const uint256 &hash, const SHAMapNode &id, std::vector<unsigned char>& rawNode);
-	virtual bool writeNode(const uint256 &hash, const SHAMapNode &id, const std::vector<unsigned char>& rawNode);
-	virtual void badNode(const uint256 &hash, const SHAMapNode &id);
+	virtual bool fetchNode(const uint256& hash, const SHAMapNode& id, std::vector<unsigned char>& rawNode);
+	virtual bool writeNode(const uint256& hash, const SHAMapNode& id, const std::vector<unsigned char>& rawNode);
+	virtual void badNode(const uint256& hash, const SHAMapNode& id);

 	static bool TestSHAMap();
 	virtual void dump(void);
--- a/SHAMapNodes.cpp
+++ b/SHAMapNodes.cpp
@@ -67,7 +67,7 @@ uint256 SHAMapNode::getNodeID(int depth, const uint256& hash)

 SHAMapNode::SHAMapNode(int depth, const uint256 &hash)
 { // canonicalize the hash to a node ID for this depth
-	assert(depth>=0 && depth<leafDepth);
+	assert(depth>=0 && depth<=leafDepth);
 	mDepth = depth;
 	mNodeID = getNodeID(depth, hash);
 }
@@ -103,7 +103,7 @@ void SHAMapNode::dump()

 SHAMapLeafNode::SHAMapLeafNode(const SHAMapNode& nodeID) : SHAMapNode(nodeID), mHash(0)
 {
- ;
+	assert(nodeID.getDepth()==SHAMapNode::leafDepth);
 }

 bool SHAMapLeafNode::hasItem(const uint256& item) const
@@ -185,9 +185,15 @@ bool SHAMapLeafNode::updateHash(void)
 	return true;
 }

+void SHAMapLeafNode::dump()
+{
+	std::cerr << "SHAMapLeafNode(" << getNodeID().GetHex() << ")" << std::endl;
+	std::cerr << "  " << mItems.size() << " items" << std::endl;
+}
+
 SHAMapInnerNode::SHAMapInnerNode(const SHAMapNode& id) : SHAMapNode(id)
 {
-	;
+	assert(id.getDepth()<SHAMapNode::leafDepth);
 }

 SHAMapInnerNode::SHAMapInnerNode(const SHAMapNode& id, const std::vector<unsigned char>& contents)
@@ -230,3 +236,13 @@ bool SHAMapInnerNode::updateHash()
 	return true;
 }

+void SHAMapInnerNode::dump()
+{
+	std::cerr << "SHAMapInnerNode(" << getDepth() << ", " << getNodeID().GetHex() << ")" << std::endl;
+
+	int children=0;
+	for(int i=0; i<32; i++)
+		if(!!mHashes[i]) children++;
+
+	std::cerr << "  " << children << " children" << std::endl;
+}
--- a/Serializer.h
+++ b/Serializer.h
@@ -2,11 +2,17 @@
 #define __SERIALIZER__

 #include <vector>
+
+#include <boost/shared_ptr.hpp>
+
 #include "key.h"
 #include "uint256.h"

 class Serializer
 {
+	public:
+	typedef boost::shared_ptr<Serializer> pointer;
+
 	protected:
 	std::vector<unsigned char> mData;
 	
--- a/Transaction.cpp
+++ b/Transaction.cpp
@@ -11,8 +11,8 @@ Transaction::Transaction() : mTransactionID(0), mAccountFrom(0), mAccountTo(0),
 {
 }

-Transaction::Transaction(TransStatus status, LocalAccount &fromLocalAccount, const Account &fromAccount,
-        uint32 fromSeq,	const uint160 &toAccount, uint64 amount, uint32 ident, uint32 ledger) :
+Transaction::Transaction(TransStatus status, LocalAccount& fromLocalAccount, Account& fromAccount,
+		uint32 fromSeq,	const uint160& toAccount, uint64 amount, uint32 ident, uint32 ledger) :
 		mAccountTo(toAccount), mAmount(amount), mFromAccountSeq(fromSeq), mSourceLedger(ledger),
 		mIdent(ident), mInLedger(0), mStatus(NEW)
 {
@@ -24,44 +24,41 @@ Transaction::Transaction(TransStatus status, LocalAccount &fromLocalAccount, con
 	sign(fromLocalAccount, fromAccount);
 }

-bool Transaction::sign(LocalAccount &fromLocalAccount, const Account &fromAccount)
+bool Transaction::sign(LocalAccount& fromLocalAccount, Account& fromAccount)
 {
 	if( (mAmount==0) || (mSourceLedger==0) || (mAccountTo==0) )
 		return false;
 	if((mAccountFrom!=fromLocalAccount.mAddress)||(mAccountFrom!=fromAccount.GetAddress()))
 		return false;
 	
-    updateHash();
-
-    std::vector<unsigned char> toSign, Signature;
-    if(!getRawUnsigned(toSign, fromAccount)) return false;
-    if(!fromLocalAccount.SignRaw(toSign, Signature)) return false;
-    mSignature=Signature;
-    return true;
+	Serializer::pointer signBuf(getRawUnsigned(fromAccount));
+	if(!signBuf->makeSignature(mSignature, fromLocalAccount.peekPrivKey()))
+	    return false;
+    signBuf->addRaw(mSignature);
+    mTransactionID=signBuf->getSHA512Half();
 }

-bool Transaction::checkSign(const Account &fromAccount) const
+bool Transaction::checkSign(Account& fromAccount) const
 {
 	if(mAccountFrom!=fromAccount.GetAddress()) return false;

-    std::vector<unsigned char> toSign;
-    if(!getRawUnsigned(toSign, fromAccount)) return false;
-
-    return fromAccount.CheckSignRaw(toSign, mSignature);
+	Serializer::pointer toSign(getRawUnsigned(fromAccount));
+	return toSign->checkSignature(mSignature, fromAccount.peekPubKey());
 }

-bool Transaction::getRawUnsigned(std::vector<unsigned char> &raw, const Account &fromAccount) const
+Serializer::pointer Transaction::getRawUnsigned(Account& fromAccount) const
 {
-    raw.clear();
-        
+	Serializer::pointer ret(new Serializer(104));
+	ret->add32(0x54584e00u);
+	ret->addRaw(fromAccount.peekPubKey().GetPubKey());
+	ret->add64(mAmount);
+	ret->add32(mFromAccountSeq);
+	ret->add32(mInLedger);
+	ret->add32(mIdent);
+	return ret;
 }

-#if 0
-void Transaction::UpdateHash()
-{ // FIXME
-    vector<unsigned char> buffer;
-    buffer.resize(trans->ByteSize());
-    trans->SerializeToArray(&(buffer[0]),buffer.size());
-    return Hash(buffer.begin(), buffer.end());
+void Transaction::updateID(Account& fromAccount)
+{
+	mTransactionID=getRawSigned(fromAccount)->getSHA512Half();
 }
-#endif
--- a/Transaction.h
+++ b/Transaction.h
@@ -41,20 +41,19 @@ private:
 	uint32		mInLedger;
 	TransStatus	mStatus;

-	void UpdateHash(void);
-
 public:
 	Transaction();
 	Transaction(const std::vector<unsigned char> rawTransaction);
 	Transaction(const std::string sqlReply);
-	Transaction(TransStatus Status, LocalAccount& fromLocal, const Account& from,
+	Transaction(TransStatus Status, LocalAccount& fromLocal, Account& from,
 		uint32 fromSeq, const uint160& to, uint64 amount, uint32 ident, uint32 ledger);

-	bool sign(LocalAccount& fromLocalAccount, const Account& fromAccount);
-	bool checkSign(const Account& fromAccount) const;
+	bool sign(LocalAccount& fromLocalAccount, Account& fromAccount);
+	bool checkSign(Account& fromAccount) const;
+	void updateID(Account& fromAccount);

-	Serializer::pointer getRawUnsigned(const Account& from) const;
-	Serializer::pointer getRawSigned(const Account& from) const;
+	Serializer::pointer getRawUnsigned(Account& from) const;
+	Serializer::pointer getRawSigned(Account& from) const;

 	const uint256& getID() const { return mTransactionID; }
 	const uint160& getFromAccount() const { return mAccountFrom; }
--- a/Wallet.h
+++ b/Wallet.h
@@ -4,6 +4,7 @@
 #include "keystore.h"
 #include "newcoin.pb.h"
 #include "Transaction.h"
+#include "Serializer.h"
 #include <list>
 #include <vector>

@@ -22,8 +23,10 @@ public:
 	int64 mAmount;
 	uint32 mSeqNum;

-	bool SignRaw(const std::vector<unsigned char> &toSign, std::vector<unsigned char> &signature);
-	bool CheckSignRaw(const std::vector<unsigned char> &toSign, const std::vector<unsigned char> &signature);
+	bool signRaw(Serializer::pointer);
+	bool signRaw(Serializer::pointer, std::vector<unsigned char>& signature);
+	bool checkSignRaw(Serializer::pointer, int signaturePosition=-1, int signedData=-1);
+	CKey& peekPrivKey() { return mPrivateKey; }
 };

 class Wallet : public CBasicKeyStore