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 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 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 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