Improve HTLC create and redeem

Allow HTLC to be created from hash value, rather than preimage. Add support for Hash160 hash algorithm. Support preimage length of 0 for unrestricted.  In redeem, add option to interpret preimage as either ascii or hex bytes.

Author: christophersanborn

bitshares/bitshares.py

@@ -1566,12 +1566,32 @@ def htlc_create(
         self,
         amount,
         to,
-        preimage,
-        hash_type="ripemd160",
-        account=None,
+        *args, # force remaining args to be named not positional
+        hash_type=None,
+        hash_hex=None,
         expiration=60 * 60,
+        preimage=None,
+        preimage_length=0,
+        account=None,
         **kwargs
     ):
+        """Create an HTLC contract.
+
+        :param Amount amount: Amount to lock
+        :param str to: Recipient
+        :param int expiration: Contract duration in seconds
+        :param str hash_hex: Hash as string of hex digits
+        :param str preimage: Preimage as ascii string. Note hex digits would be
+            interpretted as ascii text, not as bytes. Not generally recommended
+            to use this option. Options hash_hex and preimage are mutually
+            exclusive.
+        :param int preimage_length: If non-zero, htlc contract will require
+            preimage of exact length. Generally OK to leave this as zero. Note
+            if preimage param is provided, this value SHOULD be either zero or
+            match exactly the length of the preimage, else an irredeemable htlc
+            will be created. Optionally, a sentinal value of -1 can be used to
+            compute length automatically from the preimage param.
+        """
         import hashlib
         from binascii import hexlify
         from graphenebase.base58 import ripemd160
@@ -1587,37 +1607,63 @@ def htlc_create(
         if not isinstance(amount, (Amount)):
             raise ValueError("'amount' must be of type Amount")
 
+        if preimage is not None and hash_hex is not None:
+            raise ValueError("Must provide either a hash or a preimage, but not both")
+
         if hash_type == "ripemd160":
             preimage_type = 0
-            preimage_hash = hexlify(
-                ripemd160(hexlify(bytes(preimage, "utf-8")))
-            ).decode("ascii")
         elif hash_type == "sha1":
             preimage_type = 1
-            preimage_hash = hashlib.sha1(bytes(preimage, "utf-8")).hexdigest()
         elif hash_type == "sha256":
             preimage_type = 2
-            preimage_hash = hashlib.sha256(bytes(preimage, "utf-8")).hexdigest()
+        elif hash_type == "hash160":
+            preimage_type = 3
         else:
             raise ValueError(
-                "Unknown 'hash_type'. Must be 'sha1', 'sha256', or 'ripemd160'"
+                "Unknown 'hash_type'. Must be 'sha1', 'sha256', 'ripemd160', 'hash160'"
             )
 
+        if preimage is not None:
+            preimage_size = len(preimage) if preimage_length == -1 else preimage_length
+            if hash_type == "ripemd160":
+                preimage_hash = hexlify(
+                    ripemd160(hexlify(bytes(preimage, "utf-8")))
+                ).decode("ascii")
+            elif hash_type == "sha1":
+                preimage_hash = hashlib.sha1(bytes(preimage, "utf-8")).hexdigest()
+            elif hash_type == "sha256":
+                preimage_hash = hashlib.sha256(bytes(preimage, "utf-8")).hexdigest()
+            elif hash_type == "hash160":
+                preimage_hash = hexlify(ripemd160(
+                        hashlib.sha256(bytes(preimage, "utf-8")).hexdigest()
+                )).decode("ascii")
+        elif hash_hex is not None:
+            preimage_hash = hexlify(bytes.fromhex(hash_hex)).decode("ascii")
+            preimage_size = preimage_length
+        else:
+            raise ValueError("Must provide either a hash or a preimage")
+
         op = operations.Htlc_create(
             **{
                 "fee": {"amount": 0, "asset_id": "1.3.0"},
                 "from": account["id"],
                 "to": to["id"],
                 "amount": amount.json(),
                 "preimage_hash": [preimage_type, preimage_hash],
-                "preimage_size": len(preimage),
+                "preimage_size": preimage_size,
                 "claim_period_seconds": expiration,
                 "extensions": [],
             }
         )
         return self.finalizeOp(op, account, "active", **kwargs)
 
-    def htlc_redeem(self, htlc_id, preimage, account=None, **kwargs):
+
+    def htlc_redeem(self, htlc_id, preimage, encoding="utf-8", account=None, **kwargs):
+        """Redeem an htlc contract
+
+        :param str preimage: The preimage that unlocks the htlc
+        :param str encoding: "utf-8", ..., or "hex"
+        """
         from binascii import hexlify
 
         htlc = Htlc(htlc_id, blockchain_instance=self)
@@ -1628,11 +1674,16 @@ def htlc_redeem(self, htlc_id, preimage, account=None, **kwargs):
             account = htlc["to"]
         account = Account(account, blockchain_instance=self)
 
+        if encoding=="hex":
+            preimage_hex = hexlify(bytes.fromhex(preimage)).decode("ascii")
+        else:
+            preimage_hex = hexlify(bytes(preimage, encoding)).decode("ascii")
+
         op = operations.Htlc_redeem(
             **{
                 "fee": {"amount": 0, "asset_id": "1.3.0"},
                 "redeemer": account["id"],
-                "preimage": hexlify(bytes(preimage, "utf-8")).decode("ascii"),
+                "preimage": preimage_hex,
                 "htlc_id": htlc["id"],
                 "extensions": [],
             }

bitsharesbase/operations.py

@@ -24,6 +24,7 @@
     Ripemd160,
     Sha1,
     Sha256,
+    Hash160,
 )
 
 from .account import PublicKey
@@ -938,7 +939,7 @@ def detail(self, *args, **kwargs):
 
 
 class HtlcHash(Static_variant):
-    elements = [Ripemd160, Sha1, Sha256]
+    elements = [Ripemd160, Sha1, Sha256, Hash160]
 
     def __init__(self, o):
         id = o[0]