Merge pull request #16 from CodaProtocol/feature/currency-support

Add currency support to library

Author: nholland94

.gitignore

@@ -1,3 +1,4 @@
 *egg-info/
 build/*
-dist/*
+dist/*
+__pycache__

CodaClient.py

@@ -6,6 +6,89 @@
 import asyncio
 import websockets
 import logging
+from enum import Enum
+
+class CurrencyFormat(Enum):
+  WHOLE = 1
+  NANO = 2
+
+class CurrencyUnderflow(Exception):
+  pass
+
+class Currency():
+  @classmethod
+  def __nanocodas_from_int(_cls, n):
+    return n * 1000000000
+
+  @classmethod
+  def __nanocodas_from_string(_cls, s):
+    segments = s.split('.')
+    if len(segments) == 1:
+      return int(segments[0])
+    elif len(segments) == 2:
+      [l, r] = segments
+      if len(r) <= 9:
+        return int(l + r + ('0' * (9 - len(r))))
+      else:
+        raise Exception('invalid coda currency format: %s' % s)
+
+  def __init__(self, value, format=CurrencyFormat.WHOLE):
+    if format == CurrencyFormat.WHOLE:
+      if isinstance(value, int):
+        self.__nanocodas = Currency.__nanocodas_from_int(value)
+      elif isinstance(value, float):
+        self.__nanocodas = Currency.__nanocodas_from_string(str(value))
+      elif isinstance(value, str):
+        self.__nanocodas = Currency.__nanocodas_from_string(value)
+      else:
+        raise Exception('cannot construct whole Currency from %s' % type(value))
+    elif format == CurrencyFormat.NANO:
+      if isinstance(value, int):
+        self.__nanocodas = value
+      else:
+        raise Exception('cannot construct nano Currency from %s' % type(value))
+    else:
+      raise Exception('invalid Currency format %s' % format)
+
+  def decimal_format(self):
+    s = str(self.__nanocodas)
+    if len(s) > 9:
+      return s[:-9] + '.' + s[-9:]
+    else:
+      return '0.' + ('0' * (9 - len(s))) + s
+
+  def nanocodas(self):
+    return self.__nanocodas
+
+  def __str__(self):
+    return self.decimal_format()
+
+  def __repr__(self):
+    return 'Currency(%s)' % self.decimal_format()
+
+  def __add__(self, other):
+    if isinstance(other, Currency):
+      return Currency(self.nanocodas() + other.nanocodas(), format=CurrencyFormat.NANO)
+    else:
+      raise Exception('cannot add Currency and %s' % type(other))
+
+  def __sub__(self, other):
+    if isinstance(other, Currency):
+      new_value = self.nanocodas() - other.nanocodas()
+      if new_value >= 0:
+        return Currency(new_value, format=CurrencyFormat.NANO)
+      else:
+        raise CurrencyUnderflow()
+    else:
+      raise Exception('cannot subtract Currency and %s' % type(other))
+
+  def __mul__(self, other):
+    if isinstance(other, int):
+      return Currency(self.nanocodas() * other, format=CurrencyFormat.NANO)
+    elif isinstance(other, Currency):
+      return Currency(self.nanocodas() * other.nanocodas(), format=CurrencyFormat.NANO)
+    else:
+      raise Exception('cannot multiply Currency and %s' % type(other))
 
 class Client():
   # Implements a GraphQL Client for the Coda Daemon
@@ -386,7 +469,7 @@ def set_current_snark_worker(self, worker_pk: str, fee: str) -> dict:
     res = self._send_mutation(query, variables)
     return res["data"]
 
-  def send_payment(self, to_pk: str, from_pk: str, amount: int, fee: int, memo: str) -> dict:
+  def send_payment(self, to_pk: str, from_pk: str, amount: Currency, fee: Currency, memo: str) -> dict:
     """Send a payment from the specified wallet to the specified target wallet. 
     
     Arguments:
@@ -424,8 +507,8 @@ def send_payment(self, to_pk: str, from_pk: str, amount: int, fee: int, memo: st
     variables = {
       "from": from_pk,
       "to": to_pk,
-      "amount": amount,
-      "fee": fee,
+      "amount": amount.nanocodas(),
+      "fee": fee.nanocodas(),
       "memo": memo
     }
     res = self._send_mutation(query, variables)
@@ -545,4 +628,4 @@ async def listen_new_blocks(self, callback):
     '''
     variables = {
     }
-    await self._graphql_subscription(query, variables, callback)
+    await self._graphql_subscription(query, variables, callback)

tests/test_currency.py

@@ -0,0 +1,40 @@
+from CodaClient import CurrencyFormat, CurrencyUnderflow, Currency
+
+precision = 10 ** 9
+
+def test_constructor_whole_int():
+  n = 500
+  assert Currency(n).nanocodas() == n * precision
+
+def test_constructor_whole_float():
+  n = 5.5
+  assert Currency(n).nanocodas() == n * precision
+
+def test_constructor_whole_string():
+  n = "5.5"
+  assert Currency(n).nanocodas() == float(n) * precision
+
+def test_constructor_nano_int():
+  n = 500
+  assert Currency(n, format=CurrencyFormat.NANO)
+
+def test_add():
+  assert (Currency(5) + Currency(2)).nanocodas() == 7 * precision
+
+def test_sub():
+  assert (Currency(5) - Currency(2)).nanocodas() == 3 * precision
+
+def test_sub_underflow():
+  try:
+    Currency(5) - Currency(7)
+    raise Exception('no underflow')
+  except CurrencyUnderflow:
+    pass
+  except:
+    raise
+
+def test_mul_int():
+  assert (Currency(5) * 2).nanocodas() == 10 * precision
+
+def test_mul_currency():
+  assert (Currency(5) * Currency(2, format=CurrencyFormat.NANO)).nanocodas() == 10 * precision