def check_contract(prev_tx, prev_vout, contract_hash, asset): a = wally.hex_from_bytes(wally.hex_to_bytes(prev_tx)[::-1])+wally.hex_from_bytes(struct.pack('<L', int(prev_vout))) a = wally.hex_from_bytes(wally.sha256d(wally.hex_to_bytes(a))) b = a + contract_hash merkle = wally.hex_from_bytes(wally.sha256_midstate(wally.hex_to_bytes(b))) c = merkle + '0000000000000000000000000000000000000000000000000000000000000000' asset_id = wally.hex_from_bytes(wally.sha256_midstate(wally.hex_to_bytes(c))[::-1]) return(asset_id == asset)
def get_ga_root_key(testnet): """Return the GreenAddress root public key for the given network, or as set by options""" key_data = gaconstants.GA_KEY_DATA_TESTNET if testnet else gaconstants.GA_KEY_DATA_MAINNET return get_bip32_pubkey( wally.hex_to_bytes(key_data['chaincode']), wally.hex_to_bytes(key_data['pubkey']), testnet )
def sign(txdata, signatories): tx = txutil.from_hex(txdata['tx']) for i in range(wally.tx_get_num_inputs(tx)): script = wally.hex_to_bytes(txdata['prevout_scripts'][i]) script_type = txdata['prevout_script_types'][i] flags, value, sighash = 0, 0, wally.WALLY_SIGHASH_ALL if script_type == gaconstants.P2SH_P2WSH_FORTIFIED_OUT: flags = wally.WALLY_TX_FLAG_USE_WITNESS value = int(txdata['prevout_values'][i]) preimage_hash = wally.tx_get_btc_signature_hash( tx, i, script, value, sighash, flags) sigs = [s.get_signature(preimage_hash) for s in signatories] if script_type == gaconstants.P2SH_P2WSH_FORTIFIED_OUT: txutil.set_witness( tx, i, [None, _to_der(sigs[0]), _to_der(sigs[1]), script]) flags = wally.WALLY_SCRIPT_SHA256 | wally.WALLY_SCRIPT_AS_PUSH script = wally.witness_program_from_bytes(script, flags) else: sigs = sigs[0] + sigs[1] script = wally.scriptsig_multisig_from_bytes( script, sigs, [sighash, sighash], 0) wally.tx_set_input_script(tx, i, script) return tx
def sign_tx(self, details): txdetails = details['transaction'] utxos = txdetails['used_utxos'] or txdetails['old_used_utxos'] signatures = [] for index, utxo in enumerate(utxos): wally_tx = wally.tx_from_hex(txdetails['transaction'], wally.WALLY_TX_FLAG_USE_WITNESS) is_segwit = utxo['script_type'] in [14, 15, 159, 162] # FIXME!! if not is_segwit: # FIXME raise NotImplementedError("Non-segwit input") flags = wally.WALLY_TX_FLAG_USE_WITNESS if is_segwit else 0 prevout_script = wally.hex_to_bytes(utxo['prevout_script']) txhash = wally.tx_get_btc_signature_hash(wally_tx, index, prevout_script, utxo['satoshi'], wally.WALLY_SIGHASH_ALL, flags) path = utxo['user_path'] privkey = self.get_privkey(path) signature = wally.ec_sig_from_bytes( privkey, txhash, wally.EC_FLAG_ECDSA | wally.EC_FLAG_GRIND_R) signature = wally.ec_sig_to_der(signature) signature.append(wally.WALLY_SIGHASH_ALL) signatures.append(wally.hex_from_bytes(signature)) logging.debug('Signature (der) input %s path %s: %s', index, path, signature) return json.dumps({'signatures': signatures})
def _get_sighash(self, wally_tx, index, utxo): flags = wally.WALLY_TX_FLAG_USE_WITNESS prevout_script = wally.hex_to_bytes(utxo['prevout_script']) if utxo['confidential']: value = bytes.fromhex(utxo['commitment']) else: value = wally.tx_confidential_value_from_satoshi(utxo['satoshi']) return wally.tx_get_elements_signature_hash( wally_tx, index, prevout_script, value, wally.WALLY_SIGHASH_ALL, flags)
def check_tx(issuance_txid, issuance_vin, asset, explorer): if (explorer): resp = requests.get(url=explorerURL+issuance_txid, verify=True) issuance = resp.json() c = issuance['vin'][issuance_vin]['issuance']['asset_entropy'] + '0000000000000000000000000000000000000000000000000000000000000000' asset_id = wally.hex_from_bytes(wally.sha256_midstate(wally.hex_to_bytes(c))[::-1]) else: issuance = host.call('getrawtransaction', issuance_txid, 1) asset_id = issuance['vin'][issuance_vin]['issuance']['asset'] return(asset_id == asset)
def seed_from_mnemonic(mnemonic_or_hex_seed): """Return seed, mnemonic given an input string mnemonic_or_hex_seed can either be: - A mnemonic - A hex seed, with an 'X' at the end, which needs to be stripped seed will always be returned, mnemonic may be None if a seed was passed """ if mnemonic_or_hex_seed.endswith('X'): mnemonic = None seed = wally.hex_to_bytes(mnemonic_or_hex_seed[:-1]) else: mnemonic = mnemonic_or_hex_seed written, seed = wally.bip39_mnemonic_to_seed512(mnemonic_or_hex_seed, None) assert written == wally.BIP39_SEED_LEN_512 assert len(seed) == wally.BIP39_SEED_LEN_512 return seed, mnemonic
def countersign(txdata, private_key): GreenAddress = PassiveSignatory( wally.hex_to_bytes(txdata['prevout_signatures'][0])) user = ActiveSignatory(wally.bip32_key_get_priv_key(private_key)) return sign(txdata, [GreenAddress, user])
def _get_sighash(self, wally_tx, index, utxo): flags = wally.WALLY_TX_FLAG_USE_WITNESS prevout_script = wally.hex_to_bytes(utxo['prevout_script']) return wally.tx_get_btc_signature_hash( wally_tx, index, prevout_script, utxo['satoshi'], wally.WALLY_SIGHASH_ALL, flags)
contract = json.dumps( { 'name': name, 'ticker': ticker, 'precision': precision, 'entity': { 'domain': domain }, 'issuer_pubkey': issuer_pubkey, 'version': version }, separators=(',', ':'), sort_keys=True) contract_hash = wally.hex_from_bytes(wally.sha256(contract.encode('ascii'))) a = wally.hex_from_bytes( wally.hex_to_bytes(prev_tx)[::-1]) + wally.hex_from_bytes( struct.pack('<L', int(prev_vout))) a = wally.hex_from_bytes(wally.sha256d(wally.hex_to_bytes(a))) b = a + contract_hash merkle = wally.hex_from_bytes(wally.sha256_midstate(wally.hex_to_bytes(b))) c = merkle + '0000000000000000000000000000000000000000000000000000000000000000' merkle = wally.hex_from_bytes( wally.sha256_midstate(wally.hex_to_bytes(c))[::-1]) res['asset_id'] = merkle res['contract'] = contract res['contract_hash'] = contract_hash # Create the rawissuance transaction contract_hash_rev = wally.hex_from_bytes( wally.hex_to_bytes(contract_hash)[::-1]) rawissue = host_1.call('rawissueasset', funded['hex'],
import wallycore as wally h2b = wally.hex_to_bytes b2h = wally.hex_from_bytes h2b_rev = lambda h: wally.hex_to_bytes(h)[::-1] b2h_rev = lambda b: wally.hex_from_bytes(b[::-1])
0, # exponent 36 # bits ) surjectionproof = wally.asset_surjectionproof(asset_id, abf, generator, os.urandom(32), asset_ids_in, abfs_in, asset_generators_in) wally.tx_add_elements_raw_output(output_tx, script_pubkey, generator, value_commitment, ephemeral_pubkey, surjectionproof, rangeproof, 0) # end-create_outputs # start-add_fee BITCOIN = "5ac9f65c0efcc4775e0baec4ec03abdde22473cd3cf33c0419ca290e0751b225" BITCOIN = wally.hex_to_bytes(BITCOIN)[::-1] wally.tx_add_elements_raw_output( output_tx, None, bytearray([0x01]) + BITCOIN, wally.tx_confidential_value_from_satoshi(fee), None, # nonce None, # surjection proof None, # range proof 0) # end-add_fee # start-sign vout = 0 prev_txid = wally.tx_get_txid(tx)
def get_ga_root_key(network): """Return the GreenAddress root public key for the given network, or as set by options""" key_data = gaconstants.get_ga_key_data(network) return get_bip32_pubkey(wally.hex_to_bytes(key_data['chaincode']), wally.hex_to_bytes(key_data['pubkey']), network)
def issuer(asset_amount, asset_address, token_amount, token_address, issuer_pubkey, name, ticker, precision, domain): data = {} version = 0 # don't change blind = False feerate = 0.00003000 asset_amount = int(asset_amount) / 10**(8 - int(precision)) token_amount = int(token_amount) / 10**(8 - int(precision)) # Create funded base tx base = host.call('createrawtransaction', [], [{'data': '00'}]) funded = host.call('fundrawtransaction', base, {'feeRate': feerate}) # Create the contact and calculate the asset id (Needed for asset registry!) contract = json.dumps( { 'name': name, 'ticker': ticker, 'precision': int(precision), 'entity': { 'domain': domain }, 'issuer_pubkey': issuer_pubkey, 'version': version }, separators=(',', ':'), sort_keys=True) contract_hash = wally.hex_from_bytes(wally.sha256( contract.encode('ascii'))) data['contract'] = contract # Create the rawissuance transaction contract_hash_rev = wally.hex_from_bytes( wally.hex_to_bytes(contract_hash)[::-1]) rawissue = host.call('rawissueasset', funded['hex'], [{ 'asset_amount': asset_amount, 'asset_address': asset_address, 'token_amount': token_amount, 'token_address': token_address, 'blind': blind, 'contract_hash': contract_hash_rev }]) # Blind the transaction blind = host.call('blindrawtransaction', rawissue[0]['hex'], True, [], False) # Sign transaction signed = host.call('signrawtransactionwithwallet', blind) decoded = host.call('decoderawtransaction', signed['hex']) data['asset_id'] = decoded['vin'][0]['issuance']['asset'] # Test transaction test = host.call('testmempoolaccept', [signed['hex']]) if test[0]['allowed'] is True: txid = host.call('sendrawtransaction', signed['hex']) data['txid'] = txid data['registry'] = json.dumps({ 'asset_id': data['asset_id'], 'contract': json.loads(data['contract']) }) return data
import argparse import json import logging import sys import wallycore as wally b2h = lambda b: wally.hex_from_bytes(b) h2b = lambda h: wally.hex_to_bytes(h) b2h_rev = lambda b: b2h(b[::-1]) h2b_rev = lambda h: h2b(h)[::-1] def err(s): logging.error(s) sys.exit(1) def parse_tx_file(file): with file as f: try: return wally.tx_from_hex( f.read().strip(), wally.WALLY_TX_FLAG_USE_WITNESS | wally.WALLY_TX_FLAG_USE_ELEMENTS) except ValueError: err("Invalid transaction") def parse_uint256_hex(h): try: b = h2b_rev(h)
def h2b_rev(h): return wally.hex_to_bytes(h)[::-1]
def get_redeem_script(keys): """Return a 2of3 multisig redeem script as a hex string""" keys = [wally.hex_from_bytes(key) for key in keys] logging.debug("get_redeem_script public keys = {}".format(keys)) return wally.hex_to_bytes("5221{}21{}21{}53ae".format(*keys))
def _b(h): return hex_to_bytes(h)