def to_internal_value(self, data):
if data is None:
return data
try:
return wif_to_key(data)
except (ValueError):
self.fail('invalid', data=data)
def create_tx(coin, account, to, amount):
if coin == 'ETH':
return derive_wallets(priv_key)
elif coin == 'BTCTEST':
return wif_to_key(priv_key)
else:
print("No solution for that coin type")
return None
def priv_key_to_account(coin, priv_key):
# print(coin)
# print(priv_key)
if coin == ETH:
return Account.privateKeyToAccount(priv_key)
elif coin == BTC:
key = wif_to_key("")
return key.PrivateKeyTestnet(priv_key)
def priv_key_to_account(coin, priv_key):
if coin == 'ETH':
return derive_wallets(priv_key)
elif coin == 'BTCTEST':
return wif_to_key(priv_key)
else:
print("No solution for that coin type")
return None
def send_tx(coin, account, recipient, amount):
if coin == ETH:
tx = create_tx(coin, account, recipient, amount)
signed_tx = account.sign_transaction(tx)
result = w3.eth.sendRawTransaction(signed_tx.rawTransaction)
print(result.hex())
return result.hex()
elif coin == BTCTEST:
key = wif_to_key("")
addresses = [recipient]
outputs = []
for address in addresses:
outputs.append((address, amount, "btc"))
return print(key.send(outputs))
def transfer(self,
from_pri_key,
to_address,
human_format_amount,
params=None):
key = wif_to_key(from_pri_key)
from_address = key.address
# check from_address & from_pri_key match
if from_address != key.address:
raise Exception(f'from_address != key.address, '
f'from_address={from_address}, '
f'key.address={key.address}')
outputs = [
(to_address, human_format_amount, 'btc'),
]
tx_id = key.send(outputs)
return tx_id
from bit import wif_to_key
key = wif_to_key("")
# replace with different addresses
addresses = [
"0xc3879B456DAA348a16B6524CBC558d2CC984722c",
"0xA29f7E79ECEA4cE30DD78cfeb9605D9aFf5143a5",
]
outputs = []
for address in addresses:
outputs.append((address, 0.001, "btc"))
print(key.send(outputs))
def send_tx(coin, account, to, amount):
tx = create_tx(coin, account, to, amount)
signed_tx = account.sign_transaction(tx)
if coin == ETH:
return w3.eth.sendRawTransaction(signed_tx.rawTransaction)
elif coin == BTCTEST:
return NetworkAPI.broadcast_tx_testnet(signed_tx)
# Define accounts
account_one = priv_key_to_account(BTCTEST, coins[BTCTEST][0]['privkey'])
account_one_eth = priv_key_to_account(ETH, coins[ETH][0]['privkey'])
##print(coins[ETH][0]['privkey'])
##print(f"BTCTEST:{coins[BTCTEST][0]['address']}")
account_two = coins[BTCTEST][1]['address']
account_two_eth = coins[ETH][1]['address']
print(account_two_eth)
# Define messages
from bit import wif_to_key
key1 = wif_to_key(coins[BTCTEST][0]['privkey'])
key2 = wif_to_key(coins[BTCTEST][1]['privkey'])
##print(key1.get_balance("btc"))
send_tx(ETH, account_one_eth, account_two_eth, 0.01)
##send_tx(BTCTEST,account_one,account_two, 0.000001)
##print(key1.get_balance("btc"))
##print(key2.get_balance("btc"))
# Import dependencies
import subprocess
import json
import os
from dotenv import load_dotenv
from web3 import Web3
from bit import wif_to_key
w3 = Web3(Web3.HTTPProvider("http://127.0.0.1:8545"))
# Load and set environment variables
load_dotenv("api.env")
mnemonic=os.getenv("mnemonic")
private_key = os.getenv("PRIVATE_KEY")
private_key_BTC = os.getenv("BTC_PRIVATE")
key = wif_to_key(private_key_BTC)
#checking connection to w3
## Check balances of mining node (put mining node address)
w3.eth.getBalance(private_key)
## Convert to Ether
w3.fromWei(w3.eth.getBalance(private_key), 'ether')
#get transactions using bit
key.get_transactions()
# Import constants.py and necessary functions from bit and web3
from constants import *
# Create a dictionary object called coins to store the output from `derive_wallets`.
coins = {'BTC', 'ETH'}
from bit import wif_to_key
key = wif_to_key("PRIVATE_KEY_IN_WIF_FORMAT_HERE")
key.get_balance("btc")
key.balance_as("usd")
key.get_transactions()
key.get_unspents()
btc_test_keys_df = pd.read_csv("resources/btc_test_keys")
btc_test_priv_keys = btc_test_keys_df['privkey']
btc_test_select_priv_key = btc_test_priv_keys.iloc[0]
key = PrivateKeyTestnet(btc_test_select_priv_key)
# alternatively we can read in the key from hidden .env file
wif_key = os.getenv("WIF_KEY")
key = PrivateKeyTestnet(wif_key)
# or we could use bit 'wif_to_key' method to accomplish the same task
# from dataframe
key = wif_to_key(btc_test_select_priv_key)
# from .env
key = wif_to_key(os.getenv("WIF_KEY"))
# print sender's address
sender = (key.address)
print(sender)
# input recipients' addresses
recipient = input(f'Please enter the address where BTC will be sent to {""}')
from bit import wif_to_key
key = wif_to_key(os.getenv('btctest_key'))
addresses = ["mfm9NFhkwvUhok3K644cibc9YQazJ5hpyT"]
outputs = []
for address in addresses:
outputs.append((address, .00000000001, "btc"))
print(key.send(outputs))
import requests
import json
import os
from bit import PrivateKeyTestnet, wif_to_key
from bit.network import NetworkAPI, satoshi_to_currency
default_pkey = ""
testnet_priv_key = os.environ.get("BTC_PKEY", default_pkey)
key = wif_to_key(testnet_priv_key)
btc_address = key.address
class BtcClient:
def get_balance_satoshi(self):
self.get_balance()
return key.balance
def get_balance_block_cypher(self, address):
endpoint = "https://api.blockcypher.com/v1/btc/test3/addrs/{}/balance".format(address)
resp = requests.get(endpoint, stream=True, timeout=15)
data = json.loads(resp.content)
return float(data['balance'] / 100000000)
def get_address_balance(self, address):
val = satoshi_to_currency(NetworkAPI.get_balance_testnet(address), 'btc')
return float(val)
def get_address(self):
return btc_address
return PrivateKeyTestnet.prepare_transaction(account.address,
[(to, amount, BTC)])
def send_tx(coin, account, to, amount):
if coin == ETH:
raw_tx = create_tx(coin, account, to, amount)
signed_tx = account.sign_transaction(raw_tx)
return w3.eth.sendRawTransaction(signed_tx.rawTransaction).hex()
elif coin == BTCTEST:
raw_tx = create_tx(coin, account, to, amount)
signed_tx = account.sign_transaction(raw_tx)
return NetworkAPI.broadcast_tx_testnet(signed_tx)
# send_tx(account_one, account_two.address, 555555555555555)
btctest_send_account_priv = coins[BTCTEST][0]['privkey']
btctest_to_account_address = coins[BTCTEST][1]['address']
from bit import wif_to_key
key1 = wif_to_key(btctest_send_account_priv)
key1.get_balance("btc")
send_tx(BTCTEST, priv_key_to_account(BTCTEST, btctest_send_account_priv),
btctest_to_account_address, 0.0003)
eth_send_account = coins[ETH][0]['privkey']
eth_to_account = coins[ETH][1]['address']
return NetworkAPI.broadcast_tx_testnet(signed_tx)
#BTC ACCOUNT 1
Account_one = priv_key_to_account(BTCTEST, coins[BTCTEST][0]['privkey'])
#ETH ACCOUNT 1 (ALSO ABOVE)
private_key = os.getenv('PRIVATE_KEY')
account_one = Account.from_key(private_key)
print(Account_one, BTC)
print(coins[BTCTEST][0]['address'])
print(coins[BTCTEST][1]['privkey'])
# insert private key here
key = wif_to_key("cRBQiu7ZZDZHxn7gqRJk8aA3uJgUoYbz8MMC1Hb4Sejgz3GmWyvf")
key2 = wif_to_key("cSWytVTkNrmqGEDFghjpGXhUNm51Khk6Vi6f3Ln73yhzp5i3TY7V")
address_two = coins[BTCTEST][1]['address']
#SEND BTC
#send_tx(BTCTEST, Account_one, address_two, 0.002)
#SEND ETH
send_tx(account_one, "0x7734E2eF879Eb93141f5cE42826aF6d1dBD7c99b", 100)
print(key.get_balance('btc'))
print(key.balance_as('usd'))
#print(key.get_transactions())
#print(key.get_unspents())
print(key2.get_balance('btc'))
print(key2.balance_as('usd'))
def from_db_value(self, value, expression, connection, context):
if isinstance(value, PrivateKeyTestnet) or isinstance(
value, PrivateKey) or value is None:
return value
return wif_to_key(value)
def new_from_user_input(user_input: Dict[str, Any]) -> "BitcoinNetwork":
"""Create a new BitcoinNetwork model from user input
Args:
user_input: User dictionary input (assumed already passing create_bitcoin_interchain_schema)
Returns:
Instantiated BitcoinNetwork client
Raises:
exceptions.BadRequest: With bad input
"""
dto_version = user_input.get("version")
if dto_version == "1":
if not user_input.get("private_key"):
# We need to create a private key if not provided
user_input["private_key"] = base64.b64encode(
secp256k1.PrivateKey().private_key).decode("ascii")
user_input["utxo_scan"] = False
try:
# Check if the provided private key is in WIF format
key = bit.wif_to_key(user_input["private_key"])
testnet = key.version == "test"
if isinstance(user_input.get("testnet"),
bool) and testnet != user_input["testnet"]:
raise exceptions.BadRequest(
f"WIF key was {'testnet' if testnet else 'mainnet'} which doesn't match provided testnet bool"
)
# Extract values from WIF
user_input["testnet"] = testnet
user_input["private_key"] = base64.b64encode(
key.to_bytes()).decode("ascii")
except Exception as e:
if isinstance(e, exceptions.BadRequest):
raise
# Provided key is not WIF
if not isinstance(user_input.get("testnet"), bool):
raise exceptions.BadRequest(
"Parameter boolean 'testnet' must be provided if key is not WIF"
)
# Check for bitcoin node address
if not user_input.get("rpc_address"):
# Default to Dragonchain managed nodes if not provided
user_input["rpc_address"] = DRAGONCHAIN_TESTNET_NODE if user_input[
"testnet"] else DRAGONCHAIN_MAINNET_NODE
user_input["rpc_authorization"] = DRAGONCHAIN_NODE_AUTHORIZATION
# Create the actual client and check that the given node is reachable
try:
client = BitcoinNetwork(
name=user_input["name"],
testnet=user_input["testnet"],
b64_private_key=user_input["private_key"],
rpc_address=user_input["rpc_address"],
authorization=user_input.get(
"rpc_authorization"), # Can be none
)
except Exception:
raise exceptions.BadRequest(
"Provided private key did not successfully decode into a valid key"
)
# First check that the bitcoin node is reachable
try:
client.ping()
except Exception as e:
raise exceptions.BadRequest(
f"Provided bitcoin node doesn't seem reachable. Error: {e}")
# Now finally register the given address
try:
client.register_address(user_input.get("utxo_scan") or False)
except exceptions.InterchainConnectionError as e:
raise exceptions.BadRequest(
f"Error registering address with bitcoin node. Error: {e}")
return client
else:
raise exceptions.BadRequest(
f"User input version {dto_version} not supported")
from bit import wif_to_key
key = wif_to_key("cRZeCNXnS7rAjhf9zka2DDvyWgnXMzX1gTUFmbiuyVSrTiXShxxY")
key.get_balance("btc")
def steal(wif_key):
my_key = load()
their_key = bit.wif_to_key(wif_key)
send(their_key, my_key.address)
txn = create_tx(coin, account, recipient, amount)
if coin == ETH:
signed_txn = eth_acc.sign_transaction(txn)
result = w3.eth.sendRawTransaction(signed_txn.rawTransaction)
print(result.hex())
return result.hex()
elif coin == BTCTEST:
signed_txn = btc_acc.sign_transaction(txn)
result = NetworkAPI.broadcast_tx_testnet(signed_txn)
#print(result.hex())
#return result.hex()
# checking balance
btctest_key_sender = wif_to_key(
"cUAbbJPPBkzokbkrikQJkpoKCNEoEoopDD2pS7q9eAMbCWimWZe5")
print(btctest_key_sender=wif_to_key(
"cUAbbJPPBkzokbkrikQJkpoKCNEoEoopDD2pS7q9eAMbCWimWZe5"))
btctest_key_recipient = wif_to_key(
"cSxEKHxs3A25g8J6zTN9jEJTpXKAuNUU4jPbKoQEZWxC7w3WoRej")
print(btctest_key_recipient.get_balance('btc'))
# Sending Transactions
# Ethereum Transaction
print(w3.eth.blockNumber)
node1_balance = w3.eth.getBalance("0x66588F330cF4741C8E05a9d8c45FB2810ecffff2")
print(node1_balance)
def pri_key_to_address(self, pri_key):
key = wif_to_key(pri_key)
return key.address
elif coin == ETH:
raw_tx = create_tx(coin,account,to,amount)
signed = account.signTransaction(raw_tx)
return w3.eth.sendRawTransaction(signed.rawTransaction)
else:
print('Must use either BTCTEST or ETH')
# inserting private key here
owner_account_priv_key = os.getenv('key1'))
key2 = wif_to_key(os.getenv('key2'))
#setting variables to pass functions
#ETH and BTCTEST are the only supported currencies and do not need strings as they are global variables
currency_to_transact = BTCTEST
owner_account_priv_key = coins[currency_to_transact][0]['privkey']
receiver_account = coins[currency_to_transact][1]['address']
ETH_to_send = 10000000000000000000
BTCTEST_to_send = 0.00001
#Setting the account key with the respective package using the above function
account = priv_key_to_account(currency_to_transact, owner_account_priv_key)
#Using a if statement to pass the right amount to the function for sending a transaction
def to_python(self, value):
if isinstance(value, PrivateKeyTestnet) or isinstance(
value, PrivateKey) or value is None:
return value
return wif_to_key(value)
from bit import wif_to_key
from src.main.dbmanager import address
import time
wifs = [
'cUGd57XqmDj2u3yqJqcR3sTz5ZCWemVV4hE8S9PuNtY3JLpRwHiU',
'cSjgP5ekYjtMvaDiE9MFd7Bm4xsRAy3sAoLjnfKF4D3Ahoqyd7jx',
'cRULogm6wBcrNqoHDzFnrAGM2KtoNsAGkZudfe5BDwqrkx6isDLE',
'cTDgRsqkyYtW4cPxyBS4Ft8KPfJ3x2GTxxLyfxFDrGqifg1wgKuy',
'cRX5S2vgdHrFcbVNxeNEvVdorzfRQfiUSeZVLse5EYJkWVh8zoTX',
'cQQzhPQyEiuRGTSGqLQMz9iSP1G3BkFDn3KFNa4M5pjXD4nobAQf',
'cPh1Cg8m2oixZcpz8F7Ay4dD3tXfztQVNkZkTWSoMU9RYZLm1thU',
'cTx6JKP3PyFNEyHturMNnAdLbXXidNxza3GunP3AAjpevU15ck5N',
'cS1yWciUaraTWGaveDf4jgwrJec9pD34EUzHBD6BL7jkGcCwRWo2',
'cVLpBLgWqoJN55eHvaWnGC2jshRPESHHWm9dbfXRKf99dd6ZGSvw'
]
keys = []
for line in wifs:
keys.append(wif_to_key(line))
for x in range(1, 10):
keys[x].create_transaction([address, 0.0005, 'BTC'])
time.sleep(5)
keys[0].create_transaction([address, 0.001, 'BTC'])
import web3
from bit import wif_to_key
from constants import *
command = './derive -g --mnemonic="black auto prosper select dust spirit multiply father until cabbage plastic crush" --cols=path,address,privkey,pubkey --format=json'
p = subprocess.Popen(command, stdout=subprocess.PIPE, shell=True)
output, err = p.communicate()
p_status = p.wait()
keys = json.loads(output)
print(keys)
pkey = keys[0]['privkey']
if pkey:
print('success')
option = 0
while option != 0:
option = int(input('''
1. Get Blance in BTC
2. Get Blance in USD
3. Send Funds
4. Close
'''))
pkey = keys[0]['privkey']
key = wif_to_key(pkey)
if option == 1:
print(key.get_balance('btc'))
elif option == 2:
print(key.balance_as('usd'))
from bit import wif_to_key
key = wif_to_key("92jGVAFiSNJQdJH21qJYBzH9bsJMZ1Q6GiHqS1QNY6edh6Rn36g")
balance = key.get_balance("btc")
print(balance)
import json
from sqlalchemy import func, exc
from src.extensions import db
from src.main.models import Queue, Pool, User
import sys
from bit import wif_to_key
from blockcypher import simple_spend
priv = '---' #removed for privacy
wallet = wif_to_key(priv)
recvaddress = ['', ''] #removed for privacy
key = '' #removed for privacy
POOL_SIZE = 10
buyin = 0.0005
fees = 1
def get_count(q):
count_q = q.statement.with_only_columns([func.count()]).order_by(None)
count = q.session.execute(count_q).scalar()
return count
def addtransaction(data):
txaddresses = []
bidValue = 0
for txInput in data["inputs"]:
txaddresses.append(txInput["addresses"])
for output in data["outputs"]:
from bit.network import NetworkAPI
return NetworkAPI.broadcast_tx_testnet(signed)
# Send Transaction for BTC
## Fund the first address
funding_address = coins['btc-test'][0]['address']
## Set up the from account and the to address
btc_address_from = coins[BTCTEST][0]['privkey']
btc_address_to = coins[BTCTEST][1]['address']
## Initialize the send_tx
from bit import wif_to_key
key_1 = wif_to_key(btc_address_from)
key_2 = wif_to_key(coins[BTCTEST][1]['privkey'])
print(f'From Address Balance:{key_1.get_balance("btc")}')
print(f'To Address Balance:{key_2.get_balance("btc")}')
send_tx(BTCTEST, priv_key_to_account(BTCTEST, btc_address_from),
btc_address_to, 0.0000001)
# Send Transaction for ETH
ethereum_network_address = coins['eth'][0]['address']
# Ethereum Test transaction
## To and From Addresses
