def signTx(self, priv_key_hex, receiver_addr, msg, value, fee, pub_addr,
pub_key_compressed):
timestamp = getTime()
transaction = {
"from": pub_addr,
"to": receiver_addr,
"value": value,
"fee": fee,
"dateCreated": timestamp,
"data": msg,
"senderPubKey": pub_key_compressed
}
# Hash and sign
tran_hash = helper_sha256(
putDataInOrder(m_transaction_order, transaction))
tran_signature = sign(generator_secp256k1,
private_key_hex_to_int(priv_key_hex), tran_hash)
sig1 = str(hex(tran_signature[0]))[2:]
sig2 = str(hex(tran_signature[1]))[2:]
# ensure standard length
while len(sig1) < len(defSig):
sig1 = "0" + sig1
while len(sig2) < len(defSig):
sig2 = "0" + sig2
# Signed txn has appended signature; hash is not appended, but may be verified when receiving reply
transaction["senderSignature"] = [sig1, sig2]
return transaction, hex(tran_hash)[2:]
def sign_and_verify_transaction(recipient_address: str, value: int,
dateCreated: str, sender_priv_key_hex: str):
print("Generate and sign a transaction")
print("-------------------------------")
sender_priv_key = int(sender_priv_key_hex, 16)
print("sender private key:", sender_priv_key_hex)
sender_pub_key = (generator_secp256k1 * sender_priv_key).pair()
pub_key_compressed = hex(sender_pub_key[0])[2:] + str(
sender_pub_key[1] % 2)
print("sender public key:", pub_key_compressed)
sender_address = ripemd160(pub_key_compressed)
print("sender address:", sender_address)
tran = {
'from': sender_address,
'to': recipient_address,
'value': value,
'dateCreated': dateCreated,
'senderPubKey': pub_key_compressed
}
json_encoder = json.JSONEncoder(separators=(',', ':'))
tran_json = json_encoder.encode(tran)
print("transaction (json):", tran_json)
tran_hash = sha256(tran_json)
print("transaction hash (sha256):", hex(tran_hash)[2:])
tran_signature = sign(generator_secp256k1, sender_priv_key, tran_hash)
print("transaction signature:", tran_signature)
tran['senderSignature'] = [
hex(tran_signature[0])[2:],
hex(tran_signature[1])[2:]
]
print("signed transaction:")
print(json.JSONEncoder(indent=2).encode(tran))
valid = verify(generator_secp256k1, sender_pub_key, tran_hash,
tran_signature)
print("Signature valid? " + str(valid))
def do_signing(wallet, req_keys, inputs):
# Do the actual signing. We are trusting the sighash values.
# Make a right subkey for each inputs
wallets = {}
for sp, (addr_check, ppair) in req_keys.items():
w = wallet.subkey_for_path(sp)
assert w.bitcoin_address() == addr_check
assert w.public_pair() == tuple(ppair)
wallets[sp] = w
# Generate a signature for each input required
sigs = []
SIGHASH_ALL = 1
order = ecdsa.generator_secp256k1.order()
for sp, sighash in inputs:
sighash_int = int(sighash, 16)
r, s = ecdsa.sign(ecdsa.generator_secp256k1,
wallets[sp].secret_exponent(), sighash_int)
if s + s > order:
s = order - s
sig = der.sigencode_der(r, s) + chr(SIGHASH_ALL)
sigs.append((sig.encode('hex'), sighash, sp))
return sigs
def _create_script_signature(
self, secret_exponent, signature_for_hash_type_f, signature_type, script):
sign_value = signature_for_hash_type_f(signature_type, script)
order = ecdsa.generator_secp256k1.order()
r, s = ecdsa.sign(ecdsa.generator_secp256k1, secret_exponent, sign_value)
if s + s > order:
s = order - s
return der.sigencode_der(r, s) + bytes_from_int(signature_type)
def _create_script_signature(
self, secret_exponent, signature_for_hash_type_f, signature_type, script):
sign_value = signature_for_hash_type_f(signature_type, script)
order = ecdsa.generator_secp256k1.order()
r, s = ecdsa.sign(ecdsa.generator_secp256k1, secret_exponent, sign_value)
if s + s > order:
s = order - s
return der.sigencode_der(r, s) + bytes_from_int(signature_type)
def sign_transaction(private_key, data):
"""
Generates a transaction signature using private key and transaction data
:param private_key: <str> Private Key to sign with
:param data: object/str/hash that represent the data in the transaction
:return: <tuple<int,int>>
"""
signature = sign(generator_secp256k1, int(private_key, 16), data)
return signature
def cosign_spend_request(xprvkey_or_wallet, req_keys, inputs, xpub_check):
'''
Sign the inputs of a transaction, given the sighashs and subkey paths for each input
Args:
xprvkey_or_wallet = 111-char base58 encoded serialization of BIP32 wallet
or pycoin.key.BIP32Node object (w/ private key)
req_keys = dictionary: key is subpath ('a/b/c', but only 'a' for now as a string)
value is tuple: (address, public pair) ... optional checking data
inputs = list of by transaction input: (subpath, sighash_all value)
Returns:
list of 3-tuples: (der-encoded signature, sighash, subpath)
'''
# We need just these features from pycoin <https://github.com/richardkiss/pycoin>
from pycoin import ecdsa
from pycoin.key.BIP32Node import BIP32Node
from pycoin.tx.script import der
# We need a BIP32 "wallet" for the root of all keys.
if isinstance(xprvkey_or_wallet, basestring):
wallet = BIP32Node.from_wallet_key(xprvkey_or_wallet.strip())
else:
wallet = xprvkey_or_wallet
# Verify we are looking at the right extended private key
check = wallet.hwif(as_private=False)[-len(xpub_check):]
if check != xpub_check:
raise ValueError("This private key isn't the right one for xpub...%s" %
xpub_check)
# Make the right subkey for each inputs
wallets = {}
for sp, (addr_check, ppair) in req_keys.items():
w = wallet.subkey_for_path(sp)
assert w.bitcoin_address() == addr_check
assert w.public_pair() == tuple(ppair)
wallets[sp] = w
# Generate a signature for each input required
sigs = []
SIGHASH_ALL = 1
order = ecdsa.generator_secp256k1.order()
for sp, sighash in inputs:
sighash_int = int(sighash, 16)
r, s = ecdsa.sign(ecdsa.generator_secp256k1,
wallets[sp].secret_exponent(), sighash_int)
if s + s > order:
s = order - s
sig = der.sigencode_der(r, s) + chr(SIGHASH_ALL)
sigs.append((sig.encode('hex'), sighash, sp))
return sigs
def do_test(secret_exponent, val_list):
public_point = public_pair_for_secret_exponent(generator_secp256k1, secret_exponent)
for v in val_list:
signature = sign(generator_secp256k1, secret_exponent, v)
r = verify(generator_secp256k1, public_point, v, signature)
assert r == True
signature = signature[0],signature[1]+1
r = verify(generator_secp256k1, public_point, v, signature)
assert r == False
def do_test(secret_exponent, val_list):
public_point = public_pair_for_secret_exponent(generator_secp256k1, secret_exponent)
for v in val_list:
signature = sign(generator_secp256k1, secret_exponent, v)
r = verify(generator_secp256k1, public_point, v, signature)
assert r == True
signature = signature[0],signature[1]+1
r = verify(generator_secp256k1, public_point, v, signature)
assert r == False
def sign_data(self, data, privKey):
with self.lock:
symbols_set = string.ascii_letters + string.digits
salt = ''.join([random.choice(symbols_set) for _ in xrange(20)])
data = int((hash160(str(data) + salt)).encode('hex'), 16)
return {
'salt': salt,
'sign': ecdsa.sign(ecdsa.generator_secp256k1, privKey, data),
}
def sign_data(self, data, privKey):
with self.lock:
symbols_set = string.ascii_letters + string.digits
salt = ''.join([random.choice(symbols_set) for _ in xrange(20)])
data = int((hash160(str(data) + salt)).encode('hex'), 16)
return {
'salt': salt,
'sign': ecdsa.sign(ecdsa.generator_secp256k1, privKey, data),
}
def cosign_spend_request(xprvkey_or_wallet, req_keys, inputs, xpub_check):
"""
Sign the inputs of a transaction, given the sighashs and subkey paths for each input
Args:
xprvkey_or_wallet = 111-char base58 encoded serialization of BIP32 wallet
or pycoin.key.BIP32Node object (w/ private key)
req_keys = dictionary: key is subpath ('a/b/c', but only 'a' for now as a string)
value is tuple: (address, public pair) ... optional checking data
inputs = list of by transaction input: (subpath, sighash_all value)
Returns:
list of 3-tuples: (der-encoded signature, sighash, subpath)
"""
# We need just these features from pycoin <https://github.com/richardkiss/pycoin>
from pycoin import ecdsa
from pycoin.key.BIP32Node import BIP32Node
from pycoin.tx.script import der
# We need a BIP32 "wallet" for the root of all keys.
if isinstance(xprvkey_or_wallet, basestring):
wallet = BIP32Node.from_wallet_key(xprvkey_or_wallet.strip())
else:
wallet = xprvkey_or_wallet
# Verify we are looking at the right extended private key
check = wallet.hwif(as_private=False)[-len(xpub_check) :]
if check != xpub_check:
raise ValueError("This private key isn't the right one for xpub...%s" % xpub_check)
# Make the right subkey for each inputs
wallets = {}
for sp, (addr_check, ppair) in req_keys.items():
w = wallet.subkey_for_path(sp)
assert w.bitcoin_address() == addr_check
assert w.public_pair() == tuple(ppair)
wallets[sp] = w
# Generate a signature for each input required
sigs = []
SIGHASH_ALL = 1
order = ecdsa.generator_secp256k1.order()
for sp, sighash in inputs:
sighash_int = int(sighash, 16)
r, s = ecdsa.sign(ecdsa.generator_secp256k1, wallets[sp].secret_exponent(), sighash_int)
if s + s > order:
s = order - s
sig = der.sigencode_der(r, s) + chr(SIGHASH_ALL)
sigs.append((sig.encode("hex"), sighash, sp))
return sigs
def sign(self, h):
"""
Return a der-encoded signature for a hash h.
Will throw a RuntimeError if this key is not a private key
"""
if not self.is_private():
raise RuntimeError("Key must be private to be able to sign")
val = intbytes.from_bytes(h)
r, s = ecdsa.sign(ecdsa.generator_secp256k1, self.secret_exponent(),
val)
return sigencode_der(r, s)
def sign(self, h):
"""
Return a der-encoded signature for a hash h.
Will throw a RuntimeError if this key is not a private key
"""
if not self.is_private():
raise RuntimeError("Key must be private to be able to sign")
val = from_bytes_32(h)
r, s = ecdsa.sign(ecdsa.generator_secp256k1, self.secret_exponent(),
val)
return sigencode_der(r, s)
def do_test(secret_exponent, val_list):
public_point = public_pair_for_secret_exponent(generator_secp256k1, secret_exponent)
for v in val_list:
signature = sign(generator_secp256k1, secret_exponent, v)
r = verify(generator_secp256k1, public_point, v, signature)
# Check that the 's' value is 'low', to prevent possible transaction malleability as per
# https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#low-s-values-in-signatures
assert signature[1] <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
assert r == True
signature = signature[0],signature[1]+1
r = verify(generator_secp256k1, public_point, v, signature)
assert r == False
def test_sign(self):
for se in ["47f7616ea6f9b923076625b4488115de1ef1187f760e65f89eb6f4f7ff04b012"] + [x * 64 for x in "123456789abcde"]:
secret_exponent = int(se, 16)
val = 28832970699858290 #int.from_bytes(b"foo bar", byteorder="big")
sig = sign(generator_secp256k1, secret_exponent, val)
public_pair = public_pair_for_secret_exponent(generator_secp256k1, secret_exponent)
v = verify(generator_secp256k1, public_pair, val, sig)
self.assertTrue(v)
sig1 = (sig[0] + 1, sig[1])
v = verify(generator_secp256k1, public_pair, val, sig1)
self.assertFalse(v)
public_pairs = possible_public_pairs_for_signature(generator_secp256k1, val, sig)
self.assertIn(public_pair, public_pairs)
print(se)
def test_sign(self):
for se in ["47f7616ea6f9b923076625b4488115de1ef1187f760e65f89eb6f4f7ff04b012"] + [x * 64 for x in "123456789abcde"]:
secret_exponent = int(se, 16)
val = int.from_bytes(b"foo bar", byteorder="big")
sig = sign(generator_secp256k1, secret_exponent, val)
public_pair = public_pair_for_secret_exponent(generator_secp256k1, secret_exponent)
v = verify(generator_secp256k1, public_pair, val, sig)
self.assertTrue(v)
sig1 = (sig[0] + 1, sig[1])
v = verify(generator_secp256k1, public_pair, val, sig1)
self.assertFalse(v)
public_pairs = possible_public_pairs_for_signature(generator_secp256k1, val, sig)
self.assertIn(public_pair, public_pairs)
print(se)
def __call__(self, tx_out_script, signature_hash, signature_type):
"""Figure out how to create a signature for the incoming transaction, and sign it.
tx_out_script: the tx_out script that needs to be "solved"
signature_hash: the bignum hash value of the new transaction reassigning the coins
signature_type: always SIGHASH_ALL (1)
"""
if signature_hash == 0:
raise SolvingError("signature_hash can't be 0")
tx_script = TxScript(tx_out_script)
opcode_value_list = tx_script.match_script_to_templates()
ba = bytearray()
compressed = True
for opcode, v in opcode_value_list:
if opcode == opcodes.OP_PUBKEY:
public_pair = sec_to_public_pair(v)
bitcoin_address = public_pair_to_bitcoin_address(
public_pair, compressed=compressed)
elif opcode == opcodes.OP_PUBKEYHASH:
bitcoin_address = hash160_sec_to_bitcoin_address(v)
else:
raise SolvingError("can't determine how to sign this script")
secret_exponent = self.wallet.getsecretexponent(bitcoin_address)
r, s = ecdsa.sign(ecdsa.generator_secp256k1, secret_exponent,
signature_hash)
sig = der.sigencode_der(r, s) + bytes_from_int(signature_type)
ba += tools.compile(binascii.hexlify(sig).decode("utf8"))
if opcode == opcodes.OP_PUBKEYHASH:
public_pair = ecdsa.public_pair_for_secret_exponent(
ecdsa.generator_secp256k1, secret_exponent)
ba += tools.compile(
binascii.hexlify(
public_pair_to_sec(
public_pair,
compressed=compressed)).decode("utf8"))
return bytes(ba)
def send_transaction(url, wallet_addr_info, recipient_addr, amount):
if not is_valid_addr(recipient_addr):
raise ValueError("Invalid recipient address provided")
date = str(datetime.utcnow().isoformat())
msg_hash = hashlib.sha256()
msg_hash.update(
f'{wallet_addr_info.addr}{recipient_addr}{amount}{date}'.encode())
signature = sign(generator_secp256k1, int(wallet_addr_info.skey, 16),
int(msg_hash.hexdigest(), 16))
headers = {'content-type': 'application/json'}
data = {
'fromAddress': wallet_addr_info.addr,
'toAddress': recipient_addr,
'amount': amount,
'date': date,
'pkey': wallet_addr_info.pkey,
'signature': [hex(signature[0])[2:],
hex(signature[1])[2:]]
}
print("Transaction data:", data)
try:
response = requests.post(url=f"{url}/transactions/new",
data=json.dumps(data),
headers=headers)
except Exception as e:
print(e)
return
if response.status_code == 200:
print("Transaction submitted successully")
else:
print(
f"Failed to transmit transaction. Server status code {response.status_code}"
)
def sign_transaction(recipient_address: str, value: int, fee: int,
private_key: str, data: str) -> object:
if defined(recipient_address) == False: return False
if isinstance(recipient_address, str) == False: return False
if defined(value) == False: return False
if isinstance(value, int) == False: return False
if defined(fee) == False: return False
if isinstance(fee, int) == False: return False
if defined(private_key) == False: return False
if isinstance(private_key, str) == False: return False
# data can be empty, it is optional
# if defined(data) == False: return False
if isinstance(data, str) == False: return False
private_key_int = convert_string_to_int(private_key, 16)
compressed_public_key = get_compressed_public_key_from_private_key(
private_key)
address = get_address_from_compressed_public_key(compressed_public_key)
transaction = {
"from": address,
"to": recipient_address,
"value": value,
"fee": fee,
"dateCreated": datetime.datetime.now().isoformat(),
"data": data,
"senderPubKey": compressed_public_key
}
json_encoder = json.JSONEncoder(separators=(",", ":"))
transaction_json = json_encoder.encode(transaction)
transaction_json = transaction_json.encode(enc)
hashed_transaction_json = hashlib.sha256(transaction_json).digest()
hashed_transaction_int = int.from_bytes(hashed_transaction_json,
byteorder="big")
#print(hex(hashed_transaction_int)[2:])
transaction_signature = sign(generator_secp256k1, private_key_int,
hashed_transaction_int)
#print(transaction_signature)
transaction["senderSignature"] = ((hex(transaction_signature[0]))[2:],
(hex(transaction_signature[1]))[2:])
return json.dumps(transaction, sort_keys=True).encode(enc)
def __call__(self, tx_out_script, signature_hash, signature_type):
"""Figure out how to create a signature for the incoming transaction, and sign it.
tx_out_script: the tx_out script that needs to be "solved"
signature_hash: the bignum hash value of the new transaction reassigning the coins
signature_type: always SIGHASH_ALL (1)
"""
if signature_hash == 0:
raise SolvingError("signature_hash can't be 0")
tx_script = TxScript(tx_out_script)
opcode_value_list = tx_script.match_script_to_templates()
ba = bytearray()
compressed = True
for opcode, v in opcode_value_list:
if opcode == opcodes.OP_PUBKEY:
public_pair = sec_to_public_pair(v)
bitcoin_address = public_pair_to_bitcoin_address(public_pair, compressed=compressed)
elif opcode == opcodes.OP_PUBKEYHASH:
bitcoin_address = hash160_sec_to_bitcoin_address(v)
else:
raise SolvingError("can't determine how to sign this script")
secret_exponent = self.wallet.getsecretexponent(bitcoin_address)
r, s = ecdsa.sign(ecdsa.generator_secp256k1, secret_exponent, signature_hash)
sig = der.sigencode_der(r, s) + bytes_from_int(signature_type)
ba += tools.compile(binascii.hexlify(sig).decode("utf8"))
if opcode == opcodes.OP_PUBKEYHASH:
public_pair = ecdsa.public_pair_for_secret_exponent(ecdsa.generator_secp256k1, secret_exponent)
ba += tools.compile(
binascii.hexlify(public_pair_to_sec(public_pair, compressed=compressed)).decode("utf8")
)
return bytes(ba)
def sign_and_verify_transactions(recipient_address: str, value: int, fee: int,
date_created: str, sender_priv_key_hex: str):
print("sender private key hex: ", sender_priv_key_hex)
sender_priv_key = private_key_hex_to_int(sender_priv_key_hex)
print("sender private key: ", sender_priv_key)
pub_key_compressed, sender_address = extract_public_key_and_address(
sender_priv_key)
transaction = {
'from': sender_address,
'to': recipient_address,
'senderPubKey': pub_key_compressed,
'value': value,
'fee': fee,
'dataCreated': date_created,
}
json_encoder = json.JSONEncoder(separators=(',', ':'))
tran_json = json_encoder.encode(transaction)
print("transaction(json):", tran_json)
tran_hash = sha256(tran_json)
print("transaction hash (sha256): ", hex(tran_hash)[2:])
tran_signature = sign(generator_secp256k1, sender_priv_key, tran_hash)
print("transaction signature: ", tran_signature)
transaction['senderSignature'] = [
hex(tran_signature[0])[2:],
hex(tran_signature[1])[2:]
]
print("signed transaction: ")
print(json.JSONEncoder(indent=2).encode(transaction))
pub_key = private_key_to_public_key(sender_priv_key)
valid = verify(generator_secp256k1, pub_key, tran_hash, tran_signature)
print("Is signature valid? " + str(valid))
return valid
def get_signed_txn(sender_private_key, recipient_address, value, msg, fee):
priv_key_hex = sender_private_key
priv_key_int = private_key_hex_to_int(priv_key_hex)
pub_key = private_key_to_public_key(priv_key_int)
pub_key_compressed = get_pub_key_compressed(pub_key)
pub_addr = public_key_compressed_to_address(pub_key_compressed)
timestamp = datetime.datetime.now().isoformat()
timestamp = timestamp + "Z"
transaction = {
"from": pub_addr,
"to": recipient_address,
"value": int(value),
"fee": int(fee),
"dateCreated": timestamp,
"data": msg,
"senderPubKey": pub_key_compressed
}
json_encoder = json.JSONEncoder(separators=(',', ':'))
tran_json = json_encoder.encode(transaction)
tran_hash = sha256(tran_json)
tran_hash_hex = hex(tran_hash)[2:]
tran_signature = sign(generator_secp256k1, priv_key_int, tran_hash)
element1 = str(hex(tran_signature[0]))[2:]
element2 = str(hex(tran_signature[1]))[2:]
tran_signature_str = (element1, element2)
# Signed txn (appended hash and signature)
signed_txn = {
"from": pub_addr,
"to": recipient_address,
"value": value,
"fee": fee,
"dateCreated": timestamp,
"data": msg,
"senderPubKey": pub_key_compressed,
"transactionDataHash": tran_hash_hex,
"senderSignature": tran_signature_str
}
return signed_txn
def do_signing(wallet, req_keys, inputs):
# Do the actual signing. We are trusting the sighash values.
# Make a right subkey for each inputs
wallets = {}
for sp, (addr_check, ppair) in req_keys.items():
w = wallet.subkey_for_path(sp)
assert w.bitcoin_address() == addr_check
assert w.public_pair() == tuple(ppair)
wallets[sp] = w
# Generate a signature for each input required
sigs = []
SIGHASH_ALL = 1
order = ecdsa.generator_secp256k1.order()
for sp, sighash in inputs:
sighash_int = int(sighash, 16)
r,s = ecdsa.sign(ecdsa.generator_secp256k1, wallets[sp].secret_exponent(), sighash_int)
if s + s > order:
s = order - s
sig = der.sigencode_der(r, s) + chr(SIGHASH_ALL)
sigs.append((sig.encode('hex'), sighash, sp))
return sigs
def sign_transaction(self, **data):
to_address = data.pop("recipient_address")
value = data.pop("value")
fee = data.pop("fee")
transaction = {
"from": self.address,
"to": to_address,
"senderPubKey": self.pubkey,
"value": value,
"fee": fee,
"dateCreated": int(datetime.datetime.now().timestamp())
}
json_trans = json.JSONEncoder(separators=(',', ':')).encode(transaction)
hash_trans = ETH_misc.sha256(json_trans)
sig_trans = ecd.sign(ecd.generator_secp256k1, self.int, int(hash_trans, base=16))
transaction['senderSignature'] = [hex(sig_trans[0])[2:], hex(sig_trans[1])[2:]]
#print(f"=====Transaction JSON=====\n{json_trans}")
#print(f"=====Transaction Hash=====\n{hash_trans}")
#print(f"=====Transaction Sig=====\n{sig_trans}")
#print(f"=====Signed Transaction=====\n{json.dumps(transaction, indent=2)}")
verification = ecd.verify(
ecd.generator_secp256k1,
self.pubkey,
int(hash_trans, base=16),
sig_trans)
#print(f"VALIDATION: {verification}")
transaction['transactionDataHash'] = hash_trans
transaction['senderSignature'] = sig_trans
transaction['transferSuccessful'] = False
transaction['minedInBlockIndex'] = None
return transaction, json.dumps(transaction)
def sign_transaction(transaction, sender_priv_key: int):
#transaction.sender_signature.append(sign(generator_secp256k1, sender_priv_key, int(self.transaction_sha256hex,16)))
return sign(generator_secp256k1, sender_priv_key,
int(transaction.transaction_sha256hex, 16))
def from_secret_exponent_and_msg(cls, secret_exponent, msg):
msg_hash = global_hash(msg)
r, s = ecdsa.sign(ecdsa.generator_secp256k1, secret_exponent, msg_hash)
x, y = ecdsa.public_pair_for_secret_exponent(ecdsa.generator_secp256k1,
secret_exponent)
return Signature(pub_x=x, pub_y=y, r=r, s=s, msg_hash=msg_hash)
from pycoin.ecdsa import generator_secp256k1, sign, verify
import hashlib
def keccak_hash(msg):
hash_bytes = hashlib.sha3_256(msg.encode("utf8")).digest()
return int.from_bytes(hash_bytes, byteorder="big")
msg = "some message"
msg_hash = keccak_hash(msg)
private_key = 9999999999999999999999999999999999999999999
signature = sign(generator_secp256k1, private_key, msg_hash)
print("signature = " + str(signature))
def signECDSAsecp256k1(msg, privKey):
msgHash = sha3_256Hash(msg)
signature = sign(generator_secp256k1, privKey, msgHash)
return signature
def from_secret_exponent_and_msg(cls, secret_exponent, msg):
msg_hash = global_hash(msg)
r, s = ecdsa.sign(ecdsa.generator_secp256k1, secret_exponent, msg_hash)
x, y = ecdsa.public_pair_for_secret_exponent(ecdsa.generator_secp256k1, secret_exponent)
return Signature(pub_x=x, pub_y=y, r=r, s=s, msg_hash=msg_hash)
def onJoin(self, data):
print('Welcome to GreenAddress mnemonic login example')
print('\nThis script will login to GA in full mode')
self.mnemonic_phrase = getpass('Please write your mnemonic phrase and press enter: ')
self.mnemonic_phrase = "hotel helmet envelope amazing often proud scorpion myth shaft differ put expand equal scout piece million hair crater annual echo net eye middle replace"
#Generate GA-side wallet path and key info
GA_pubkey = binascii.unhexlify("036307e560072ed6ce0aa5465534fb5c258a2ccfbc257f369e8e7a181b16d897b3")
GA_pair = sec_to_public_pair(GA_pubkey)
GA_chaincode = binascii.unhexlify("b60befcc619bb1c212732770fe181f2f1aa824ab89f8aab49f2e13e3a56f0f04")
gawallet = BIP32Node.BIP32Node('XTN', GA_chaincode, public_pair=GA_pair)
if sys.version_info.major < 3:
m = hmac.new(bytearray(self.mnemonic_phrase), bytearray('GreenAddress!!!'), hashlib.sha512)
else:
m = hmac.new(bytearray(self.mnemonic_phrase, 'utf-8'), bytearray('GreenAddress!!!', 'utf-8'), hashlib.sha512)
gawalletpath = binascii.hexlify(m.digest())
gawalletpath_bin = binascii.unhexlify(gawalletpath)
gawalletpath_str = '/'.join(str(struct.unpack('!H', gawalletpath_bin[i*2:(i+1)*2])[0]) for i in range(32))
# 1. Master wallet
seed = mnemonic.Mnemonic.to_seed(self.mnemonic_phrase)
self.wallet = BIP32Node.BIP32Node.from_master_secret(seed, 'XTN')
# Change 'BTC' to 'XTN' for Testnet
# 2. Login wallet
path = '%X' % random.randint(0, 2**64-1)
while len(path) < 16:
path = '0' + path
path_bin = binascii.unhexlify(path)
path_str = '/'.join(str(struct.unpack('!H', path_bin[i*2:(i+1)*2])[0]) for i in range(4))
wallet_login = self.wallet.subkey_for_path(path_str)
# 3. Get challenge
print('\nLogging in with mnemonic passphrase, requesting challenge')
challenge = yield self.call(
'com.greenaddress.login.get_challenge',
self.wallet.bitcoin_address(),
# disclose_me is required for authentication
options=CallOptions(disclose_me=True)
)
# 4. Login
signature = pycoin_ecdsa.sign(pycoin_ecdsa.generator_secp256k1, wallet_login.secret_exponent(), int(challenge))
if signature[1]+signature[1] > pycoin_ecdsa.generator_secp256k1.order():
signature = (signature[0], pycoin_ecdsa.generator_secp256k1.order() - signature[1])
login_data = yield self.call(
"com.greenaddress.login.authenticate",
list(map(str, signature)),
False,
path,
options=CallOptions(disclose_me=True)
)
if data and login_data:
print(login_data)
last_login = (login_data['last_login']['at'], login_data['last_login']['country'], login_data['last_login']['ip'])
print('\nLogin successful! Last login on %s, from country %s, ip address: %s' % last_login)
else: print('\nLogin failed')
p2sh_addr = yield self.call(
"com.greenaddress.vault.fund",
return_pointer=True,
options=CallOptions(disclose_me=True))
print(p2sh_addr)
validateGAAddr(p2sh_addr, self.wallet)
syncWallet(p2sh_addr, self.wallet, gawallet, gawalletpath_str)
'''
balance = yield self.call(
"com.greenaddress.txs.get_balance",
options=CallOptions(disclose_me=True))
print(balance)
prep_tx = yield self.call(
"com.greenaddress.vault.prepare_tx",
rcpt_ad="2MtXwJyVCWLUmNeeNsQt958sV9658ZEpAdn",
value="10000",
add_fee='sender',
priv_data={},
options=CallOptions(disclose_me=True))
print(prep_tx)
'''
reactor.stop()
def sendTransaction():
# try
data = request.data
parsed = json.loads(data.decode())
parsedBody = parsed['body']
parsedAddress = parsedBody['senderWalletAddress']
parsedSigningKey = parsedBody['senderPrivateKey']
parsedPublicKey = parsedBody['senderPublicKey']
parsedAmount = parsedBody['amount']
parsedData = parsedBody['data']
parsedRecipientAddress = parsedBody['recipientWalletAddress']
parsedBalance = parsedBody['balance']
# parsedBalance = 200
# parsedTotal = 120
# parsedAmount = 50
transactionFee = 0.3125
parsedTotal = float(transactionFee) + float(parsedAmount)
sender_private_key = private_key_hex_to_int(parsedPublicKey)
public_key_compressed, sender_address = extract_public_key_and_address(
sender_private_key)
transaction = {
'sender': parsedSigningKey,
'senderAddress': parsedAddress,
'to': parsedRecipientAddress,
'trueAmount': parsedAmount,
'amount': parsedTotal,
'dateCreated': getDateStamp(),
'hourCreated': getTimeStamp(),
'transactionFee': transactionFee,
'data': parsedData,
'balance': parsedBalance
}
validTransaction = Transaction()
json_encoder = json.JSONEncoder(separators=(',', ':'))
trans_json = json_encoder.encode(transaction)
print("transaction (json):", trans_json)
trans_hash = sha256(trans_json)
print("transaction hash (sha256):", hex(trans_hash)[2:])
trans_signature = sign(generator_secp256k1, sender_private_key, trans_hash)
print("transaction signature:", trans_signature)
transaction['senderSignature'] = [
hex(trans_signature[0])[2:],
hex(trans_signature[1])
]
print("sign transaction: ")
print(json.JSONEncoder(indent=2).encode(transaction))
pub_key = private_key_to_public_key(sender_private_key)
valid = verify(generator_secp256k1, pub_key, trans_hash, trans_signature)
print("is signature valid? " + str(valid))
if valid == True:
return validTransaction.addValidatedTransaction(
trans_hash, parsedAddress, parsedRecipientAddress, parsedBalance,
parsedTotal, parsedAmount)
else:
return jsonify({'status': False})
def signECDSAsecp256k1(msg, decoded_private_key):
msgHash = sha3_256Hash(msg)
signature = sign(generator_secp256k1, decoded_private_key, msgHash)
return signature
