Changeset 279

Timestamp:

04/27/09 17:48:41 (3 years ago)

Author:

ocjhb

Message:

client can now buy coins

Location:

trunk/sandbox/jhb

Files:

• oc2/data (added)
• oc2/documentation.py (modified) (1 diff)
• oc2/entity.py (modified) (1 diff)
• oc2/storage.py (modified) (1 diff)
• oc2/testissuer.py (added)
• oc2/testwallet.py (added)
• oc2/wallet.py (modified) (2 diffs)
• pys60/btsocket.py.jhb (moved) (moved from trunk/sandbox/jhb/pys60/btsocket.py) (2 diffs, 1 prop)
• pys60/data (added)
• pys60/ocwallet.py (modified) (5 diffs)

trunk/sandbox/jhb/oc2/documentation.py

@@ -1 +1 @@
 """
+
 ###############################################################################
 Setup an issuer

trunk/sandbox/jhb/oc2/entity.py

@@ -1 +1 @@
 import occrypto,container
-from storage import Item
 
 class Entity(object):

trunk/sandbox/jhb/oc2/storage.py

@@ -1 @@
-import pickle,base64
-class Item(object):
-    
-    def dump(self,path):
-        return base64.b64encode(pickle.dumps(self))
+import UserDict, cPickle
+class Storage(UserDict.UserDict):
 
-    def load(self,path):
-        return pickle.loads(base64.decode(open(path).read()))
+    def setFilename(self,filename):
+        self.filename = filename
+        return self
+
+    def save(self):
+        cPickle.dump(self.data,open(self.filename,'w'))
+        return self
+
+    def restore(self):
+        try:
+            self.data = cPickle.load(open(self.filename))
+        except:            
+            pass
+        return self
+

trunk/sandbox/jhb/oc2/wallet.py

@@ -53 +53 @@
         if not (denominations or keyids):
             raise "you need to ask at least for one"
-        
         message = messages.FetchMintKeys()
-        message.denominations = denominations
+        message.denominations = [str(d) for d in denominations]
         message.keyids = keyids
         
         response = transport(message)
-
         if response.header == 'MINTING_KEY_FAILURE':
             raise message
@@ -146 +144 @@
         return answer
 
+
+    def getCurrency(self,id):
+        if self.storage.has_key(id):
+            return self.storage[id]
+        else:
+            currency = dict(cdds=[],
+                            blanks = {},
+                            coins = [],
+                            transactions = {})
+            self.storage[id]=currency
+            return currency
+
+    def listCurrencies(self):
+        out = []
+        for key,currency in self.storage.items():
+            cdd = currency['cdds'][-1]
+            amount = sum([int(coin.denomination) for coin in currency['coins']])
+            out.append((cdd,amount))
+        return out            
+
+    def deleteCurrency(self,id):
+        del(self.storage[id])
+
+
+    def tokenizeForBuying(self,amount,denominations):
+        denominations = [int(d) for d in denominations]
+        denominations.sort()
+        denominations.reverse()
+
+        out = []
+        for d in denominations:
+            while amount and amount >= d:
+                out.append(d)
+                amount -= d
+        return out                
+
+        
+
+#################################higher level#############################
+
+    def addCurrency(self,transport):
+        cdd = self.askLatestCDD(transport)
+        id = cdd.currencyId
+        currency = self.getCurrency(id)
+        if cdd.version not in [cdd.version for cdd in currency['cdds']]:
+            currency['cdds'].append(cdd)
+
+    def buyCoins(self,transport,amount,target):
+        cdd = self.askLatestCDD(transport)
+        currency = self.getCurrency(cdd.currencyId)
+        tokenized =  self.tokenizeForBuying(amount,cdd.denominations) #what coins do we need
+        wanted = list(set(tokenized)) #what mkcs do we want
+        
+        keys = self.fetchMintKeys(transport,denominations=wanted)
+        mkcs = {}
+        for mkc in keys:
+            if not cdd.masterPubKey.verifyContainerSignature(mkc):
+                raise 'Invalid signature on mkc'
+            mkcs[mkc.denomination] = mkc
+        
+        secrets = []
+        data = []
+        print tokenized
+        for denomination in tokenized:
+            mkc = mkcs[str(denomination)]
+            blank = self._makeBlank(cdd,mkc)
+            secret,blind = mkc.publicKey.blindBlank(blank)
+            secrets.append((blank,blind,mkc,secret))
+            data.append((mkc.keyId,blind))
+
+        tid = self.makeSerial() 
+        response = self.requestTransfer(transport,tid,target,data,[])                 
+        i = 0
+        signatures = response.signatures
+        for signature in signatures:
+            blank,blind,mkc,secret = secrets[i]
+            key = mkc.publicKey
+            blank.signature = key.unblind(secret,signature)
+            coin = blank
+            if not key.verifyContainerSignature(coin):
+                raise 'Invalid signature' 
+            currency['coins'].append(coin)
+            i += 1
+            self.storage.save()

trunk/sandbox/jhb/pys60/btsocket.py.jhb

@@ -30 +30 @@
 default_access_point = None
 
+class AccessPoint(object):
+    def __init__(self,apid=None):
+        self.apid = apid
+
+    def start(self):
+        pass
+    def stop(self):
+        pass
+
+    def ip(self):
+        return 'fake ip'
+
 def select_access_point():
    """
@@ -45 +57 @@
    This creates access point object by given apid. Returns access point object.
    """
-   return repr(apid)
+   return AccessPoint(apid)
    
 def set_default_access_point(apo):

trunk/sandbox/jhb/pys60/ocwallet.py

@@ -3 +3 @@
 from key_codes import EKeyLeftArrow, EKeyRightArrow
 
+from oc2 import storage,wallet, transports
 
 class WalletClient:
 
-    def __init__(self,wallet):
-        self.wallet = wallet
+    def __init__(self,storage):
+        self.storage = storage
+        self.wallet = wallet.Wallet(storage)
         self.makeWalletMenu()
         self.displayWalletMenu()        
@@ -13 +15 @@
                       (u'Receive',u'Receive coins',self.getReceiveDetails),
                       (u'Freshen up',u'Freshen up the coins',self.getFreshenUpDetails),
-                      (u'Buy',u'Buy new coins',self.getDetails),
+                      (u'Buy',u'Buy new coins',self.buyCoins),
                       (u'Sell',u'Sell coins',self.getDetails),
                       (u'Details',u'See what coins you hold',self.inspect),]
 
-        self.methods=[(u'Internet',u'Use the net'),
+        self.methods=[(u'Internet',u'Use the internet'),
                       (u'Bluetooth',u'Mobile to mobile')]
         
         self.todo = {}
-
+        self.apo = None
 
     def makeWalletMenu(self):
-        self.wallet_list = [(u'12 hubtokens',u'the-hub.net'),(u'14 greenbucks',u'opencoin.org')]
+        self.wallet_list = []
+        tmp = [(cdd.currencyId,cdd,amount) for cdd,amount in self.wallet.listCurrencies()]
+        tmp.sort()
+        self.currencies = [(t[1],t[2]) for t in tmp]
+
+        for cdd,amount in self.currencies:
+            title = u'%s %ss' % (amount,cdd.currencyId)
+            description = unicode(cdd.issuerServiceLocation)
+            self.wallet_list.append((title,description))
         self.wallet_menu =  appuifw.Listbox(self.wallet_list,self.displayActionMenu)
         self.wallet_menu.bind(EKeyRightArrow,self.displayActionMenu)
@@ -31 +41 @@
         appuifw.app.body =  self.wallet_menu
         appuifw.app.title = u'opencoin - main\nchoose your currency'
+        appuifw.app.menu = [(u'add Currency',self.addCurrency),
+                            (u'delete Currency',self.delCurrency)]
 
     def displayActionMenu(self):
@@ -47 +59 @@
         self.actions[current][2]()
 
+
+    def getAmount(self):
+        amount = appuifw.query(u'Amount','number')
+        amount = int(amount)
+        self.todo['amount'] = amount
+        return amount
+
+    def getTarget(self):
+        target = ''
+        while target == '':
+            target = appuifw.query(u'Reference','text')
+        self.todo['target'] = target
+        return target            
+
     def getDetails(self):
-        amount = appuifw.query(u'amount','number')
-        self.todo['amount'] = amount
+        
+        amount = self.getAmount()
+        if not amount:
+            return
 
-        target = appuifw.query(u'subject','text')
-        self.todo['target'] = target
+        target = self.getTarget()
+        if not target:
+            return
 
         method = self.getMethod()
@@ -80 +109 @@
         #print 'inspect'
         pass
+
+
+    def addCurrency(self):
+        url = appuifw.query(u'url','text',u'http://localhost:9090')
+        self.todo['url'] = url
+        transport = self.getHTTPTransport(url) 
+        self.wallet.addCurrency(transport)
+        self.makeWalletMenu()
+        self.displayWalletMenu()
+
+
+    def getCurrentCurrency(self):
+        return self.currencies[self.wallet_menu.current()]
+
+    def delCurrency(self):
+        cdd,amount = self.getCurrentCurrency()
+        id = cdd.currencyId
+        result = appuifw.query(u'Delete %s %ss?' % (amount,id),'query')
+        if result:
+            self.wallet.deleteCurrency(id)
+        self.makeWalletMenu()
+        self.displayWalletMenu()
+
+    def buyCoins(self):
+        amount = self.getAmount()
+        if not amount:
+            return
         
+        target = self.getTarget()
+        if not target:
+            return
+
+        cdd,alreadythere = self.getCurrentCurrency()
+        url = cdd.issuerServiceLocation
+
+        transport = transports.HTTPTransport(url)
+        self.wallet.buyCoins(transport,amount,target)
+        self.makeWalletMenu()
+        self.displayWalletMenu()
+
     def execute(self):
         #print 'execute'
         print self.todo
 
+
+    def getHTTPTransport(self,url):
+        self.startInternet()
+        transport = transports.HTTPTransport(url)
+        return transport
+
+    def startInternet(self):
+        if not self.apo:
+            import sys
+            try:
+                sys.modules['socket'] = __import__('btsocket')
+                import socket
+                apid = socket.select_access_point()
+                apo = socket.access_point(apid)
+                socket.set_default_access_point(apo)
+                apo.start()
+                self.apo = apo
+                self.ip = apo.ip()
+
+            except ImportError:
+                import socket
+            
+
+    def stopInternet(self):
+        if self.apo:
+            self.apo.stop()
+            self.apo = None
+
+
+
+    
+
 #appuifw.app.screen='full'
 app_lock = e32.Ao_lock()
-w = WalletClient({})
+storage = storage.Storage()
+storage.setFilename('data/wallet.bin')
+storage.restore()
+
+w = WalletClient(storage)
 appuifw.app.screen='normal'
 appuifw.app.exit_key_handler = app_lock.signal
 import time
 app_lock.wait()
+storage.save()
 print 'fini'