Merge branch 'release/0.2.1'

Author: xeroc

bitshares/dex.py

@@ -149,13 +149,19 @@ def close_debt_position(self, symbol, account=None):
         })
         return self.blockchain.finalizeOp(op, account["name"], "active")
 
-    def adjust_debt(self, delta, new_collateral_ratio=None, account=None):
+    def adjust_debt(self, delta, new_collateral_ratio=None, account=None, target_collateral_ratio=None):
         """ Adjust the amount of debt for an asset
 
-            :param Amount delta: Delta amount of the debt (-10 means reduce debt by 10, +10 means borrow another 10)
-            :param float new_collateral_ratio: collateral ratio to maintain (optional, by default tries to maintain old ratio)
+            :param Amount delta: Delta amount of the debt (-10 means reduce
+                debt by 10, +10 means borrow another 10)
+                :param float new_collateral_ratio: collateral ratio to maintain
+                (optional, by default tries to maintain old ratio)
+            :param float target_collateral_ratio: Tag the call order so that in
+                case of margin call, only enough debt is covered to get back to
+                this ratio
             :raises ValueError: if symbol is not a bitasset
-            :raises ValueError: if collateral ratio is smaller than maintenance collateral ratio
+            :raises ValueError: if collateral ratio is smaller than maintenance
+                collateral ratio
             :raises ValueError: if required amounts of collateral are not available
         """
         if not account:
@@ -178,14 +184,11 @@ def adjust_debt(self, delta, new_collateral_ratio=None, account=None):
 
         # Check minimum collateral ratio
         backing_asset_id = bitasset["options"]["short_backing_asset"]
-        # maintenance_col_ratio = bitasset["current_feed"]["maintenance_collateral_ratio"] / 1000
         current_debts = self.list_debt_positions(account)
         if not new_collateral_ratio and symbol not in current_debts:
-            new_collateral_ratio = maintenance_col_ratio
+            new_collateral_ratio = bitasset["current_feed"]["maintenance_collateral_ratio"] / 1000
         elif not new_collateral_ratio and symbol in current_debts:
             new_collateral_ratio = current_debts[symbol]["ratio"]
-        # if maintenance_col_ratio > new_collateral_ratio:
-        #     raise ValueError("Collateral Ratio has to be higher than %5.2f" % maintenance_col_ratio)
 
         # Derive Amount of Collateral
         collateral_asset = Asset(
@@ -212,7 +215,7 @@ def adjust_debt(self, delta, new_collateral_ratio=None, account=None):
             raise ValueError("Not enough funds available. Need %f %s, but only %f %s are available" %
                              (fundsNeeded, collateral_asset["symbol"], fundsHave, collateral_asset["symbol"]))
 
-        op = operations.Call_order_update(**{
+        payload = {
             'fee': {'amount': 0, 'asset_id': '1.3.0'},
             'delta_debt': {
                 'amount': int(float(delta) * 10 ** asset["precision"]),
@@ -221,15 +224,25 @@ def adjust_debt(self, delta, new_collateral_ratio=None, account=None):
                 'amount': int(float(amount_of_collateral) * 10 ** collateral_asset["precision"]),
                 'asset_id': collateral_asset["id"]},
             'funding_account': account["id"],
-            'extensions': []
-        })
+            'extensions': {}
+        }
+        # Extension
+        if target_collateral_ratio:
+            payload["extensions"].update(dict(
+                target_collateral_ratio=int(target_collateral_ratio * 100)
+            ))
+
+        op = operations.Call_order_update(**payload)
         return self.blockchain.finalizeOp(op, account["name"], "active")
 
-    def adjust_collateral_ratio(self, symbol, target_collateral_ratio, account=None):
+    def adjust_collateral_ratio(self, symbol, new_collateral_ratio, account=None, target_collateral_ratio=None):
         """ Adjust the collataral ratio of a debt position
 
             :param Asset amount: Amount to borrow (denoted in 'asset')
-            :param float target_collateral_ratio: desired collateral ratio
+            :param float new_collateral_ratio: desired collateral ratio
+            :param float target_collateral_ratio: Tag the call order so that in
+                case of margin call, only enough debt is covered to get back to
+                this ratio
             :raises ValueError: if symbol is not a bitasset
             :raises ValueError: if collateral ratio is smaller than maintenance collateral ratio
             :raises ValueError: if required amounts of collateral are not available
@@ -243,17 +256,20 @@ def adjust_collateral_ratio(self, symbol, target_collateral_ratio, account=None)
         current_debts = self.list_debt_positions(account)
         if symbol not in current_debts:
             raise ValueError("No Call position available to adjust! Please borrow first!")
-        return self.adjust_debt(Amount(0, symbol), target_collateral_ratio, account)
+        return self.adjust_debt(Amount(0, symbol), new_collateral_ratio, account, target_collateral_ratio=target_collateral_ratio)
 
-    def borrow(self, amount, collateral_ratio=None, account=None):
+    def borrow(self, amount, collateral_ratio=None, account=None, target_collateral_ratio=None):
         """ Borrow bitassets/smartcoins from the network by putting up
             collateral in a CFD at a given collateral ratio.
 
             :param float amount: Amount to borrow (denoted in 'asset')
             :param float collateral_ratio: Collateral ratio to borrow at
+            :param float target_collateral_ratio: Tag the call order so that in
+                case of margin call, only enough debt is covered to get back to
+                this ratio
             :raises ValueError: if symbol is not a bitasset
             :raises ValueError: if collateral ratio is smaller than maintenance collateral ratio
             :raises ValueError: if required amounts of collateral are not available
 
         """
-        return self.adjust_debt(amount, collateral_ratio, account)
+        return self.adjust_debt(amount, collateral_ratio, account, target_collateral_ratio=target_collateral_ratio)

bitshares/message.py

@@ -44,10 +44,10 @@
 """
 
 
-class Message():
+class Message(BlockchainInstance):
 
-    def __init__(self, message, **kwargs):
-        BlockchainInstance.__init__(self, **kwargs)
+    def __init__(self, message, *args, **kwargs):
+        BlockchainInstance.__init__(self, *args, **kwargs)
         self.message = message
 
     def sign(self, account=None, **kwargs):

bitshares/wallet.py

@@ -142,12 +142,14 @@ def created(self):
     def create(self, pwd):
         """ Alias for newWallet()
         """
-        pass
+        self.newWallet(pwd)
 
     def newWallet(self, pwd):
         """ Create a new wallet database
         """
-        pass
+        if self.created():
+            raise WalletExists("You already have created a wallet!")
+        self.store.unlock(pwd)
 
     def addPrivateKey(self, wif):
         """ Add a private key to the wallet database

bitsharesbase/account.py

@@ -1,11 +1,151 @@
 from graphenebase.account import (
-    PasswordKey,
-    BrainKey,
-    Address,
-    PublicKey,
-    PrivateKey,
-    Prefix
+    PasswordKey as GPHPasswordKey,
+    BrainKey as GPHBrainKey,
+    Address as GPHAddress,
+    PublicKey as GPHPublicKey,
+    PrivateKey as GPHPrivateKey
 )
 
-# Redefine default prefix
-Prefix.prefix = "BTS"
+import sys
+import hashlib
+from binascii import hexlify, unhexlify
+
+
+class PasswordKey(GPHPasswordKey):
+    """ This class derives a private key given the account name, the
+        role and a password. It leverages the technology of Brainkeys
+        and allows people to have a secure private key by providing a
+        passphrase only.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(PasswordKey, self).__init__(*args, **kwargs)
+
+    # overloaded from GHPPasswordKey, JUST to set prefix='BTS' :(
+    def get_private(self):
+        """ Derive private key from the brain key and the current sequence
+            number
+        """
+        if sys.version > '3':
+            a = bytes(self.account + self.role + self.password, 'utf8')
+        else:
+            a = bytes(self.account + self.role + self.password).encode('utf8')
+        s = hashlib.sha256(a).digest()
+        return PrivateKey(hexlify(s).decode('ascii'))
+
+
+class BrainKey(GPHBrainKey):
+    """Brainkey implementation similar to the graphene-ui web-wallet.
+
+        :param str brainkey: Brain Key
+        :param int sequence: Sequence number for consecutive keys
+
+        Keys in Graphene are derived from a seed brain key which is a string of
+        16 words out of a predefined dictionary with 49744 words. It is a
+        simple single-chain key derivation scheme that is not compatible with
+        BIP44 but easy to use.
+
+        Given the brain key, a private key is derived as::
+
+            privkey = SHA256(SHA512(brainkey + " " + sequence))
+
+        Incrementing the sequence number yields a new key that can be
+        regenerated given the brain key.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(BrainKey, self).__init__(*args, **kwargs)
+
+    # overloaded from GHPBrainKey, JUST to set prefix='BTS' :(
+    def get_private(self):
+        """ Derive private key from the brain key and the current sequence
+            number
+        """
+        encoded = "%s %d" % (self.brainkey, self.sequence)
+        if sys.version > '3':
+            a = bytes(encoded, 'ascii')
+        else:
+            a = bytes(encoded).encode('ascii')
+        s = hashlib.sha256(hashlib.sha512(a).digest()).digest()
+        return PrivateKey(hexlify(s).decode('ascii'))
+
+    def get_blind_private(self):
+        """ Derive private key from the brain key (and no sequence number)
+        """
+        if sys.version > '3':
+            a = bytes(self.brainkey, 'ascii')
+        else:
+            a = bytes(self.brainkey).encode('ascii')
+        return PrivateKey(hashlib.sha256(a).hexdigest())
+
+
+class Address(GPHAddress):
+    """ Address class
+
+        This class serves as an address representation for Public Keys.
+
+        :param str address: Base58 encoded address (defaults to ``None``)
+        :param str pubkey: Base58 encoded pubkey (defaults to ``None``)
+        :param str prefix: Network prefix (defaults to ``BTS``)
+
+        Example::
+
+           Address("BTSFN9r6VYzBK8EKtMewfNbfiGCr56pHDBFi")
+
+    """
+    def __init__(self, *args, **kwargs):
+        if "prefix" not in kwargs:
+            kwargs["prefix"] = "BTS"  # make prefix BTS
+        super(Address, self).__init__(*args, **kwargs)
+
+
+class PublicKey(GPHPublicKey):
+    """ This class deals with Public Keys and inherits ``Address``.
+
+        :param str pk: Base58 encoded public key
+        :param str prefix: Network prefix (defaults to ``BTS``)
+
+        Example:::
+
+           PublicKey("BTS6UtYWWs3rkZGV8JA86qrgkG6tyFksgECefKE1MiH4HkLD8PFGL")
+
+        .. note:: By default, graphene-based networks deal with **compressed**
+                  public keys. If an **uncompressed** key is required, the
+                  method ``unCompressed`` can be used::
+
+                      PublicKey("xxxxx").unCompressed()
+
+    """
+    def __init__(self, *args, **kwargs):
+        if "prefix" not in kwargs:
+            kwargs["prefix"] = "BTS"  # make prefix BTS
+        super(PublicKey, self).__init__(*args, **kwargs)
+
+
+class PrivateKey(GPHPrivateKey):
+    """ Derives the compressed and uncompressed public keys and
+        constructs two instances of ``PublicKey``:
+
+        :param str wif: Base58check-encoded wif key
+        :param str prefix: Network prefix (defaults to ``BTS``)
+
+        Example:::
+
+            PrivateKey("5HqUkGuo62BfcJU5vNhTXKJRXuUi9QSE6jp8C3uBJ2BVHtB8WSd")
+
+        Compressed vs. Uncompressed:
+
+        * ``PrivateKey("w-i-f").pubkey``:
+            Instance of ``PublicKey`` using compressed key.
+        * ``PrivateKey("w-i-f").pubkey.address``:
+            Instance of ``Address`` using compressed key.
+        * ``PrivateKey("w-i-f").uncompressed``:
+            Instance of ``PublicKey`` using uncompressed key.
+        * ``PrivateKey("w-i-f").uncompressed.address``:
+            Instance of ``Address`` using uncompressed key.
+
+    """
+    def __init__(self, *args, **kwargs):
+        if "prefix" not in kwargs:
+            kwargs["prefix"] = "BTS"  # make prefix BTS
+        super(PrivateKey, self).__init__(*args, **kwargs)