def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
prefix = kwargs.pop("prefix", default_prefix)
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
# Sort keys (FIXME: ideally, the sorting is part of Public
# Key and not located here)
kwargs["key_auths"] = sorted(
kwargs["key_auths"],
key=lambda x: repr(PublicKey(x[0], prefix=prefix)),
reverse=False,
)
kwargs["account_auths"] = sorted(
kwargs["account_auths"],
key=lambda x: x[0],
reverse=False,
)
accountAuths = Map([
[String(e[0]), Uint16(e[1])]
for e in kwargs["account_auths"]
])
keyAuths = Map([
[PublicKey(e[0], prefix=prefix), Uint16(e[1])]
for e in kwargs["key_auths"]
])
super().__init__(OrderedDict([
('weight_threshold', Uint32(int(kwargs["weight_threshold"]))),
('account_auths', accountAuths),
('key_auths', keyAuths),
]))
def test_PubKey(self):
self.assertEqual([
format(
PublicKey(
"BTS6UtYWWs3rkZGV8JA86qrgkG6tyFksgECefKE1MiH4HkLD8PFGL",
prefix="BTS").address, "BTS"),
format(
PublicKey(
"BTS8YAMLtNcnqGNd3fx28NP3WoyuqNtzxXpwXTkZjbfe9scBmSyGT",
prefix="BTS").address, "BTS"),
format(
PublicKey(
"BTS7HUo6bm7Gfoi3RqAtzwZ83BFCwiCZ4tp37oZjtWxGEBJVzVVGw",
prefix="BTS").address, "BTS"),
format(
PublicKey(
"BTS6676cZ9qmqPnWMrm4McjCuHcnt6QW5d8oRJ4t8EDH8DdCjvh4V",
prefix="BTS").address, "BTS"),
format(
PublicKey(
"BTS7u8m6zUNuzPNK1tPPLtnipxgqV9mVmTzrFNJ9GvovvSTCkVUra",
prefix="BTS").address, "BTS")
], [
"BTS66FCjYKzMwLbE3a59YpmFqA9bwporT4L3",
"BTSKNpRuPX8KhTBsJoFp1JXd7eQEsnCpRw3k",
"BTS838ENJargbUrxXWuE2xD9HKjQaS17GdCd",
"BTSNsrLFWTziSZASnNJjWafFtGBfSu8VG8KU",
"BTSDjAGuXzk3WXabBEgKKc8NsuQM412boBdR"
])
def test_PublicKey(self):
self.assertEqual([
str(
PublicKey(
"BTS6UtYWWs3rkZGV8JA86qrgkG6tyFksgECefKE1MiH4HkLD8PFGL",
prefix="BTS")),
str(
PublicKey(
"BTS8YAMLtNcnqGNd3fx28NP3WoyuqNtzxXpwXTkZjbfe9scBmSyGT",
prefix="BTS")),
str(
PublicKey(
"BTS7HUo6bm7Gfoi3RqAtzwZ83BFCwiCZ4tp37oZjtWxGEBJVzVVGw",
prefix="BTS")),
str(
PublicKey(
"BTS6676cZ9qmqPnWMrm4McjCuHcnt6QW5d8oRJ4t8EDH8DdCjvh4V",
prefix="BTS")),
str(
PublicKey(
"BTS7u8m6zUNuzPNK1tPPLtnipxgqV9mVmTzrFNJ9GvovvSTCkVUra",
prefix="BTS"))
], [
"BTS6UtYWWs3rkZGV8JA86qrgkG6tyFksgECefKE1MiH4HkLD8PFGL",
"BTS8YAMLtNcnqGNd3fx28NP3WoyuqNtzxXpwXTkZjbfe9scBmSyGT",
"BTS7HUo6bm7Gfoi3RqAtzwZ83BFCwiCZ4tp37oZjtWxGEBJVzVVGw",
"BTS6676cZ9qmqPnWMrm4McjCuHcnt6QW5d8oRJ4t8EDH8DdCjvh4V",
"BTS7u8m6zUNuzPNK1tPPLtnipxgqV9mVmTzrFNJ9GvovvSTCkVUra"
])
def involved_keys(message):
" decode structure "
raw = base58decode(message[1:])
from_key = PublicKey(raw[:66])
raw = raw[66:]
to_key = PublicKey(raw[:66])
return [from_key, to_key]
def verify(self, pubkeys=[], chain=None):
if not chain:
raise ValueError("Chain needs to be provided!")
chain_params = self.getChainParams(chain)
self.deriveDigest(chain)
signatures = self.data["signatures"].data
pubKeysFound = []
for signature in signatures:
sig = bytes(signature)[1:]
recoverParameter = (
bytes(signature)[0]) - 4 - 27 # recover parameter only
if USE_SECP256K1:
ALL_FLAGS = secp256k1.lib.SECP256K1_CONTEXT_VERIFY | \
secp256k1.lib.SECP256K1_CONTEXT_SIGN
# Placeholder
pub = secp256k1.PublicKey(flags=ALL_FLAGS)
# Recover raw signature
sig = pub.ecdsa_recoverable_deserialize(sig, recoverParameter)
# Recover PublicKey
verifyPub = secp256k1.PublicKey(
pub.ecdsa_recover(bytes(self.message), sig))
# Convert recoverable sig to normal sig
normalSig = verifyPub.ecdsa_recoverable_convert(sig)
# Verify
verifyPub.ecdsa_verify(bytes(self.message), normalSig)
phex = hexlify(
verifyPub.serialize(compressed=True)).decode('ascii')
pubKeysFound.append(phex)
else:
p = self.recover_public_key(self.digest, sig, recoverParameter)
# Will throw an exception of not valid
p.verify_digest(sig,
self.digest,
sigdecode=ecdsa.util.sigdecode_string)
phex = hexlify(self.compressedPubkey(p)).decode('ascii')
pubKeysFound.append(phex)
for pubkey in pubkeys:
if not isinstance(pubkey, PublicKey):
raise Exception("Pubkeys must be array of 'PublicKey'")
k = pubkey.unCompressed()[2:]
if k not in pubKeysFound and repr(pubkey) not in pubKeysFound:
k = PublicKey(PublicKey(k).compressed())
f = format(k, chain_params["prefix"])
raise Exception("Signature for %s missing!" % f)
return pubKeysFound
def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
prefix = kwargs.pop("prefix", default_prefix)
meta = ""
if "json_metadata" in kwargs and kwargs["json_metadata"]:
if isinstance(kwargs["json_metadata"], dict):
meta = json.dumps(kwargs["json_metadata"])
else:
meta = kwargs["json_metadata"]
owner = Permission(kwargs["owner"], prefix=prefix) if "owner" in kwargs else None
active = Permission(kwargs["active"], prefix=prefix) if "active" in kwargs else None
posting = Permission(kwargs["posting"], prefix=prefix) if "posting" in kwargs else None
super().__init__(OrderedDict([
('account', String(kwargs["account"])),
('owner', Optional(owner)),
('active', Optional(active)),
('posting', Optional(posting)),
('memo_key', PublicKey(kwargs["memo_key"], prefix=prefix)),
('json_metadata', String(meta)),
]))
def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
prefix = kwargs.pop("prefix", default_prefix)
assert len(kwargs["new_account_name"]) <= 16, "Account name must be at most 16 chars long"
meta = ""
if "json_metadata" in kwargs and kwargs["json_metadata"]:
if isinstance(kwargs["json_metadata"], dict):
meta = json.dumps(kwargs["json_metadata"])
else:
meta = kwargs["json_metadata"]
super().__init__(OrderedDict([
('fee', Amount(kwargs["fee"])),
('delegation', Amount(kwargs["delegation"])),
('creator', String(kwargs["creator"])),
('new_account_name', String(kwargs["new_account_name"])),
('owner', Permission(kwargs["owner"], prefix=prefix)),
('active', Permission(kwargs["active"], prefix=prefix)),
('posting', Permission(kwargs["posting"], prefix=prefix)),
('memo_key', PublicKey(kwargs["memo_key"], prefix=prefix)),
('json_metadata', String(meta)),
('extensions', Array([])),
]))
def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
prefix = kwargs.pop("prefix", default_prefix)
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
super().__init__(OrderedDict([
('from', PublicKey(kwargs["from"], prefix=prefix)),
('to', PublicKey(kwargs["to"], prefix=prefix)),
('nonce', Uint64(int(kwargs["nonce"]))),
('check', Uint32(int(kwargs["check"]))),
('encrypted', Bytes(kwargs["encrypted"])),
]))
def decode_memo(priv, message):
""" Decode a message with a shared secret between Alice and Bob
:param PrivateKey priv: Private Key (of Bob)
:param base58encoded message: Encrypted Memo message
:return: Decrypted message
:rtype: str
:raise ValueError: if message cannot be decoded as valid UTF-8
string
"""
" decode structure "
raw = base58decode(message[1:])
from_key = PublicKey(raw[:66])
raw = raw[66:]
to_key = PublicKey(raw[:66])
raw = raw[66:]
nonce = str(struct.unpack_from("<Q", unhexlify(raw[:16]))[0])
raw = raw[16:]
check = struct.unpack_from("<I", unhexlify(raw[:8]))[0]
raw = raw[8:]
cipher = raw
if repr(to_key) == repr(priv.pubkey):
shared_secret = get_shared_secret(priv, from_key)
elif repr(from_key) == repr(priv.pubkey):
shared_secret = get_shared_secret(priv, to_key)
else:
raise ValueError("Incorrect PrivateKey")
" Init encryption "
aes, checksum = init_aes(shared_secret, nonce)
" Check "
assert check == checksum, "Checksum failure"
" Encryption "
# remove the varint prefix (FIXME, long messages!)
message = cipher[2:]
message = aes.decrypt(unhexlify(bytes(message, 'ascii')))
try:
return _unpad(message.decode('utf8'), 16)
except:
raise ValueError(message)
def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
prefix = kwargs.pop("prefix", default_prefix)
if not kwargs["block_signing_key"]:
kwargs["block_signing_key"] = "STM1111111111111111111111111111111114T1Anm"
super().__init__(OrderedDict([
('owner', String(kwargs["owner"])),
('url', String(kwargs["url"])),
('block_signing_key', PublicKey(kwargs["block_signing_key"], prefix=prefix)),
('props', WitnessProps(kwargs["props"])),
('fee', Amount(kwargs["fee"])),
]))
def __init__(self, *args, **kwargs):
if isArgsThisClass(self, args):
self.data = args[0].data
else:
if len(args) == 1 and len(kwargs) == 0:
kwargs = args[0]
prefix = kwargs.pop("prefix", default_prefix)
if not kwargs["block_signing_key"]:
kwargs[
"block_signing_key"] = "GLS1111111111111111111111111111111114T1Anm"
super().__init__(
OrderedDict([
("owner", String(kwargs["owner"])),
("url", String(kwargs["url"])),
("block_signing_key",
PublicKey(kwargs["block_signing_key"], prefix=prefix)),
("props", ChainProperties(kwargs["props"])),
("fee", Amount(kwargs["fee"])),
]))