Changeset 266 for trunk

Timestamp:

04/12/09 13:56:00 (3 years ago)

Author:

ocjhb

Message:

work I did on the train

Location:

trunk/sandbox/jhb/oc2

Files:

• documentation.py (modified) (7 diffs)
• issuer.py (modified) (2 diffs)
• messages.py (modified) (2 diffs)
• mint.py (modified) (2 diffs)
• protocols.py (modified) (2 diffs)
• testserver.py (modified) (2 diffs)

trunk/sandbox/jhb/oc2/documentation.py

@@ -355 +355 @@
 >>> tid = wallet.makeSerial()
 
+>>> int(mkc.denomination)
+5
+
 ###############################################################################
 
@@ -419 +422 @@
 
   to issuer service
-
-* Issuer: if request will not be minted (e.g., "Bad Key ID" if the key_id
-  is not current):
-
-        TRANSFER_TOKEN_REJECT( transaction_id, reason,
-            list( (blind1.key_id, reason1), ... ), (empty list1)  )
-
-  ElseIf minting is done just-in-time, IS answers
-
-        TRANSFER_TOKEN_ACCEPT( transaction_id, message, list_of_signed_blinds)
-
-  Else IS queues blind to the mint and tells wallet to wait
-
-        TRANSFER_TOKEN_DELAY( transaction_id, reason )
-
-  Session is terminated.
-
-
-  In case of delayed minting, mint processes request (signs blind with key_id)
-  some time later and passes "signed blind"="blind token" back to IS 
-
-
-###############################################################################
-
-We first need to setup something to sign the requests for authorization
+  
+  
+###############################################################################
+
+We first need to setup an authorizer, to (surpise) authorize the request. Nils says
+the mint should more or less just mint
 
 >>> from authorizer import Authorizer
@@ -450 +434 @@
 >>> mint.addAuthKey(authpub)
 >>> authorizer.setMKCs(mkcs)
-
-
-good, lets start the action
 >>> clientside = protocols.TransferRequest(transport,tid,'foo',[[mkc.keyId,blind]],[])
+
+###############################################################################
+
+* Issuer: if request will not be minted (e.g., "Bad Key ID" if the key_id
+  is not current):
+
+        TRANSFER_TOKEN_REJECT( transaction_id, reason,
+            list( (blind1.key_id, reason1), ... ), (empty list1)  )
+        
+###############################################################################
+>>> import time
+>>> time.sleep(1)
+>>> authorizer.deny = True
 >>> testserver.run_once(port,mint=mint,authorizer=authorizer)
 >>> text,value =  clientside.run()
 >>> text
-u'minted'
+'TransferReject'
+
+
+###############################################################################
+
+  ElseIf minting is done just-in-time, IS answers
+
+        TRANSFER_TOKEN_ACCEPT( transaction_id, message, list_of_signed_blinds)
+
+###############################################################################
+
+>>> authorizer.deny = False
+>>> testserver.run_once(port,mint=mint,authorizer=authorizer)
+>>> text,value =  clientside.run()
+>>> text
+'TransferAccept'
 >>> blindsign = value[0]
 >>> blank.signature = key.unblind(secret,blindsign)
@@ -464 +473 @@
 True
 
-###############################################################################
+We don't have a transport between mint and issuer yet. Lets have the mint
+stuff coins directly into the issuer 
+
+>>> mint.addToTransactions = issuer.addToTransactions
+
+
+###############################################################################
+
+  Else IS queues blind to the mint and tells wallet to wait
+
+        TRANSFER_TOKEN_DELAY( transaction_id, reason )
+
+
+###############################################################################
+
+>>> mint.delay = True
+>>> testserver.run_once(port,mint=mint,authorizer=authorizer)
+>>> text,value =  clientside.run()
+>>> text
+'TransferDelay'
+>>> mint.delay = False
+
+###############################################################################
+
+
+  Session is terminated.
+
+
+  In case of delayed minting, mint processes request (signs blind with key_id)
+  some time later and passes "signed blind"="blind token" back to IS 
+
+
+
+
+
+
+
 3.5 Wallet gets token back
 
@@ -480 +525 @@
 
         TRANSFER_TOKEN_DELAY( transaction_id, reason )
-    
+
+###############################################################################
+
+>>> issuer.delay = True
+>>> clientside = protocols.TransferResume(transport,tid)
+>>> testserver.run_once(port,issuer=issuer)
+>>> text,value =  clientside.run()
+>>> text
+'TransferDelay'
+>>> issuer.delay = False
+
+###############################################################################
+
   (question: what about key expiration while request is in mining queue)
   (oierw thinks: as long as the key is valid for minting when the request is made, we are good)
@@ -487 +544 @@
 
         TRANSFER_TOKEN_ACCEPT( transaction_id, message, list_of_singed_blinds )
-    
+   
+
+###############################################################################
+
+>>> clientside = protocols.TransferResume(transport,tid)
+>>> testserver.run_once(port,issuer=issuer)
+>>> text,value =  clientside.run()
+>>> text
+'TransferAccept'
+
+###############################################################################
+
   Session terminates
 
@@ -495 +563 @@
 
 * Wallet unblinds signed blind and yields token  (or reblinds)
+
+###############################################################################
+
+>>> blindsign = value[0]
+>>> blank.signature = key.unblind(secret,blindsign)
+>>> coin = blank
+>>> key.verifyContainerSignature(coin)
+True
+
+###############################################################################
 
 

trunk/sandbox/jhb/oc2/issuer.py

@@ -3 +3 @@
 
 class Issuer(Entity):
- 
+
+    def __init__(self,storage=None):
+        Entity.__init__(self,storage)
+        self.delay = False
+
     def createMasterKeys(self):
         priv,pub = occrypto.KeyFactory(1024)
@@ -84 +88 @@
     def getMKCById(self,keyid,default=None):
         return self.storage.setdefault('keyidlist',{}).get(keyid,default)
+
+    def addToTransactions(self,transactionId,signatures):
+        self.storage.setdefault('transactions',{})[transactionId]=signatures
+
+    def getTransactionResult(self,transactionId):
+        if self.delay:
+            return None
+        else:            
+            return self.storage.setdefault('transactions',{}).get(transactionId,None)

trunk/sandbox/jhb/oc2/messages.py

@@ -42 +42 @@
 class TransferAccept(Message):
     fields = Message.fields + [
-        Field('text'),
         Field('signatures'),
     ]
@@ -63 +62 @@
     pass
 
+class TransferDelay(Message):
+     fields = Message.fields + [
+        Field('transactionId'),
+        Field('reason'),
+    ]
 
+class TransferResume(Message):
+     fields = Message.fields + [
+        Field('transactionId'),
+    ]
+
+

trunk/sandbox/jhb/oc2/mint.py

@@ -3 +3 @@
 class Mint(Entity):
 
+    def __init__(self,storage=None):
+        Entity.__init__(self,storage)
+        self.delay = False
 
     def setCDD(self,cdd):
@@ -62 +65 @@
             signature = priv.sign(blind)
             result.append(signature)
-                    
-        return ('minted',result)
 
+        if self.delay:
+            
+            self.addToTransactions(message.transactionId,result)
+            return('delayed','mint asked to delay')
+        else:            
+            return ('minted',result)
 
+    def addToTransactions(self,transactionId,result):
+        self.storage.setdefault('transactions',{})[transactionId]=result

trunk/sandbox/jhb/oc2/protocols.py

@@ -105 +105 @@
             return ('TransferDelay','')
         elif header == 'TransferAccept':
-            return (response.text,response.signatures)
+            return ('TransferAccept',response.signatures)
         else:
             raise 'unknown thing'
@@ -128 +128 @@
 
             text,value = response
-            if value:
+            if text=='minted':
                 answer = messages.TransferAccept()
-                answer.text = text
                 answer.signatures = value
+            elif text =='delayed':
+                answer = messages.TransferDelay()
+                answer.transactionId = message.transactionId
+                answer.reason = value
             else:
                 raise 'something went wrong'
         return answer    
 
+class TransferResume(Protocol):
+
+    def __init__(self,transport,transactionId):
+        self.transport = transport
+        self.transactionId = transactionId
+
+    def run(self,message=None):
+        message = messages.TransferResume()
+        message.transactionId = self.transactionId
+        response = self.transport(message)
+        header = response.header
+        if header == 'TransferReject':
+            return ('TransferReject','')
+        elif header == 'TransferDelay':
+            return ('TransferDelay','')
+        elif header == 'TransferAccept':
+            return ('TransferAccept',response.signatures)
+        else:
+            raise 'unknown thing'
+
+        return response.cdd 
+
+class TransferResumeHandling(Protocol):
+
+    def __init__(self,issuer):
+        self.issuer = issuer
+
+    def run(self,message):
+            
+        signatures = self.issuer.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    
+
+
 class CoinsSpendSender(Protocol):
 

trunk/sandbox/jhb/oc2/testserver.py

@@ -19 +19 @@
         elif message.header == 'TransferRequest':
             protocol = protocols.TransferHandling(self.mint,self.authorizer)
+        elif message.header == 'TransferResume':
+            protocol = protocols.TransferResumeHandling(self.issuer)
+ 
         answer = protocol.run(message)
         self.send_response(200)
@@ -26 +29 @@
 
 
+
 def run_once(port,issuer=None,mint=None,authorizer=None):
+    import time
+    time.sleep(0.001)
     Handler.issuer = issuer
     Handler.mint = mint