def from_str(cls, obj):
if not isinstance(obj, str):
raise TypeError(
"UnlockHash is expected to be a str, not {}".format(type(obj)))
obj = jsstr.strip(obj)
if len(obj) != UnlockHash._TOTAL_SIZE_HEX:
raise ValueError(
"UnlockHash is expexcted to be of length {} when stringified, not of length {}, invalid: {} ({})"
.format(UnlockHash._TOTAL_SIZE_HEX, len(obj), obj, type(obj)))
t = UnlockHashType(
int(jsarr.slice_array(obj, 0, UnlockHash._TYPE_SIZE_HEX)))
h = Hash(
value=obj[UnlockHash._TYPE_SIZE_HEX:UnlockHash._TYPE_SIZE_HEX +
UnlockHash._HASH_SIZE_HEX])
uh = cls(uhtype=t, uhhash=h)
if t.__eq__(UnlockHashType.NIL):
expectedNH = jshex.bytes_to_hex(
bytes(jsarr.new_array(UnlockHash._HASH_SIZE)))
nh = jshex.bytes_to_hex(h.value)
if nh != expectedNH:
raise ValueError("unexpected nil hash {}".format(nh))
else:
expected_checksum = jshex.bytes_to_hex(
jsarr.slice_array(uh._checksum(), 0,
UnlockHash._CHECKSUM_SIZE))
checksum = jsarr.slice_array(
obj,
UnlockHash._TOTAL_SIZE_HEX - UnlockHash._CHECKSUM_SIZE_HEX)
if expected_checksum != checksum:
raise ValueError("unexpected checksum {}, expected {}".format(
checksum, expected_checksum))
return uh
def to_mnemonic(self, data):
if len(data) not in [16, 20, 24, 28, 32]:
raise ValueError(
'Data length should be one of the following: [16, 20, 24, 28, 32], but it is not (%d).'
% len(data))
h = jshex.bytes_to_hex(self._sha256_func(data))
b = jsstr.zfill(jshex.hex_to_bin(jshex.bytes_to_hex(data))[2:], len(data) * 8) + \
jsstr.zfill(jshex.hex_to_bin(h)[2:], 256)[:len(data) * 8 // 32]
result = []
for i in range(len(b) // 11):
idx = jsbin.bin_str_to_int(b[i * 11:(i + 1) * 11])
result.append(self.wordlist[idx])
result_phrase = ' '.join(result)
return result_phrase
def check(self, mnemonic):
if not isinstance(mnemonic, str):
return False
mnemonic = jsstr.strip(mnemonic)
mnemonic = mnemonic.split(' ')
# list of valid mnemonic lengths
if len(mnemonic) not in [12, 15, 18, 21, 24]:
return False
try:
idx = map(
lambda x: jsstr.zfill(
jsint.to_bin_str(jsarr.index_of(self.wordlist, x))[2:], 11
), mnemonic)
b = ''.join(idx)
except ValueError:
return False
l = len(b) # noqa: E741
d = b[:l // 33 * 32]
h = b[-l // 33:]
nd = jshex.bytes_from_hex(
jsstr.zfill(
jsstr.rstrip(jshex.hex_from_bin(jsint.to_bin_str(d)[2:]), 'L'),
l // 33 * 8))
nh = jsstr.zfill(
jshex.hex_to_bin(jshex.bytes_to_hex(self._sha256_func(nd)))[2:],
256)[:l // 33]
return h == nh
def _as_primitive(obj):
if isinstance(obj, (bytes, bytearray)) or jsarr.is_uint8_array(obj):
return jshex.bytes_to_hex(obj)
if isinstance(obj, tfjson.BaseJSONObject):
return _as_primitive(obj.json())
if jsobj.is_js_obj(obj):
return jsjson.json_dumps(obj)
return obj
def sha256(data):
data = jshex.bytes_to_hex(data)
digest = ''
__pragma__(
"js", "{}", """
const input = sjcl.codec.hex.toBits(data);
const words = sjcl.hash.sha256.hash(input)
digest = sjcl.codec.hex.fromBits(words);
""")
return jshex.bytes_from_hex(digest)
def __init__(self, value=None, fixed_size=None, strencoding=None):
# define string encoding
if strencoding != None and not isinstance(strencoding, str):
raise TypeError(
"strencoding should be None or a str, not be of type {}".format(strencoding))
if strencoding == None or jsstr.String(strencoding).lower().strip().__eq__('hex'):
self._from_str = lambda s: jshex.bytes_from_hex(s)
self._to_str = lambda value: jshex.bytes_to_hex(value)
elif jsstr.String(strencoding).lower().strip().__eq__('base64'):
self._from_str = lambda s: jsbase64.bytes_from_b64(s)
self._to_str = lambda value: jsbase64.bytes_to_b64(value)
elif jsstr.String(strencoding).lower().strip().__eq__('hexprefix'):
self._from_str = lambda s: jshex.bytes_from_hex(
s[2:] if (s.startswith("0x") or s.startswith("0X")) else s)
self._to_str = lambda value: '0x' + jshex.bytes_to_hex(value)
else:
raise TypeError(
"{} is not a valid string encoding".format(strencoding))
self._strencoding = strencoding
# define fixed size
if fixed_size != None:
if not isinstance(fixed_size, int):
raise TypeError(
"fixed size should be None or int, not be of type {}".format(type(fixed_size)))
if fixed_size < 0:
raise TypeError(
"fixed size should be at least 0, {} is not allowed".format(fixed_size))
if fixed_size != 0:
self._fixed_size = fixed_size
else:
self._fixed_size = None # for now use no fixed size
# define the value (finally)
self._value = None
self.value = value
if fixed_size == 0:
# define the fixed size now, if the fixed_size was 0
# based on the binary length of the value
self._fixed_size = len(self.value)
def __str__(self):
checksum = jshex.bytes_to_hex(
jsarr.slice_array(self._checksum(), 0, UnlockHash._CHECKSUM_SIZE))
return "{}{}{}".format(
jshex.bytes_to_hex(bytes([self._type.__int__()])),
self._hash.__str__(), checksum)
def from_recipient(recipient, lock=None):
"""
Create automatically a recipient condition based on any accepted pythonic value (combo).
"""
# define base condition
if isinstance(recipient, ConditionBaseClass):
condition = recipient
else:
condition = None
if recipient == None:
# free-for-all wallet
condition = nil_new()
elif isinstance(recipient, str):
if recipient == jsstr.repeat('0', 78): # nil wallet
condition = nil_new()
else: # single sig wallet
condition = unlockhash_new(unlockhash=recipient)
elif isinstance(recipient, UnlockHash):
# single sig wallet
condition = unlockhash_new(unlockhash=recipient)
elif isinstance(recipient,
(bytes, bytearray)) or jsarr.is_uint8_array(recipient):
# single sig wallet
condition = unlockhash_new(
unlockhash=jshex.bytes_to_hex(recipient))
elif isinstance(recipient, list) or jsobj.is_js_arr(recipient):
if len(recipient) == 2:
sig_count, owners = None, None
if isinstance(recipient[0], (int, float)):
sig_count, owners = int(recipient[0]), recipient[1]
if isinstance(recipient[1], (int, float)):
if sig_count != None:
raise TypeError(
"invalid recipient {}".format(recipient))
sig_count, owners = int(recipient[1]), recipient[0]
if sig_count != None:
condition = multi_signature_new(min_nr_sig=sig_count,
unlockhashes=owners)
if condition == None:
# multisig to an all-for-all wallet
condition = multi_signature_new(min_nr_sig=len(recipient),
unlockhashes=recipient)
elif isinstance(recipient, tuple):
# multisig wallet with custom x-of-n definition
if len(recipient) != 2:
raise ValueError(
"recipient is expected to be a tupple of 2 values in the form (sigcount,hashes) or (hashes,sigcount), cannot be of length {}"
.format(len(recipient)))
# allow (sigs,hashes) as well as (hashes,sigs)
if isinstance(recipient[0], int):
condition = multi_signature_new(min_nr_sig=recipient[0],
unlockhashes=recipient[1])
else:
condition = multi_signature_new(min_nr_sig=recipient[1],
unlockhashes=recipient[0])
else:
raise TypeError("invalid type for recipient parameter: {}: {}",
type(recipient), recipient)
# if lock is defined, define it as a locktime value
if lock != None:
condition = locktime_new(lock=lock, condition=condition)
# return condition
return condition