def withdrawfromvault(self, fromvaultaddress, toaddress, amount):
vault = self.getvault(fromvaultaddress)
received = self.chaindb.listreceivedbyvault(fromvaultaddress)
received = received.values()[0]
if received['value'] < amount + 2 * utils.calculate_fees(None):
self.logger.warning("Insufficient funds in vault, exiting, return")
return
# create transaction
tx = CTransaction()
# to the receiver
txout = CTxOut()
txout.nValue = amount
txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(toaddress)
tx.vout.append(txout)
# from the sender
nValueIn = 0
nValueOut = amount
txin = CTxIn()
txin.prevout = COutPoint()
txin.prevout.hash = received['txhash']
txin.prevout.n = received['n']
txin.scriptSig = received['scriptPubKey']
tx.vin.append(txin)
# calculate nValueIn
nValueIn = received['value']
# calculate the total excess amount
excessAmount = nValueIn - nValueOut
# calculate the fees
fees = 2 * utils.calculate_fees(tx)
# create change transaction, if there is any change left
if excessAmount > fees:
change_txout = CTxOut()
change_txout.nValue = excessAmount - fees
account = self.getaccount()
changeaddress = fromvaultaddress
self.logger.debug("Change address: %s" % changeaddress)
change_txout.scriptPubKey = \
utils.vault_address_to_pay_to_vault_script(changeaddress)
tx.vout.append(change_txout)
# calculate txhash
tx.calc_sha256()
txhash = str(tx.sha256)
key = CKey()
key.set_pubkey(vault['public_key'])
key.set_privkey(vault['private_key'])
signature = key.sign(txhash)
vaultscript = utils.create_vault_script(vault['address'], \
vault['master_address'], vault['timeout'], vault['maxfees'])
scriptSig = chr(OP_VAULT_WITHDRAW) + chr(len(signature)) + signature + \
chr(len(vaultscript)) + vaultscript
self.logger.debug("Adding signature: %s" % binascii.hexlify(scriptSig))
txin.scriptSig = scriptSig
return tx
def withdrawfromvault(self, fromvaultaddress, toaddress, amount):
vault = self.getvault(fromvaultaddress)
received = self.chaindb.listreceivedbyvault(fromvaultaddress)
received = received.values()[0]
if received['value'] < amount + 2 * utils.calculate_fees(None):
self.logger.warning("Insufficient funds in vault, exiting, return")
return
# create transaction
tx = CTransaction()
# to the receiver
txout = CTxOut()
txout.nValue = amount
txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(toaddress)
tx.vout.append(txout)
# from the sender
nValueIn = 0
nValueOut = amount
txin = CTxIn()
txin.prevout = COutPoint()
txin.prevout.hash = received['txhash']
txin.prevout.n = received['n']
txin.scriptSig = received['scriptPubKey']
tx.vin.append(txin)
# calculate nValueIn
nValueIn = received['value']
# calculate the total excess amount
excessAmount = nValueIn - nValueOut
# calculate the fees
fees = 2 * utils.calculate_fees(tx)
# create change transaction, if there is any change left
if excessAmount > fees:
change_txout = CTxOut()
change_txout.nValue = excessAmount - fees
account = self.getaccount()
changeaddress = fromvaultaddress
self.logger.debug("Change address: %s" % changeaddress)
change_txout.scriptPubKey = \
utils.vault_address_to_pay_to_vault_script(changeaddress)
tx.vout.append(change_txout)
# calculate txhash
tx.calc_sha256()
txhash = str(tx.sha256)
key = CKey()
key.set_pubkey(vault['public_key'])
key.set_privkey(vault['private_key'])
signature = key.sign(txhash)
vaultscript = utils.create_vault_script(vault['address'], \
vault['master_address'], vault['timeout'], vault['maxfees'])
scriptSig = chr(OP_VAULT_WITHDRAW) + chr(len(signature)) + signature + \
chr(len(vaultscript)) + vaultscript
self.logger.debug("Adding signature: %s" % binascii.hexlify(scriptSig))
txin.scriptSig = scriptSig
return tx
def overridevaulttx(self, fromvaultaddress, toaddress):
vault = self.getvault(fromvaultaddress)
# select the input addresses
received = self.chaindb.listallreceivedbyvault(fromvaultaddress)
if not received:
self.logger.warning("Empty vault, exiting, return")
return None, None
received = received.values()[0]
if received['value'] < 2 * utils.calculate_fees(None):
self.logger.warning("Insufficient funds in vault, exiting, return")
return None, None
# calculate remaining amount
amount = received['value'] - 2 * utils.calculate_fees(None)
# create transaction
tx = CTransaction()
# to the receiver
txout = CTxOut()
txout.nValue = amount
txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(toaddress)
tx.vout.append(txout)
# from the sender
nValueIn = 0
nValueOut = amount
txin = CTxIn()
txin.prevout = COutPoint()
txin.prevout.hash = received['txhash']
txin.prevout.n = received['n']
txin.scriptSig = received['scriptPubKey']
tx.vin.append(txin)
# calculate nValueIn
nValueIn = received['value']
# calculate the total excess amount
excessAmount = nValueIn - nValueOut
# calculate the fees
fees = utils.calculate_fees(tx)
# calculate txhash
tx.calc_sha256()
txhash = str(tx.sha256)
key = CKey()
key.set_pubkey(vault['public_key'])
key.set_privkey(vault['private_key'])
signature = key.sign(txhash)
# get the script
vaultscript = utils.create_vault_script(vault['address'], \
vault['master_address'], vault['timeout'], vault['maxfees'])
scriptSig = chr(OP_VAULT_OVERRIDE) + chr(len(vault['master_public_key'])) + \
vault['master_public_key'] + chr(len(signature)) + signature + \
chr(len(vaultscript)) + vaultscript
self.logger.debug("Adding signature: %s" % binascii.hexlify(scriptSig))
txin.scriptSig = scriptSig
return amount, tx
def overridevaulttx(self, fromvaultaddress, toaddress):
vault = self.getvault(fromvaultaddress)
# select the input addresses
received = self.chaindb.listallreceivedbyvault(fromvaultaddress)
if not received:
self.logger.warning("Empty vault, exiting, return")
return None, None
received = received.values()[0]
if received['value'] < 2 * utils.calculate_fees(None):
self.logger.warning("Insufficient funds in vault, exiting, return")
return None, None
# calculate remaining amount
amount = received['value'] - 2 * utils.calculate_fees(None)
# create transaction
tx = CTransaction()
# to the receiver
txout = CTxOut()
txout.nValue = amount
txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(toaddress)
tx.vout.append(txout)
# from the sender
nValueIn = 0
nValueOut = amount
txin = CTxIn()
txin.prevout = COutPoint()
txin.prevout.hash = received['txhash']
txin.prevout.n = received['n']
txin.scriptSig = received['scriptPubKey']
tx.vin.append(txin)
# calculate nValueIn
nValueIn = received['value']
# calculate the total excess amount
excessAmount = nValueIn - nValueOut
# calculate the fees
fees = utils.calculate_fees(tx)
# calculate txhash
tx.calc_sha256()
txhash = str(tx.sha256)
key = CKey()
key.set_pubkey(vault['public_key'])
key.set_privkey(vault['private_key'])
signature = key.sign(txhash)
# get the script
vaultscript = utils.create_vault_script(vault['address'], \
vault['master_address'], vault['timeout'], vault['maxfees'])
scriptSig = chr(OP_VAULT_OVERRIDE) + chr(len(vault['master_public_key'])) + \
vault['master_public_key'] + chr(len(signature)) + signature + \
chr(len(vaultscript)) + vaultscript
self.logger.debug("Adding signature: %s" % binascii.hexlify(scriptSig))
txin.scriptSig = scriptSig
return amount, tx
def sendtovault(self, vault_address, amount):
# select the input addresses
funds = 0
subaccounts = []
accounts = self.getaccounts()
for account in accounts:
for address, subaccount in account.iteritems():
if subaccount['balance'] == 0:
continue
else:
subaccounts.append(subaccount)
funds = funds + subaccount['balance']
if funds >= amount + utils.calculate_fees(None):
break
# incase of insufficient funds, return
if funds < amount + utils.calculate_fees(None):
self.logger.warning("Insufficient funds, exiting, return")
raise exceptions.InsufficientBalanceException
# create transaction
tx = CTransaction()
# to the receiver
txout = CTxOut()
txout.nValue = amount
txout.scriptPubKey = utils.vault_address_to_pay_to_vault_script(vault_address)
tx.vout.append(txout)
# from the sender
nValueIn = 0
nValueOut = amount
public_keys = []
private_keys = []
for subaccount in subaccounts:
# get received by from address
previous_txouts = subaccount['received']
for received in previous_txouts:
txin = CTxIn()
txin.prevout = COutPoint()
txin.prevout.hash = received['txhash']
txin.prevout.n = received['n']
txin.scriptSig = received['scriptPubKey']
tx.vin.append(txin)
nValueIn = nValueIn + received['value']
public_keys.append(subaccount['public_key'])
private_keys.append(subaccount['private_key'])
if nValueIn >= amount + utils.calculate_fees(tx):
break
if nValueIn >= amount + utils.calculate_fees(tx):
break
# calculate the total excess amount
excessAmount = nValueIn - nValueOut
# calculate the fees
fees = utils.calculate_fees(tx)
# create change transaction, if there is any change left
if excessAmount > fees:
change_txout = CTxOut()
change_txout.nValue = excessAmount - fees
changeaddress = self.getnewaddress()[1]
change_txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(changeaddress)
tx.vout.append(change_txout)
# calculate txhash
tx.calc_sha256()
txhash = str(tx.sha256)
self.logger.debug("Sending to vault %064x" % tx.sha256)
# sign the transaction
for public_key, private_key, txin in zip(public_keys, private_keys, tx.vin):
key = CKey()
key.set_pubkey(public_key)
key.set_privkey(private_key)
signature = key.sign(txhash)
# scriptSig = chr(len(signature)) + hash_type + signature + chr(len(public_key)) + public_key
scriptSig = chr(len(signature)) + signature + chr(len(public_key)) + public_key
self.logger.debug("Adding signature: %s" % binascii.hexlify(scriptSig))
txin.scriptSig = scriptSig
self.logger.debug("Tx Validity: %064x" % tx.is_valid())
# push data to vault
tx.calc_sha256()
self.set(str("vault:" + vault_address), {'txhash': tx.sha256})
return (vault_address, tx)
def build_claim_tx(self, txid_hex):
if self.secret_info["plaintext"] == None:
raise Exception("We don't know the secret yet.")
#Create redeem script.
redeem_script = self.fund_redeem_script(self.their)
#Convert to p2sh address.
their_fund_address = self.script_to_address(redeem_script, self.their)
#Check there is enough in the p2sh address.
their_fund_tx = self.jsonrpc[self.their].gettransaction(
txid_hex)["details"]
found = 0
for tx_input in their_fund_tx:
#Check it's the right input.
if tx_input["address"] == their_fund_address:
found = 1
if tx_input["amount"] + self.recv_amount > decimal.Decimal(
coinbend.config["mining_fee"]["standard"]):
raise Exception(
"Their contract has not been sufficently funded.")
break
else:
continue
#Their side of the contract hasn't been funded.
if not found:
raise Exception("Their contract fund output was not detected.")
#Generate address to receive redeemed output.
if "receive" not in self.key_pairs:
self.key_pairs["receive"] = self.key_pair_from_address(
self.jsonrpc[self.their].getnewaddress(), self.their)
#Load private key for signing.
seckey = CBitcoinSecret(self.key_pairs[self.my]["priv"]["wif"])
#Generate p2sh script pub key.
redeem_script_hash160 = self.hash160_script(redeem_script)
txin_script_pub_key = CScript(
[OP_HASH160, redeem_script_hash160["bin"], OP_EQUAL])
#Setup tx inputs and outputs.
txid = lx(txid_hex)
vout = 0
txin = CTxIn(COutPoint(txid, vout))
txout = CTxOut(
(self.recv_amount -
decimal.Decimal(coinbend.config["mining_fee"]["standard"])) *
COIN,
CBitcoinAddress(
self.key_pairs["receive"]["addr"]["base58"]).to_scriptPubKey())
#Create unsigned transaction.
tx = CTransaction([txin], [txout])
#Sign transactions.
sighash = SignatureHash(redeem_script["bin"], tx, 0, SIGHASH_ALL)
sig = seckey.sign(sighash) + bytes([SIGHASH_ALL])
txin.scriptSig = CScript([
bytes(self.secret_info["plaintext"].encode("ascii")), sig, OP_3,
redeem_script["bin"]
])
#Return signed transaction hex.
return b2x(tx.serialize())
# address.
txout = CTxOut(0.0005*COIN, CBitcoinAddress('323uf9MgLaSn9T7vDaK1cGAZ2qpvYUuqSp').to_scriptPubKey())
# Create the unsigned transaction.
tx = CTransaction([txin],[txout])
# Calculate the signature hash for that transaction. Note how the script we use
# is the redeemScript, not the scriptPubKey. That's because when the CHECKSIG
# operation happens EvalScript() will be evaluating the redeemScript, so the
# corresponding SignatureHash() function will use that same script when it
# replaces the scriptSig in the transaction being hashed with the script being
# executed.
sighash = SignatureHash(txin_redeemScript, tx, 0, SIGHASH_ALL)
# Now sign it. We have to append the type of signature we want to the end, in
# this case the usual SIGHASH_ALL.
sig = seckey.sign(sighash) + bytes([SIGHASH_ALL])
# Set the scriptSig of our transaction input appropriately.
txin.scriptSig = CScript([sig, txin_redeemScript])
# Verify the signature worked. This calls EvalScript() and actually executes
# the opcodes in the scripts to see if everything worked out. If it doesn't an
# exception will be raised.
print(b2x(txin_scriptPubKey))
VerifyScript(txin.scriptSig, txin_scriptPubKey, tx, 0, (SCRIPT_VERIFY_P2SH,))
# Done! Print the transaction to standard output with the bytes-to-hex
# function.
print(b2x(tx.serialize()))
from bitcoin.core import COutPoint, CTxIn, CTxOut, CTransaction, CBlock coinbase = "04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73" scriptPubKeyHex = "4104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac" # construct previous out point previousOut = COutPoint() previousOut.hash = 0 previousOut.n = 4294967295 # construct txin txin = CTxIn() txin.coinbase = binascii.unhexlify(coinbase) txin.scriptSig = binascii.unhexlify(coinbase) txin.prevout = previousOut # construct txout txout = CTxOut() txout.nValue = 5000000000 txout.scriptPubKey = binascii.unhexlify(scriptPubKeyHex) # create transaction tx = CTransaction() tx.vin.append(txin) tx.vout.append(txout) tx.calc_sha256() print tx print "Transaction: ", tx.is_valid() print "hash: ", hex(tx.sha256)
# from utils
def myhash(s):
return hashlib.sha256(hashlib.sha256(s).digest()).digest()
previous = COutPoint()
txin = CTxIn()
txout = CTxOut()
tx = CTransaction()
# get the outpoint from which we want to spend
previous.hash = 0xeccf7e3034189b851985d871f91384b8ee357cd47c3024736e5676eb2debb3f2
previous.n = 0x01000000
txin.prevout = previous
txin.scriptSig = binascii.unhexlify(
"76a914010966776006953d5567439e5e39f86a0d273bee88ac")
# create output transaction
txout.nValue = 0x605af40500000000
txout.scriptPubKey = binascii.unhexlify(
"76a914097072524438d003d23a2f23edb65aae1bb3e46988ac")
# set inputs and outputs
tx.vin.append(txin)
tx.vout.append(txout)
sertx = tx.serialize() + binascii.unhexlify("01000000")
"""
print sertx[:76]
print sertx[76:152]
print sertx[152:]
"""
def sendtoaddress(self, toaddress, amount):
# select the input addresses
funds = 0
subaccounts = []
accounts = self.getaccounts()
for account in accounts:
for address, subaccount in account.iteritems():
if subaccount['balance'] == 0:
continue
else:
subaccounts.append(subaccount)
funds = funds + subaccount['balance']
if funds >= amount + utils.calculate_fees(None):
break
# incase of insufficient funds, return
if funds < amount + utils.calculate_fees(None):
self.logger.warning("Insufficient funds, exiting, return")
return None, None
# create transaction
tx = CTransaction()
# to the receiver
txout = CTxOut()
txout.nValue = amount
txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(toaddress)
tx.vout.append(txout)
# from the sender
nValueIn = 0
nValueOut = amount
public_keys = []
private_keys = []
# secrets = []
for subaccount in subaccounts:
# get received by from address
previous_txouts = subaccount['received']
for received in previous_txouts:
txin = CTxIn()
txin.prevout = COutPoint()
txin.prevout.hash = received['txhash']
txin.prevout.n = received['n']
txin.scriptSig = received['scriptPubKey']
tx.vin.append(txin)
nValueIn = nValueIn + received['value']
public_keys.append(subaccount['public_key'])
private_keys.append(subaccount['private_key'])
# secrets.append(subaccount['secret'])
if nValueIn >= amount + utils.calculate_fees(tx):
break
if nValueIn >= amount + utils.calculate_fees(tx):
break
# calculate the total excess amount
excessAmount = nValueIn - nValueOut
# calculate the fees
fees = utils.calculate_fees(tx)
# create change transaction, if there is any change left
if excessAmount > fees:
change_txout = CTxOut()
change_txout.nValue = excessAmount - fees
changeaddress = subaccounts[0]['address']
change_txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(
changeaddress)
tx.vout.append(change_txout)
# calculate txhash
tx.calc_sha256()
txhash = str(tx.sha256)
# sign the transaction
for public_key, private_key, txin in zip(public_keys, private_keys,
tx.vin):
key = CKey()
key.set_pubkey(public_key)
key.set_privkey(private_key)
signature = key.sign(txhash)
# scriptSig = chr(len(signature)) + hash_type + signature + chr(len(public_key)) + public_key
scriptSig = chr(len(signature)) + signature + chr(
len(public_key)) + public_key
txin.scriptSig = scriptSig
return amount, tx
txout = CTxOut(
0.0005 * COIN,
CBitcoinAddress('323uf9MgLaSn9T7vDaK1cGAZ2qpvYUuqSp').to_scriptPubKey())
# Create the unsigned transaction.
tx = CTransaction([txin], [txout])
# Calculate the signature hash for that transaction. Note how the script we use
# is the redeemScript, not the scriptPubKey. That's because when the CHECKSIG
# operation happens EvalScript() will be evaluating the redeemScript, so the
# corresponding SignatureHash() function will use that same script when it
# replaces the scriptSig in the transaction being hashed with the script being
# executed.
sighash = SignatureHash(txin_redeemScript, tx, 0, SIGHASH_ALL)
# Now sign it. We have to append the type of signature we want to the end, in
# this case the usual SIGHASH_ALL.
sig = seckey.sign(sighash) + bytes([SIGHASH_ALL])
# Set the scriptSig of our transaction input appropriately.
txin.scriptSig = CScript([sig, txin_redeemScript])
# Verify the signature worked. This calls EvalScript() and actually executes
# the opcodes in the scripts to see if everything worked out. If it doesn't an
# exception will be raised.
VerifyScript(txin.scriptSig, txin_scriptPubKey, tx, 0, (SCRIPT_VERIFY_P2SH, ))
# Done! Print the transaction to standard output with the bytes-to-hex
# function.
print(b2x(tx.serialize()))
#!/usr/bin/env python from bitcoin.core import CBlock from bitcoin.core import CTxIn, CTxOut, CTransaction txin = CTxIn() txout = CTxOut() txin.scriptSig = 0x04FFFF001D0104455468652054696D65732030332F4A616E2F32303039204368616E63656C6C6F72206F6E206272696E6B206F66207365636F6E64206261696C6F757420666F722062616E6B73 txin.prevout = 0x0000000000000000000000000000000000000000000000000000000000000000FFFFFFFF print txin, txin.is_valid() tx.vout.nValue = 5000000000 tx.vout.scriptPubKey = 0x5F1DF16B2B704C8A578D0BBAF74D385CDE12C11EE50455F3C438EF4C3FBCF649B6DE611FEAE06279A60939E028A8D65C10B73071A6F16719274855FEB0FD8A6704 tx = CTransaction() tx.vin = [txin] tx.vout = [txout] """ tx.vout.scriptPubKey = 0x5F1DF16B2B704C8A578D0BBAF74D385CDE12C11EE50455F3C438EF4C3FBCF649B6DE611FEAE06279A60939E028A8D65C10B73071A6F16719274855FEB0FD8A6704 OP_CHECKSIG """ block = CBlock() block.nVersion = 1 block.hashPrevBlock = 0 block.hashMerkleRoot = 0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b block.nTime = 1231006505 block.nBits = 0x1d00ffff block.nNonce = 2083236893 block.vtx = [tx] block.sha256 = 0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f print block.is_valid()
from bitcoin.core import COutPoint, CTxIn, CTxOut, CTransaction
# from utils
def myhash(s):
return hashlib.sha256(hashlib.sha256(s).digest()).digest()
previous = COutPoint()
txin = CTxIn()
txout = CTxOut()
tx = CTransaction()
# get the outpoint from which we want to spend
previous.hash = 0xeccf7e3034189b851985d871f91384b8ee357cd47c3024736e5676eb2debb3f2
previous.n = 0x01000000
txin.prevout = previous
txin.scriptSig = binascii.unhexlify("76a914010966776006953d5567439e5e39f86a0d273bee88ac")
# create output transaction
txout.nValue = 0x605af40500000000
txout.scriptPubKey = binascii.unhexlify("76a914097072524438d003d23a2f23edb65aae1bb3e46988ac")
# set inputs and outputs
tx.vin.append(txin)
tx.vout.append(txout)
sertx = tx.serialize() + binascii.unhexlify("01000000")
"""
print sertx[:76]
print sertx[76:152]
print sertx[152:]
"""
def attack_command(args):
#args.starting_height = 2**32-1
#scan_command(args)
fd = open('sent-txs','a')
for txhash in args.rpc.getrawmempool():
txhash = lx(txhash)
tx = args.rpc.getrawtransaction(txhash)
args.wallet.scan_tx(tx)
args.fee_per_kb = int(args.fee_per_kb * COIN)
# deque of transaction outputs, (COutPoint, CTxOut), that we have available
# to spend. We use these outputs in order, oldest first.
available_txouts = collections.deque()
# gather up existing outputs
total_funds = 0
for outpoint, txout in args.wallet.unspent_txouts.items():
total_funds += txout.nValue
available_txouts.append((outpoint, txout))
size_sent = 0
while available_txouts:
logging.info('Attacking! Sent %d bytes total, Funds left: %s in %d txouts' %
(size_sent, str_money_value(total_funds), len(available_txouts)))
tx = CTransaction()
# Gather up txouts until we have enough funds in to pay the fees on a
# target-sized tx as well as the non-dust outputs.
sum_value_in = 0
# Assuming the whole tx is CTxOut's, each one is 46 bytes (1-of-1
# CHECKMULTISIG) and the value out needs to be at least 1000 satoshis.
avg_txout_size = 46 #25+1+8
num_txouts = args.target_tx_size // avg_txout_size
min_value_out = 10000
sum_min_value_out = num_txouts * min_value_out
fees = (args.target_tx_size/1000) * args.fee_per_kb
inputs = {}
tx_size = len(tx.serialize())
dummy_scriptSig = CScript([b'\x00'*74])
while (sum_value_in < fees + sum_min_value_out
and tx_size < args.target_tx_size/2 # don't devote more than half the tx to inputs
and available_txouts):
outpoint, txout = available_txouts.popleft()
try:
args.rpc.gettxout(outpoint)
except IndexError:
continue
inputs[outpoint] = txout
sum_value_in += txout.nValue
# The CTxIn has a dummy signature so size calculations will be right
txin = CTxIn(outpoint, dummy_scriptSig)
tx.vin.append(txin)
tx_size += len(txin.serialize())
total_funds -= sum_value_in
# Recalculate number of txouts we'll have now that we've added the
# txins. Of course, this will leave the actual value per txout a bit
# high, but whatever.
num_txouts = int(min((args.target_tx_size-len(tx.serialize())) / avg_txout_size,
(sum_value_in - fees) / min_value_out))
# Split the funds out evenly among all transaction outputs.
per_txout_value = (sum_value_in - fees) // num_txouts
for i in range(num_txouts):
scriptPubKey = args.wallet.make_multisig()
txout = CTxOut(per_txout_value, scriptPubKey)
tx.vout.append(txout)
# Sign the transaction
for (i, txin) in enumerate(tx.vin):
prevout_scriptPubKey = inputs[txin.prevout].scriptPubKey
sighash = SignatureHash(prevout_scriptPubKey, tx, i, SIGHASH_ALL)
seckey = args.wallet.keypairs[prevout_scriptPubKey]
sig = seckey.sign(sighash) + bytes([SIGHASH_ALL])
if prevout_scriptPubKey[-1] == OP_CHECKMULTISIG:
txin.scriptSig = CScript([OP_0, sig])
elif prevout_scriptPubKey[-1] == OP_CHECKSIG and prevout_scriptPubKey[-2] == OP_EQUALVERIFY:
txin.scriptSig = CScript([sig, seckey.pub])
VerifyScript(txin.scriptSig, prevout_scriptPubKey, tx, i)
# Add the new txouts to the list of available txouts
tx_hash = tx.get_hash()
sum_value_out = 0
for i, txout in enumerate(tx.vout):
outpoint = COutPoint(tx_hash, i)
available_txouts.append((outpoint, txout))
sum_value_out += txout.nValue
total_funds += sum_value_out
actual_fees = sum_value_in - sum_value_out
serialized_tx = tx.serialize()
logging.debug('Sending tx %s\n'
' value in: %s, value out: %s, fees: %s, fees/KB: %s\n'
' size: %d, # of inputs: %d, # of outputs: %d, txout.nValue: %s' %
(b2lx(tx_hash), str_money_value(sum_value_in), str_money_value(sum_value_out),
str_money_value(actual_fees),
str_money_value(actual_fees/(len(serialized_tx)/1000)),
len(serialized_tx), len(tx.vin), len(tx.vout), per_txout_value))
size_sent += len(serialized_tx)
#print(b2x(serialized_tx))
#args.wallet.save()
try:
args.rpc.sendrawtransaction(tx)
fd.write(b2x(serialized_tx) + '\n')
fd.flush()
except bitcoin.rpc.JSONRPCException as exp:
print(b2x(tx.serialize()))
#import pdb; pdb.set_trace()
time.sleep(random.randrange(30,60))
def sendtovault(self, vault_address, amount):
# select the input addresses
funds = 0
subaccounts = []
accounts = self.getaccounts()
for account in accounts:
for address, subaccount in account.iteritems():
if subaccount['balance'] == 0:
continue
else:
subaccounts.append(subaccount)
funds = funds + subaccount['balance']
if funds >= amount + utils.calculate_fees(None):
break
# incase of insufficient funds, return
if funds < amount + utils.calculate_fees(None):
self.logger.warning("Insufficient funds, exiting, return")
raise exceptions.InsufficientBalanceException
# create transaction
tx = CTransaction()
# to the receiver
txout = CTxOut()
txout.nValue = amount
txout.scriptPubKey = utils.vault_address_to_pay_to_vault_script(
vault_address)
tx.vout.append(txout)
# from the sender
nValueIn = 0
nValueOut = amount
public_keys = []
private_keys = []
for subaccount in subaccounts:
# get received by from address
previous_txouts = subaccount['received']
for received in previous_txouts:
txin = CTxIn()
txin.prevout = COutPoint()
txin.prevout.hash = received['txhash']
txin.prevout.n = received['n']
txin.scriptSig = received['scriptPubKey']
tx.vin.append(txin)
nValueIn = nValueIn + received['value']
public_keys.append(subaccount['public_key'])
private_keys.append(subaccount['private_key'])
if nValueIn >= amount + utils.calculate_fees(tx):
break
if nValueIn >= amount + utils.calculate_fees(tx):
break
# calculate the total excess amount
excessAmount = nValueIn - nValueOut
# calculate the fees
fees = utils.calculate_fees(tx)
# create change transaction, if there is any change left
if excessAmount > fees:
change_txout = CTxOut()
change_txout.nValue = excessAmount - fees
changeaddress = self.getnewaddress()[1]
change_txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(
changeaddress)
tx.vout.append(change_txout)
# calculate txhash
tx.calc_sha256()
txhash = str(tx.sha256)
self.logger.debug("Sending to vault %064x" % tx.sha256)
# sign the transaction
for public_key, private_key, txin in zip(public_keys, private_keys,
tx.vin):
key = CKey()
key.set_pubkey(public_key)
key.set_privkey(private_key)
signature = key.sign(txhash)
# scriptSig = chr(len(signature)) + hash_type + signature + chr(len(public_key)) + public_key
scriptSig = chr(len(signature)) + signature + chr(
len(public_key)) + public_key
self.logger.debug("Adding signature: %s" %
binascii.hexlify(scriptSig))
txin.scriptSig = scriptSig
self.logger.debug("Tx Validity: %064x" % tx.is_valid())
# push data to vault
tx.calc_sha256()
self.set(str("vault:" + vault_address), {'txhash': tx.sha256})
return (vault_address, tx)
[OP_DUP, OP_HASH160,
Hash160(seckey.pub), OP_EQUALVERIFY, OP_CHECKSIG])
# Create the txout. This time we create the scriptPubKey from a Bitcoin
# address.
txout = CTxOut(
0.001 * COIN,
CBitcoinAddress('1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8').to_scriptPubKey())
# Create the unsigned transaction.
tx = CTransaction([txin], [txout])
# Calculate the signature hash for that transaction.
sighash = SignatureHash(txin_scriptPubKey, tx, 0, SIGHASH_ALL)
# Now sign it. We have to append the type of signature we want to the end, in
# this case the usual SIGHASH_ALL.
sig = seckey.sign(sighash) + bytes([SIGHASH_ALL])
# Set the scriptSig of our transaction input appropriately.
txin.scriptSig = CScript([sig, seckey.pub])
# Verify the signature worked. This calls EvalScript() and actually executes
# the opcodes in the scripts to see if everything worked out. If it doesn't an
# exception will be raised.
VerifyScript(txin.scriptSig, txin_scriptPubKey, tx, 0, (SCRIPT_VERIFY_P2SH, ))
# Done! Print the transaction to standard output with the bytes-to-hex
# function.
print(b2x(tx.serialize()))
nbytes = (nbytes << 8) | (int(v_hex[6:8], 16) & 0xFF)
return nbytes
coinbase = "04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73"
scriptPubKeyHex = "4104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac"
# construct previous out point
previousOut = COutPoint()
previousOut.hash = 0
previousOut.n = 4294967295
# construct txin
txin = CTxIn()
txin.coinbase = binascii.unhexlify(coinbase)
txin.scriptSig = binascii.unhexlify(coinbase)
txin.prevout = previousOut
# construct txout
txout = CTxOut()
txout.nValue = 5000000000
txout.scriptPubKey = binascii.unhexlify(scriptPubKeyHex)
# create transaction
tx = CTransaction()
tx.vin.append(txin)
tx.vout.append(txout)
tx.calc_sha256()
#print tx
#print "Transaction: ", tx.is_valid()
#print "hash: ", hex(tx.sha256)
def sendtoaddress(self, toaddress, amount):
# select the input addresses
funds = 0
subaccounts = []
accounts = self.getaccounts()
for account in accounts:
for address, subaccount in account.iteritems():
if subaccount['balance'] == 0:
continue
else:
subaccounts.append(subaccount)
# print "got one subaccount", subaccount
# print "subaccounts: ", subaccounts
funds = funds + subaccount['balance']
if funds >= amount + utils.calculate_fees(None):
break
# print "subaccounts 2: ", subaccounts
# incase of insufficient funds, return
if funds < amount + utils.calculate_fees(None):
print "In sufficient funds, exiting, return"
return
# create transaction
tx = CTransaction()
# print "subaccounts 3: ", subaccounts
# to the receiver
txout = CTxOut()
txout.nValue = amount
txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(toaddress)
tx.vout.append(txout)
# from the sender
nValueIn = 0
nValueOut = amount
public_keys = []
private_keys = []
# secrets = []
# print "subaccounts 4: ", subaccounts
for subaccount in subaccounts:
# print "subaccount: ", subaccount
# get received by from address
previous_txouts = subaccount['received']
# print "Previous txouts", previous_txouts
for received in previous_txouts:
txin = CTxIn()
txin.prevout = COutPoint()
txin.prevout.hash = received['txhash']
txin.prevout.n = received['n']
txin.scriptSig = binascii.unhexlify(received['scriptPubKey'])
tx.vin.append(txin)
nValueIn = nValueIn + received['value']
public_keys.append(subaccount['public_key'])
private_keys.append(subaccount['private_key'])
# secrets.append(subaccount['secret'])
if nValueIn >= amount + utils.calculate_fees(tx):
break
if nValueIn >= amount + utils.calculate_fees(tx):
break
# calculate the total excess amount
excessAmount = nValueIn - nValueOut
# calculate the fees
fees = utils.calculate_fees(tx)
# create change transaction, if there is any change left
if excessAmount > fees:
change_txout = CTxOut()
change_txout.nValue = excessAmount - fees
changeaddress = subaccounts[0]['address']
change_txout.scriptPubKey = utils.address_to_pay_to_pubkey_hash(changeaddress)
tx.vout.append(change_txout)
# calculate txhash
tx.calc_sha256()
txhash = str(tx.sha256)
# sign the transaction
for public_key, private_key, txin in zip(public_keys, private_keys, tx.vin):
key = CKey()
key.set_pubkey(public_key)
key.set_privkey(private_key)
signature = key.sign(txhash)
# scriptSig = chr(len(signature)) + hash_type + signature + chr(len(public_key)) + public_key
scriptSig = chr(len(signature)) + signature + chr(len(public_key)) + public_key
print "Adding signature: ", binascii.hexlify(scriptSig)
txin.scriptSig = scriptSig
print "Tx Validity: ", tx.is_valid()
return tx
#
# Here we'll create that scriptPubKey from scratch using the pubkey that
# corresponds to the secret key we generated above.
txin_scriptPubKey = CScript([OP_DUP, OP_HASH160, Hash160(seckey.pub), OP_EQUALVERIFY, OP_CHECKSIG])
# Create the txout. This time we create the scriptPubKey from a Bitcoin
# address.
txout = CTxOut(0.001*COIN, CBitcoinAddress('1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8').to_scriptPubKey())
# Create the unsigned transaction.
tx = CTransaction([txin],[txout])
# Calculate the signature hash for that transaction.
sighash = SignatureHash(txin_scriptPubKey, tx, 0, SIGHASH_ALL)
# Now sign it. We have to append the type of signature we want to the end, in
# this case the usual SIGHASH_ALL.
sig = seckey.sign(sighash) + bytes([SIGHASH_ALL])
# Set the scriptSig of our transaction input appropriately.
txin.scriptSig = CScript([sig, seckey.pub])
# Verify the signature worked. This calls EvalScript() and actually executes
# the opcodes in the scripts to see if everything worked out. If it doesn't an
# exception will be raised.
VerifyScript(txin.scriptSig, txin_scriptPubKey, tx, 0, (SCRIPT_VERIFY_P2SH,))
# Done! Print the transaction to standard output with the bytes-to-hex
# function.
print(b2x(tx.serialize()))
