Changeset 277 for trunk

Timestamp:

04/24/09 16:17:24 (3 years ago)

Author:

ocjhb

Message:

protocols removed, functionality now in wallet and issuer

Location:

trunk/sandbox/jhb/oc2

Files:

• containerbase.py (modified) (1 diff)
• documentation.py (modified) (16 diffs)
• issuer.py (modified) (2 diffs)
• protocols.py (deleted)
• testserver.py (modified) (1 diff)
• wallet.py (modified) (2 diffs)

trunk/sandbox/jhb/oc2/containerbase.py

@@ -97 +97 @@
     fields = []
 
-    def __init__(self,data={},**kwargs):
-        if not data and kwargs:
-            data = kwargs
+    def __init__(self,data={}):
         self.fromData(data)
-
-    def __xrepr__(self):
-        return "<%s(%s)>" % (self.__class__.__name__,self.getData(True))
-
-    def __xstr__(self):
-        return self.toString()
 
     def fromData(self,data):

trunk/sandbox/jhb/oc2/documentation.py

@@ -1 +1 @@
 """
+###############################################################################
 Setup an issuer
 
@@ -18 +19 @@
 
 
+###############################################################################
 mint (regularily) creates keypairs (pP,sP) for all denominations and id(p). 
 Master key holder generates keys certificate
@@ -37 +39 @@
 >>> wallet = Wallet({})
 >>> import protocols
->>> serverside = protocols.GiveLatestCDD(issuer)
->>> clientside = protocols.AskLatestCDD(serverside.run)
->>> cdd == clientside.run()
+>>> cdd == wallet.askLatestCDD(issuer.giveLatestCDD)
 True
 
@@ -46 +46 @@
 >>> import testserver
 >>> transport = transports.HTTPTransport('http://localhost:%s/' % port)
->>> clientside = protocols.AskLatestCDD(transport)
 >>> testserver.run_once(port,issuer)
->>> cdd2 =  clientside.run()
+>>> cdd2 = wallet.askLatestCDD(transport)
 >>> cdd2.toString(True) == cdd.toString(True)
 True
@@ -54 +53 @@
 
 
+###############################################################################
 Wallet: fetches current public minting keys for denomination
 
->>> clientside = protocols.FetchMintKeys(transport,denominations=['1','5'])
 >>> testserver.run_once(port,issuer)
->>> mkcs =  clientside.run()
+>>> mkcs = wallet.fetchMintKeys(transport,denominations=['1','5'])
 >>> mkcs[0].toString() == issuer.getCurrentMKCs()['1'].toString()
 True
@@ -80 +79 @@
 
 
+###############################################################################
 Lets try to get a coin minted
 
@@ -90 +90 @@
 >>> mint.addAuthKey(authpub)
 >>> authorizer.setMKCs(mkcs)
->>> clientside = protocols.TransferRequest(transport,tid,'foo',[[mkc.keyId,blind]],[])
 
 Lets have the authorizer denying the request
 
 >>> authorizer.deny = True
->>> testserver.run_once(port,mint=mint,authorizer=authorizer)
->>> clientside.run().header
+>>> testserver.run_once(port,issuer=issuer,mint=mint,authorizer=authorizer)
+>>> wallet.requestTransfer(transport,tid,'foo',[[mkc.keyId,blind]],[]).header
 'TransferReject'
 
@@ -102 +101 @@
 
 >>> authorizer.deny = False
->>> testserver.run_once(port,mint=mint,authorizer=authorizer)
->>> response = clientside.run()
+>>> testserver.run_once(port,issuer=issuer,mint=mint,authorizer=authorizer)
+>>> response = wallet.requestTransfer(transport,tid,'foo',[[mkc.keyId,blind]],[])
 >>> response.header
 'TransferAccept'
@@ -123 +122 @@
 
 >>> mint.delay = True
->>> testserver.run_once(port,mint=mint,authorizer=authorizer)
->>> clientside.run().header
+>>> testserver.run_once(port,issuer=issuer,mint=mint,authorizer=authorizer)
+>>> wallet.requestTransfer(transport,tid,'foo',[[mkc.keyId,blind]],[]).header
 'TransferDelay'
 
@@ -132 +131 @@
 
 >>> issuer.delay = True
->>> clientside = protocols.TransferResume(transport,tid)
 >>> testserver.run_once(port,issuer=issuer)
->>> clientside.run().header
+>>> wallet.resumeTransfer(transport,tid).header
 'TransferDelay'
 >>> issuer.delay = False
@@ -140 +138 @@
 So we need to resume
 
->>> clientside = protocols.TransferResume(transport,tid)
 >>> testserver.run_once(port,issuer=issuer)
->>> response = clientside.run()
->>> response.header
+>>> wallet.resumeTransfer(transport,tid).header
 'TransferAccept'
 
@@ -156 +152 @@
 
 
+###############################################################################
 Now, wallet to wallet. We setup an alice and a bob side. Alice announces
 a sum, and bob dedices if he wants to accept it
 
+>>> alice = wallet
 >>> bobport = 9091
->>> bobwallet = Wallet({})
+>>> bob = Wallet({})
 >>> import test
->>> alicetid = wallet.makeSerial()
->>> bob = protocols.SumAnnounceListen(bobwallet)
->>> alice = protocols.SumAnnounce(bob.run, wallet, alicetid, 5, 'foobar') 
->>> bobwallet.approval = "I don't like odd sums"
->>> alice.run()
+>>> bob.approval = "I don't like odd sums"
+>>> alicetid = alice.makeSerial()
+>>> alice.announceSum(bob.listenSum, alicetid, 5, 'foobar') 
 "I don't like odd sums"
 
->>> bobwallet.approval = True
->>> alice.run()
+>>> bob.approval = True
+>>> wallet.announceSum(bob.listenSum, alicetid, 5, 'foobar') 
 True
 
@@ -179 +175 @@
 
 Lets have first a wrong transactionId
-
->>> bob = protocols.SpendListen(bobwallet)
 >>> #transport = transports.YieldTransport(bob.run,[])
->>> alice = protocols.SpendRequest(bob.run, wallet, 'foobar', [coin]) 
->>> alice.run()
+>>> alice.requestSpend(bob.listenSpend,'foobar',[coin])
 Traceback (most recent call last):
     ....
@@ -190 +183 @@
 Or lets try to send a wrong amount
 
->>> alice = protocols.SpendRequest(bob.run, wallet, alicetid, []) 
->>> alice.run()
+>>> alice.requestSpend(bob.listenSpend,alicetid,[])
 Traceback (most recent call last):
     ....
 SpendReject: amount of coins does not match announced one
 
->>> alice = protocols.SpendRequest(bob.run, wallet, alicetid, [coin]) 
->>> alice.run()
-True
-
+>>> alice.requestSpend(bob.listenSpend, alicetid, [coin]) 
+True
+
+
+
+###############################################################################
 Now, lets first pretend we are on Bobs side. Fix that later, but assume we 
 received the coins, we know what cdd and mkc to use. We need to exchange now
@@ -205 +199 @@
 >>> coins = [coin]
 >>> key = mkc.publicKey
->>> bobblank = bobwallet._makeBlank(cdd,mkc)
+>>> bobblank = bob._makeBlank(cdd,mkc)
 >>> bobsecret, bobblind = key.blindBlank(bobblank)
 >>> blinds = [[mkc.keyId,bobblind]]
 >>> bobtid = wallet.makeSerial()
 
->>> clientside = protocols.TransferRequest(transport,tid,blinds = blinds, coins = coins)
 >>> testserver.run_once(port,issuer=issuer,mint=mint)
->>> response = clientside.run()
+>>> response = bob.requestTransfer(transport,tid,blinds = blinds, coins = coins)
 >>> bobblank.signature = key.unblind(bobsecret,response.signatures[0])
 >>> bobcoin = bobblank
@@ -221 +214 @@
 
 >>> import messages
->>> bobblank = bobwallet._makeBlank(cdd,mkc)
+>>> bobblank = bob._makeBlank(cdd,mkc)
 >>> bobsecret, bobblind = key.blindBlank(bobblank)
 >>> blinds = [[mkc.keyId,bobblind]]
 >>> bobtid = wallet.makeSerial()
->>> clientside = protocols.TransferRequest(transport,tid,blinds = blinds, coins = coins)
 >>> testserver.run_once(port,issuer=issuer,mint=mint)
->>> clientside.run().header
+>>> wallet.requestTransfer(transport,tid,blinds = blinds, coins = coins).header
 'TransferReject'
 
 
 
+###############################################################################
 Last step - bob wants to redeem the coins
 
 >>> bobtid = wallet.makeSerial()
->>> clientside = protocols.TransferRequest(transport,tid,target='foo', coins = [bobcoin])
 >>> testserver.run_once(port,issuer=issuer,mint=mint)
->>> clientside.run().header
+>>> bob.requestTransfer(transport,tid,target='foo', coins = [bobcoin]).header
 'TransferAccept'
 

trunk/sandbox/jhb/oc2/issuer.py

@@ -1 +1 @@
 from entity import *
 import datetime
+import messages
 
 class Issuer(Entity):
@@ -97 +98 @@
         else:            
             return self.storage.setdefault('transactions',{}).get(transactionId,None)
+
+    def giveLatestCDD(self,message):
+        answer = messages.GiveLatestCDD()
+        answer.cdd = self.getCDD()
+        return answer
+
+
+    def giveMintKeys(self,message):
+        keys = []
+        if message.denominations:
+            keyslist = self.getCurrentMKCs()
+            for d in message.denominations:
+                keys.append(keyslist.get(d))
+        elif message.keyids:
+            for id in message.keyids:
+                keys.append(self.getKeyById(id))
+        
+        answer = messages.GiveMintKeys()
+        answer.keys = keys
+        return answer
+
+    def handleTransferRequest(self,mint,authorizer,message):
+        options = dict(message.options)
+        requesttype = options['type']
+        
+        if requesttype == 'mint':
+            authorizedMessage = authorizer.authorize(message)
+            if type(authorizedMessage) == messages.Error:
+                return messages.TransferReject()
+            else:
+                return mint.handleMintingRequest(authorizedMessage)
+        
+        elif requesttype == 'exchange':
+            return mint.handleExchangeRequest(message)
+                        
+        elif requesttype == 'redeem':
+            return mint.handleRedeemRequest(message)
+        
+        else:
+            return messages.TransferReject()
+
+    def resumeTransfer(self,message):
+        signatures = self.getTransactionResult(message.transactionId)
+        if signatures:
+            answer = messages.TransferAccept()
+            answer.signatures = signatures
+        else:
+            answer = messages.TransferDelay()
+            answer.transactionId = message.transactionId
+            answer.reason = 'issuer has no coins yet'
+        return answer 
+

trunk/sandbox/jhb/oc2/testserver.py

@@ -14 +14 @@
         message = transports.createMessage(data)
         if message.header == 'AskLatestCDD':
-            protocol = protocols.GiveLatestCDD(self.issuer)
+            answer = self.issuer.giveLatestCDD(message)
         elif message.header == 'FetchMintKeys':
-            protocol = protocols.GiveMintKeys(self.issuer)
+            answer = self.issuer.giveMintKeys(message)
         elif message.header == 'TransferRequest':
-            protocol = protocols.TransferHandling(self.mint,self.authorizer)
+            answer = self.issuer.handleTransferRequest(self.mint,self.authorizer,message)
         elif message.header == 'TransferResume':
-            protocol = protocols.TransferResumeHandling(self.issuer)
+            answer = self.issuer.resumeTransfer(message)
  
-        answer = protocol.run(message)
         self.send_response(200)
         self.send_header("Content-type", "text/plain")

trunk/sandbox/jhb/oc2/wallet.py

@@ -3 +3 @@
 from container import *
 import occrypto
+import messages
 
 class Wallet(Entity):
@@ -41 +42 @@
         return approval
         
+
+    def askLatestCDD(self,transport):
+        response = transport(messages.AskLatestCDD())
+        return response.cdd
+
+
+    def fetchMintKeys(self,transport,denominations=None,keyids=None):
+        if denominations and keyids:
+            raise "you can't ask for denominations and keyids at the same time"
+        if not (denominations or keyids):
+            raise "you need to ask at least for one"
         
+        message = messages.FetchMintKeys()
+        message.denominations = denominations
+        message.keyids = keyids
+        
+        response = transport(message)
+
+        if response.header == 'MINTING_KEY_FAILURE':
+            raise message
+        else:
+            return  response.keys
+       
+
+    def requestTransfer(self,transport,transactionId,target=None,blinds=None,coins=None):
+        if target and blinds:
+            requesttype = 'mint'
+        elif target and coins:
+            requesttype = 'redeem'
+        elif blinds and coins:
+            requesttype = 'exchange'
+        else:
+            raise 'Not a valid combination of options'
+        
+        message = messages.TransferRequest()
+        message.transactionId = transactionId
+        message.target = target
+        message.blinds = blinds
+        message.coins = coins
+        message.options = dict(type=requesttype).items()
+
+        response = transport(message)
+        return response
+
+    def resumeTransfer(self,transport,transactionId):
+        message = messages.TransferResume()
+        message.transactionId = transactionId
+        response = transport(message)
+        return response
+
+
+    def announceSum(self,transport,tid,amount,target):
+        message = messages.SumAnnounce()
+        message.transactionId = tid
+        message.amount = amount    
+        message.target = target
+        self.addOutgoing(message)
+        response = transport(message)
+        if response.header == 'SumReject':
+            return response.reason
+        else:
+            return True
+
+    def listenSum(self,message):
+        approval = self.getApproval(message)
+        if approval == True:
+            answer = messages.SumAccept()
+        else:
+            answer = messages.SumReject()
+            answer.reason = approval
+        answer.transactionId = message.transactionId            
+        return answer
+
+    def requestSpend(self,transport,tid,coins):
+        message = messages.SpendRequest() 
+        message.transactionId = tid
+        message.coins = coins
+        response = transport(message)
+        if response.header == 'SpendReject':
+            raise response
+        else:
+            return True
+
+    def listenSpend(self,message):
+        tid = message.transactionId
+        amount = sum([int(m.denomination) for m in message.coins])
+        #check transactionid
+        orig = self.getIncoming(tid)
+        if not orig:
+            answer = messages.SpendReject()
+            answer.reason = 'unknown transactionId'
+            return answer
+        #check sum
+        if amount != int(orig.amount):
+            answer = messages.SpendReject()
+            answer.reason = 'amount of coins does not match announced one'
+            return answer
+        #do exchange
+
+
+        answer = messages.SpendAccept()
+        answer.transactionId = tid
+        return answer
+