def unicodify(self):
r = []
for s in self.data:
o = ord(s)
if o <= 7:
r.append("u%04x" % o)
elif o == 8:
r.append("b")
elif o == 9:
r.append("\t")
elif o == 10:
r.append("\n")
elif o == 11:
r.append("u%04x" % o)
elif o == 12:
r.append("f")
elif o == 13:
r.append("\r")
elif 13 < o < 32:
r.append("u%04x" % o)
else:
r.append(s)
return compat_bytes("".join(r), "utf-8")
def deriveDigest(self, chain):
chain_params = self.getChainParams(chain)
# Chain ID
self.chainid = chain_params["chain_id"]
# Do not serialize signatures
sigs = self.data["signatures"]
self.data["signatures"] = []
# Get message to sign
# bytes(self) will give the wire formatted data according to
# GrapheneObject and the data given in __init__()
# from beowulf.beowulfd import Beowulfd
# tx_hex = Beowulfd().get_transaction_hex(self.json())
# print("Server:", unhexlify(tx_hex[0:-2]))
# print("Client:", compat_bytes(self))
# self.message = unhexlify(self.chainid + tx_hex[0:-2])
self.message = unhexlify(self.chainid) + compat_bytes(self)
self.digest = hashlib.sha256(self.message).digest()
# restore signatures
self.data["signatures"] = sigs
def __bytes__(self):
# padding
amount = round(float(self.amount) * 10**self.precision)
asset_name = self.asset + "\x00" * (9 - len(self.asset))
return (struct.pack("<q", amount) + struct.pack("<I", self.precision) +
compat_bytes(asset_name, "ascii"))
def deriveChecksum(self, s):
""" Derive the checksum
"""
checksum = hashlib.sha256(compat_bytes(s, "ascii")).hexdigest()
return checksum[:4]
def derive_checksum(s):
checksum = hashlib.sha512(compat_bytes(s, "ascii")).hexdigest()
return checksum
def __bytes__(self):
return compat_bytes(self.instance) # only yield instance
def __bytes__(self):
""" Returns the raw public key (has length 33)"""
return compat_bytes(self._pk)
def _unpad(s, BS):
count = int(struct.unpack('B', compat_bytes(s[-1], 'ascii'))[0])
if compat_bytes(s[-count::], 'ascii') == count * struct.pack('B', count):
return s[:-count]
return s
def isempty(self):
if not self.data:
return True
return not bool(compat_bytes(self.data))
def __bytes__(self):
return compat_bytes(self.length) + b"".join(
[compat_bytes(a) for a in self.data])
def __bytes__(self):
# FIXME constraint data to self.length
d = unhexlify(compat_bytes(self.data, 'utf-8'))
return varint(len(d)) + d
def __bytes__(self):
"""Returns bytes representation."""
d = bytes(unhexlify(compat_bytes(self.data, 'ascii')))
return varint(len(d)) + d
def get_private_key_str(self):
a = compat_bytes(self.account + self.role + self.password, 'utf8')
s = hashlib.sha256(a).digest()
return hexlify(s).decode('ascii')
def __bytes__(self):
""" Returns the raw private key """
return compat_bytes(self._wif)
def __bytes__(self):
decimals = int(str(self.data['decimals']))
asset_name = str(
self.data['name']) + "\x00" * (9 - len(str(self.data['name'])))
return struct.pack("<I", decimals) + compat_bytes(asset_name, "ascii")
def __bytes__(self):
return varint(self.type_id) + compat_bytes(self.data)
def __bytes__(self):
return compat_bytes(Id(self.opId)) + compat_bytes(self.op)
def __bytes__(self):
b = b""
b += varint(len(self.data))
for e in self.data:
b += compat_bytes(e[0]) + compat_bytes(e[1])
return b
def compressedPubkey(self, pk):
order = pk.curve.generator.order()
p = pk.pubkey.point
x_str = ecdsa.util.number_to_string(p.x(), order)
return compat_bytes(compat_chr(2 + (p.y() & 1)), 'ascii') + x_str
def __bytes__(self):
return compat_bytes(self.data)
def sign(self, wifkeys, chain=None):
""" Sign the transaction with the provided private keys.
:param list wifkeys: Array of wif keys
:param str chain: identifier for the chain
:param tx_hex: identifier for the chain
"""
if not chain:
raise ValueError("Chain needs to be provided!")
self.deriveDigest(chain)
# Get Unique private keys
self.privkeys = []
[
self.privkeys.append(item) for item in wifkeys
if item not in self.privkeys
]
# Sign the message with every private key given!
sigs = []
for wif in self.privkeys:
p = compat_bytes(PrivateKey(wif))
i = 0
if USE_SECP256K1:
ndata = secp256k1.ffi.new("const int *ndata")
ndata[0] = 0
while True:
ndata[0] += 1
privkey = secp256k1.PrivateKey(p, raw=True)
sig = secp256k1.ffi.new(
'secp256k1_ecdsa_recoverable_signature *')
signed = secp256k1.lib.secp256k1_ecdsa_sign_recoverable(
privkey.ctx, sig, self.digest, privkey.private_key,
secp256k1.ffi.NULL, ndata)
assert signed == 1
signature, i = privkey.ecdsa_recoverable_serialize(sig)
if self._is_canonical(signature):
i += 4 # compressed
i += 27 # compact
break
else:
cnt = 0
sk = ecdsa.SigningKey.from_string(p, curve=ecdsa.SECP256k1)
while 1:
cnt += 1
if not cnt % 20:
log.info("Still searching for a canonical signature. "
"Tried %d times already!" % cnt)
# Deterministic k
k = ecdsa.rfc6979.generate_k(
sk.curve.generator.order(),
sk.privkey.secret_multiplier,
hashlib.sha256,
hashlib.sha256(
self.digest + struct.pack("d", time.time(
)) # use the local time to randomize the signature
).digest())
# Sign message
#
sigder = sk.sign_digest(self.digest,
sigencode=ecdsa.util.sigencode_der,
k=k)
# Reformating of signature
#
r, s = ecdsa.util.sigdecode_der(sigder,
sk.curve.generator.order())
signature = ecdsa.util.sigencode_string(
r, s, sk.curve.generator.order())
# This line allows us to convert a 2.7 byte array(which is just binary) to an array of byte values.
# We can then use the elements in sigder as integers, as in the following two lines.
sigder = array.array('B', sigder)
# Make sure signature is canonical!
#
lenR = sigder[3]
lenS = sigder[5 + lenR]
if lenR is 32 and lenS is 32:
# Derive the recovery parameter
#
i = self.recoverPubkeyParameter(
self.digest, signature, sk.get_verifying_key())
i += 4 # compressed
i += 27 # compact
break
# pack signature
#
sigstr = struct.pack("<B", i)
sigstr += signature
sigs.append(Signature(sigstr))
self.data["signatures"] = Array(sigs)
return self
def __bytes__(self):
""" Returns the raw content of the ``Base58CheckEncoded`` address """
if self._address is None:
return compat_bytes(self.derivesha512address())
else:
return compat_bytes(self._address)