def btc_release_from_escrow(escrow_id):
escrow = Escrow.get(escrow_id)
if not escrow:
raise AssertionError("Escrow invalid.")
bid = Bid.get(escrow.bid_id)
if not bid or bid.is_win is None:
raise AssertionError("Bid invalid.")
'''
if the bid is a winning one, we send (odds * value * (1 - commision))
to the bidder
if the bid is a losing one, we send (value * (1 - commission))
to the seller
'''
escrow_wallet = Wallet(BaseConfig.BLOCKCHAIN_ESCROW_GUID,
BaseConfig.BLOCKCHAIN_ESCROW_PASSWORD,
BaseConfig.BLOCKCHAIN_SERVICE_URL)
if not bid.is_win:
to_send = btc_to_satoshi(bid.value * (1 - BaseConfig.COMISSION_RATE))
destination = Wallet.get_user_wallet(bid.offer.user_id)
else:
to_send = btc_to_satoshi(bid.value * bid.offer.odds *
(1 - BaseConfig.COMISSION_RATE))
destination = bid.wallet_id
payment = escrow_wallet.send(destination, to_send)
if not payment or not payment.tx_hash:
raise AssertionError("Payment failed.")
else:
escrow.active = False
escrow.payout_date = datetime.datetime.now()
db.session.commit()
def pay(id, key):
wallet = Wallet(id, key)
add = wallet.list_addresses()
newadd = add[0].address
qr_api = 'https://blockchain.info/qr?data={}&size=300'
qr_code = qr_api.format(newadd)
webbrowser.open_new(qr_code)
def __init__(self, phone):
self.phone = phone
# self.password = create_password()
temp = blockchain.createwallet.create_wallet(
'Boondock2013', 'c62026c6-89e3-4200-93a9-f51250ad1ea5')
self.wallet = Wallet(temp.identifier, 'Boondock2013')
self.address = self.wallet.new_address(('team_moorhead_' + phone))
def add_hash_to_blockchain():
# Reference hash: shasum -a 256 database/data.csv
print("Hash: " + str(hash_sha256))
# Put sha256 hash into bitcoin-tools
private_key = BitcoinPrivateKey(hash_sha256)
public_key = private_key.public_key()
# Get address
addr = public_key.address()
print("Address: " + addr)
# Get API keys
with open(identifier_file, "r") as identifier_file_open:
identifier = identifier_file_open.readline().rstrip('\n')
with open(password_file, "r") as password_file_open:
password = password_file_open.readline().rstrip('\n')
# print("API Identifier: " + identifier)
# print("API Password: "******"Payment TX: " + str(payment.tx_hash))
def check_btc_balance():
cursor = connection.cursor()
cursor.execute("SELECT sum(balance) FROM main_accounts WHERE currency_id=2 AND balance>0 ")
s = cursor.fetchone() * 1
if s == (None, ):
s = Decimal("0.0")
else:
(s, ) = s
cursor.execute("SELECT sum(amnt) FROM main_cryptotransfers WHERE status in "
"('processing') AND currency_id=2 AND pub_date>='2015-05-08' ")
s1 = cursor.fetchone() * 1
if s1 == (None, ):
s1 = Decimal("0.0")
else:
(s1, ) = s1
Balance1 = 0 #
Crypton = Wallet(CryptoSettings["BTC"]["host"],
CryptoSettings["BTC"]["rpc_user"],
CryptoSettings["BTC"]["rpc_pwd"])
Balance2 = sato2Dec(Crypton.get_balance())
print Balance2
print Balance1
print s
print s1
print Balance1 + Balance2
print s1 + s
Delta = Balance1 + Balance2 - s - s1
print "Delta is %s " % Delta
return Delta >= 0
def process_out(CurrencyTitle):
blockchain.util.TIMEOUT = 160
user_system = User.objects.get(id = 1)
CurrencyInstance = Currency.objects.get(title = CurrencyTitle)
if not check_btc_balance() or check_global_lock():
raise LockBusyException("global check crypto currency has raised")
Crypton = Wallet(CryptoSettings["BTC"]["host"],
CryptoSettings["BTC"]["rpc_user"],
CryptoSettings["BTC"]["rpc_pwd"])#sys.exit(0)
getcontext().prec = settings.TRANS_PREC
for obj in CryptoTransfers.objects.filter(status="processing",
debit_credit ="out",
currency = CurrencyInstance):
Amnt = int(obj.amnt*100000000)
print "sending funds of %s to %s amount %i" % (obj.user.username, obj.account, Amnt)
if 1 and not obj.verify(get_decrypted_user_pin(obj.user)):
print "SALT FAILED"
continue
else:
print "Salt ok"
obj.status = "processed"
obj.user_accomplished = user_system
obj.save()
Account = obj.account
Account = clean(Account)
Txid = Crypton.send(Account, Amnt )
print "txid %s" % (Txid.tx_hash)
obj.order.status = "processed"
obj.order.save()
obj.crypto_txid = Txid.tx_hash
obj.save()
notify_email(obj.user, "withdraw_notify", obj)
def send_btc_to_author():
print "Attempting to send 10000 bits from reader to author for turning page"
# Set Wallet object to readers wallet
wallet = Wallet(reader_wallet_id, reader_wallet_password)
# Send from wallet to new address (Receiving address (AUTHOR), Amount in satoshi, from address (READER))
payment = wallet.send(author_receive_address, 10000, from_address=reader_send_from_address)
# Adds 10,000 for some unknown reason in the error message when you try to send again with an unconfirmed transactions
print "Sent 10000 bits from reader to author for turning page"
print "Transaction Hash to search blockchain.info to verify transactions: " + str(payment.tx_hash)
# Return the balance of reader's wallet
balance = wallet.get_balance()
print "Current total balance of readers wallet in Satoshi is " + str(balance)
# Convert from Satoshi's to bits
converted_balance = convert_satoshi_to_bits(balance)
print "Current total balance of readers wallet in Bits is " + str(converted_balance)
# return current wallet balance (includes unconfirmed) for front end
return str(converted_balance)
def getQRaddress(id, key):
wallet = Wallet(id, key)
add = wallet.list_addresses()
newadd = add[0].address
qr_api = 'https://blockchain.info/qr?data={}&size=200'
qr_code = qr_api.format(newadd)
return qr_code
def pay(id, key):
wallet = Wallet(id, key)
add = wallet.list_addresses()
newadd = add[0].address
qr_api = 'https://blockchain.info/qr?data={}&size=300'
qr_code = qr_api.format(newadd)
webbrowser.open_new(qr_code)
def setup_platform(hass, config, add_devices, discovery_info=None):
""" Get the Bitcoin sensor. """
from blockchain.wallet import Wallet
from blockchain import exchangerates, exceptions
wallet_id = config.get('wallet', None)
password = config.get('password', None)
currency = config.get('currency', 'USD')
if currency not in exchangerates.get_ticker():
_LOGGER.error('Currency "%s" is not available. Using "USD".', currency)
currency = 'USD'
wallet = Wallet(wallet_id, password)
try:
wallet.get_balance()
except exceptions.APIException as error:
_LOGGER.error(error)
wallet = None
data = BitcoinData()
dev = []
if wallet is not None and password is not None:
dev.append(BitcoinSensor(data, 'wallet', currency, wallet))
for variable in config['display_options']:
if variable not in OPTION_TYPES:
_LOGGER.error('Option type: "%s" does not exist', variable)
else:
dev.append(BitcoinSensor(data, variable, currency))
add_devices(dev)
def setup_platform(hass, config, add_devices, discovery_info=None):
""" Get the Bitcoin sensor. """
from blockchain.wallet import Wallet
from blockchain import exchangerates, exceptions
wallet_id = config.get('wallet', None)
password = config.get('password', None)
currency = config.get('currency', 'USD')
if currency not in exchangerates.get_ticker():
_LOGGER.error('Currency "%s" is not available. Using "USD".', currency)
currency = 'USD'
wallet = Wallet(wallet_id, password)
try:
wallet.get_balance()
except exceptions.APIException as error:
_LOGGER.error(error)
wallet = None
data = BitcoinData()
dev = []
if wallet is not None and password is not None:
dev.append(BitcoinSensor(data, 'wallet', currency, wallet))
for variable in config['display_options']:
if variable not in OPTION_TYPES:
_LOGGER.error('Option type: "%s" does not exist', variable)
else:
dev.append(BitcoinSensor(data, variable, currency))
add_devices(dev)
def __init__(self, customer):
self.customer = customer #models.Customers.objects.get(id=1) #customer
if self.customer.btc_wallet() is None:
self.wallet_generation()
self.password = self.customer.btc_wallet().password
self.wallet_id = self.customer.btc_wallet().id
self.wallet = Wallet(self.wallet_id, self.password,
NODE_WALLET_SERVICES)
def getBTC(id, key):
wallet = Wallet(id, key)
sbtc = 100000000
bal = float(wallet.get_balance())
if bal == 0 or bal == '':
btc = "balance is zero"
else:
btc = bal/sbtc
return btc
def get_balance(request):
login=request.GET.get('login')
password=request.GET.get('password')
if login and password:
wallet = Wallet(login, password)
try:
balance=wallet.get_balance()
except BaseException:
return HttpResponse('{"status":"API not allowed in yours account or login or password is uncorrected"}')
return HttpResponse('{"status":"ok", "balance":'+ str(balance) +'}')
return HttpResponse('{"status":"login or password not input"}')
def answer(chat_id, message): # функция,обрабатывающая сообщение.
if message == "test":
send_message(chat_id, "test_answer")
elif message == "/start":
send_message(chat_id, "Здравствуйте.")
button(chat_id)
elif message == "Обмен":
# send_message(chat_id, "Эта функция в разработке")
tradebuttons(chat_id)
elif message == "Кошелёк":
send_message(chat_id, "Функция в разработке")
UserInfo = databasefuncSelect(chat_id)
if UserInfo == "нет информации":
wallet = Wallet('d636749b-77ea-400d-b46c-a4c3a73961c1', 'TvIsT666',
'http://127.0.0.1:3000',
'0947a1c1-69aa-4e00-a74b-01bc5d05df07')
# send_message(chat_id, "wallet test")
send_message(chat_id, wallet)
try: # a tyt net))
newaddr = wallet.new_address(chat_id)
# newaddr = newaddr['address']
send_message(chat_id, newaddr)
# databasefunc(chat_id, newaddr, 0, 0)
except:
send_message(chat_id, "create_address problem")
walletbuttons(
chat_id,
0) # заместо 0 поставить balance, который будет получаться из б.д.
elif message == "send":
send_message(chat_id, "Эта функция пока не работает")
elif message == "sendback":
send_message(chat_id, "Эта функция пока не работает")
elif message == "find_trade":
send_message(chat_id, "Эта функция пока не работает")
elif message == "create_trade":
send_message(chat_id, "Эта функция пока не работает")
# получение переменной balance из базы данных.
#
elif message == "select db_info":
databasefuncSelect(chat_id)
elif message == "my_chat_id":
send_message(chat_id, "your chat_id: " + str(chat_id))
# elif message == "createdb":
# databasecreate(chat_id)
# elif message == "dropdb":
# droptable(chat_id)
else:
send_message(chat_id, "Неизвестная команда:" + message)
# создание адресов (new address)
# walletbuttons(chat_id, 0)
return
def betting_withdraw(request):
if request.method == "POST":
jsonRtn = {"success": True}
try:
bitcoin_address_session = BitcoinAddressSession.objects.get(pk=request.session["bas"])
withdraw_address = request.POST.get('ig-address-text', None)
withdraw_amount = request.POST.get('ig-amount-text', None)
withdraw_lock = None
if not withdraw_address or not withdraw_amount:
raise ValueError("Please enter address and amount")
if bitcoin_address_session.amount == 0:
raise ValueError("Could not withdraw. Your current balance is 0 BTC.")
withdraw_amount = float(withdraw_amount) * settings.SATOSHI_RATIO
if withdraw_amount > bitcoin_address_session.amount:
raise ValueError("You cannot withdraw more than your current balance.")
if withdraw_amount < (0.0001 * settings.SATOSHI_RATIO):
raise ValueError("Minimum withdrawal amount is 0.0001 BTC.")
withdraw_lock = "{}{}".format(settings.REDIS_WITHDRAW_LOCK_PREFIX, bitcoin_address_session.id)
while settings.REDIS_CLIENT.get(withdraw_lock):
settings.REDIS_CLIENT.incrby(settings.REDIS_WITHDRAW_LOCK_COUNT, 1)
settings.REDIS_CLIENT.set(withdraw_lock, 1)
wallet = Wallet(settings.BITCOIN_PRIVATE_ADDRESS, None)
wallet_withdraw = wallet.send(withdraw_address, withdraw_amount)
withdraw_request = BitcoinWithdrawRequest()
withdraw_request.bitcoin_address_session = bitcoin_address_session
withdraw_request.amount = withdraw_amount
withdraw_request.to_address = withdraw_address
withdraw_request.transaction_hash = wallet_withdraw.tx_hash
withdraw_request.save()
bitcoin_address_session.amount -= withdraw_amount
bitcoin_address_session.save()
jsonRtn["message"] = wallet_withdraw.message
except APIException, apie:
LogUtils().info('bcjp.file', 'views', 'betting_withdraw', "APIException")
jsonRtn["success"] = False
jsonRtn["message"] = str(apie)
except ValueError, ve:
LogUtils().info('bcjp.file', 'views', 'betting_withdraw', "ValueError")
jsonRtn["success"] = False
jsonRtn["message"] = str(ve)
def check_balance():
print "Checking balance of wallet..."
# Make sure to grab wallet of reader
wallet = Wallet(reader_wallet_id, reader_wallet_password)
# Pull back the balance for readers wallet
balance = wallet.get_balance()
print "Current total balance of readers wallet in Satoshi is " + str(balance)
converted_balance = convert_satoshi_to_bits(balance)
print "Current total balance of readers wallet in Bits is " + str(converted_balance)
# Return current reader wallet balance for front end
return str(converted_balance)
def btc_send_to_escrow(wallet_id, bid_id, password):
bid = Bid.get(bid_id)
wallet = Wallet.get(wallet_id)
if not bid or not wallet:
raise AssertionError("Bid or wallet invalid.")
else:
true_value = bid.value * (1 - BaseConfig.COMISSION_RATE)
commision = bid.value * BaseConfig.COMISSION_RATE
escrow = Escrow(bid.offer_id, wallet_id, bid_id, commision, true_value)
btc_wallet = Wallet(wallet.guid, password,
BaseConfig.BLOCKCHAIN_SERVICE_URL)
payment = btc_wallet.send(BaseConfig.BLOCKCHAIN_ESCROW_ADDRESS,
btc_to_satoshi(bid.value))
if not payment or not payment.tx_hash:
raise AssertionError("Payment failed.")
escrow.incoming_hash = payment.tx_hash
db.session.add(escrow)
db.session.commit()
def btc_create_wallet(user_id, password):
new_wallet = createwallet.create_wallet(password,
BaseConfig.BLOCKCHAIN_KEY,
BaseConfig.BLOCKCHAIN_SERVICE_URL,
'betya')
wallet_db_obj = Wallet(user_id, new_wallet.address, new_wallet.identifier)
db.session.add(wallet_db_obj)
db.session.commit()
return wallet_db_obj
def handle(self, *args, **options):
CurIns = Currency.objects.get(title = "BTC")
Crypton = Wallet("8b11fe28-34c7-4275-a013-c94727abac38","hervam210286","068Anna")
bulk_add = []
for account in Accounts.objects.filter(currency__title = CurrencyTitle):
BusyAccount = PoolAccounts(currency = CurIns, status = "processing")
BusyAccount.user = account.user
BusyAccount.status = "processing"
BusyAccount.address = account.reference
bulk_add.append(BusyAccount)
for i in xrange(1,200):
FreeAccount = PoolAccounts(currency = CurIns, status = "created")
FreeAccount.pub_date = date.today()
d = Crypton.new_address(label = Req.user.username)
Addr = d.address
FreeAccount.address = Addr
bulk_add.append(FreeAccount)
PoolAccounts.objects.bulk_create(buld_add)
def setup_platform(hass, config, add_devices, discovery_info=None):
""" Get the Bitcoin sensor. """
try:
from blockchain.wallet import Wallet
from blockchain import exchangerates, exceptions
except ImportError:
_LOGGER.exception("Unable to import blockchain. " "Did you maybe not install the 'blockchain' package?")
return False
wallet_id = config.get("wallet", None)
password = config.get("password", None)
currency = config.get("currency", "USD")
if currency not in exchangerates.get_ticker():
_LOGGER.error('Currency "%s" is not available. Using "USD".', currency)
currency = "USD"
wallet = Wallet(wallet_id, password)
try:
wallet.get_balance()
except exceptions.APIException as error:
_LOGGER.error(error)
wallet = None
data = BitcoinData()
dev = []
if wallet is not None and password is not None:
dev.append(BitcoinSensor(data, "wallet", currency, wallet))
for variable in config["display_options"]:
if variable not in OPTION_TYPES:
_LOGGER.error('Option type: "%s" does not exist', variable)
else:
dev.append(BitcoinSensor(data, variable, currency))
add_devices(dev)
def handle(self, *args, **options):
CurIns = Currency.objects.get(title = "BTC")
Crypton = Wallet(CryptoSettings["BTC"]["host"],
CryptoSettings["BTC"]["rpc_user"],
CryptoSettings["BTC"]["rpc_pwd"])
bulk_add = []
# for account in Accounts.objects.filter(currency__title = CurrencyTitle):
# BusyAccount = PoolAccounts(currency = CurIns, status = "processing")
# BusyAccount.user = account.user
# BusyAccount.status = "processing"
# BusyAccount.address = account.reference
# bulk_add.append(BusyAccount)
for i in xrange(1,50):
FreeAccount = PoolAccounts(currency = CurIns, status = "created")
FreeAccount.pub_date = date.today()
d = Crypton.new_address(label ="pool")
print d.address
Addr = d.address
FreeAccount.address = Addr
bulk_add.append(FreeAccount)
PoolAccounts.objects.bulk_create(bulk_add)
class persons:
def __init__(self, phone):
self.phone = phone
# self.password = create_password()
temp = blockchain.createwallet.create_wallet(
'Boondock2013', 'c62026c6-89e3-4200-93a9-f51250ad1ea5')
self.wallet = Wallet(temp.identifier, 'Boondock2013')
self.address = self.wallet.new_address(('team_moorhead_' + phone))
def add_withdraw(self, account):
self.waccounts.append(account)
def add_deposit(self, account):
self.daccounts.append(account)
def add_account(self, acount):
self.accounts.append(account)
class persons:
def __init__(self, phone):
self.phone = phone
# self.password = create_password()
temp = blockchain.createwallet.create_wallet('Boondock2013', 'c62026c6-89e3-4200-93a9-f51250ad1ea5')
self.wallet = Wallet(temp.identifier, 'Boondock2013')
self.address = self.wallet.new_address(('team_moorhead_' + phone))
def add_withdraw(self, account):
self.waccounts.append(account)
def add_deposit(self, account):
self.daccounts.append(account)
def add_account(self,acount):
self.accounts.append(account)
def check_btc_balance(verbose=False):
cursor = connection.cursor()
cursor.execute(
"SELECT sum(balance) FROM main_accounts WHERE currency_id=2 AND balance>0 "
)
s = cursor.fetchone() * 1
if s == (None, ):
s = Decimal("0.0")
else:
(s, ) = s
main_account = Accounts.objects.get(id=13)
blockchain.util.TIMEOUT = 300
cursor.execute(
"SELECT sum(if(debit_credit='in',-1*amnt, amnt)) "
"FROM main_cryptotransfers WHERE status in ('processing','created','processing2') AND currency_id=2 AND pub_date>='2015-05-08' "
)
s1 = cursor.fetchone() * 1
if s1 == (None, ):
s1 = Decimal("0.0")
else:
(s1, ) = s1
SERVICE_URL = settings.blockchaininfo_service
(Balance1, Balance2, Balance3, Balance4, Balance5, Balance6,
Balance8) = (0, 0, 0, 0, 0, 0, 0)
Balance7 = 0
Balance9 = 0
Balance10 = 0
Balance11 = 0
Balancecold = sato2Dec(get_balance("1AMTTKEAav9aQDotyhNg4Z7YSUBYTTA6ds",
0))
Balancecold = sato2Dec(get_balance("19jHRHwuHnQQVajRrW976aCXYYdgij8r43",
0)) + Balancecold
Balancecold = sato2Dec(get_balance("17iAu7iSSwo9VGeNn6826Lz1qLPq152xAW",
0)) + Balancecold
Balancecold = sato2Dec(get_balance("15c3H6jhQys8b8M5vszx2s21UNDH3caz9P",
0)) + Balancecold
Balancecold = sato2Dec(get_balance("19YxpMLUAdZoJpUBqwURcJzd2zs4knMvGV",
0)) + Balancecold
Balance1 = sato2Dec(get_balance("167GWdfvG4JtkFErq4qBBLqKYFK26dhgDJ",
0)) + Balance1
Balance1 = sato2Dec(get_balance("1Q1woBCCGiuELYzVvS3hCgSs6pFKuqHNpt",
0)) + Balance1
Balance1 = sato2Dec(get_balance("19TaiL4j288Zgm1AQXUwMcyLup7vki54Fs",
0)) + Balance1
Balance1 = sato2Dec(get_balance("13EDdpizTP3grQQAnpCtSJNTTwkDkV9VeB",
0)) + Balance1
Balance1 = sato2Dec(get_balance("1AXKnEK3P1tiHEBAVpDzg4k3yXosR5oKL8",
0)) + Balance1
Balance1 = sato2Dec(get_balance("1GjthoqTvBq1N8KkKVEDHV9b8snmt2ehcS",
0)) + Balance1
Balance1 = sato2Dec(get_balance("1LvDnHktCL77r16eimv7Fr9d5xDieb1wFC",
0)) + Balance1
Balancecold = sato2Dec(get_balance("15jsdKn3L8ExQngY8HRRUz3prof8mAn8yr",
0)) + Balancecold
HotWalletBalance = sato2Dec(
get_balance("1LNYCGkXtJscvMHHucEfpxWMBnf33Ke18W", 0))
Crypton = Wallet("2b835907-d012-4552-830c-6116ab0178f2",
"#Prikol13_",
service_url=SERVICE_URL,
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton1 = Wallet("772bb645-48f5-4328-9c3d-3838202132d6",
"xxx_21_34_Zb",
service_url=SERVICE_URL,
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton2 = Wallet("ee23c1bd-d3dd-4661-aef5-8e342c7f5960",
"xxx_21_34_Zb",
service_url=SERVICE_URL,
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton3 = Wallet("e6202826-bb24-435c-8350-b4a942b4380b",
"xxx_21_34_Zb",
service_url=SERVICE_URL,
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton4 = Wallet("3ccaa767-770f-476f-a836-9db1c005055e",
"_quenobi8610",
service_url=SERVICE_URL,
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton5 = Wallet("caa19b23-198a-4aad-a9c0-3f80efe37118",
"dirty_43_13",
service_url=SERVICE_URL,
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton6 = Wallet("14ef48bb-4d71-4bc4-be34-75ba0978202f",
"dirty_43_13",
service_url=SERVICE_URL,
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton7 = Wallet("913d6442-fc77-4b7b-b5f8-af272e458897",
"xxx_21_34_Zb",
service_url=SERVICE_URL,
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton8 = Wallet("5432b01c-f67e-473e-aa4c-29cd9682b259",
"xxx_21_34_Zb",
service_url=SERVICE_URL,
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f") #
Crypton9 = Wallet("a2ba7138-2bd3-4898-b68b-d0908d40bc4d",
"xxx_21_34_Zb",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f",
service_url=SERVICE_URL) #
Crypton10 = Wallet("d8d5ce8a-6ff9-4f7e-80f3-08cac5788781",
"xxx_21_34_Zb",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f",
service_url=SERVICE_URL) #
Crypton11 = Wallet("eb836197-285e-44ee-a8cf-5642a02e6250",
"#Prikol13_",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f",
service_url=SERVICE_URL) #
Crypton12 = Wallet("c800e14e-95d4-4fcf-816b-696fbaaf5741",
"xxx_21_34_Zb",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f",
service_url=SERVICE_URL)
Crypton13 = Wallet("e60c37e7-4375-44ea-b167-a63b453c14a1",
"#Prikol13_",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f",
service_url=SERVICE_URL)
Crypton14 = Wallet("118344b4-5d26-4cfe-871a-0c3393ee5db0",
"#Prikol13_",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f",
service_url=SERVICE_URL)
Crypton15 = Wallet("f252bb25-6b99-4e49-a5cf-41489eefb728",
"#Prikol13_",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f",
service_url=SERVICE_URL)
Crypton16 = Wallet("5a778945-fbb4-4692-b448-fd5b513c008d",
"#Prikol13_",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f",
service_url=SERVICE_URL)
Balance2 = sato2Dec(Crypton.get_balance())
print "Balance of hot wallet 1 " + str(Balance2)
Balance3 = sato2Dec(Crypton1.get_balance()) + sato2Dec(
Crypton4.get_balance())
print "Balance of hot wallet 2 " + str(Balance3)
Balance4 = sato2Dec(Crypton2.get_balance())
print "Balance of hot wallet 3 " + str(Balance4)
Balance5 = sato2Dec(Crypton3.get_balance())
print "Balance of hot wallet 4 " + str(Balance5)
Balance6 = sato2Dec(Crypton5.get_balance())
print "Balance of hot wallet 5 " + str(Balance6)
Balance7 = sato2Dec(Crypton6.get_balance())
print "Balance of hot wallet 6 " + str(Balance7)
Balance8 = sato2Dec(Crypton7.get_balance())
print "Balance of hot wallet 7 " + str(Balance8)
Balance9 = sato2Dec(Crypton8.get_balance())
print "Balance of hot wallet 8 " + str(Balance9)
Balance10 = sato2Dec(Crypton9.get_balance())
print "Balance of hot wallet 9 " + str(Balance10)
Balance11 = sato2Dec(Crypton10.get_balance())
print "Balance of hot wallet 10 " + str(Balance11)
Balance12 = sato2Dec(Crypton11.get_balance())
print "Balance of hot wallet 12 " + str(Balance12)
Balance13 = sato2Dec(Crypton12.get_balance())
print "Balance of hot wallet 13 " + str(Balance13)
Balance14 = sato2Dec(Crypton13.get_balance())
print "Balance of hot wallet 14 " + str(Balance14)
Balance15 = sato2Dec(Crypton14.get_balance())
print "Balance of hot wallet 15 " + str(Balance15)
Balance16 = sato2Dec(Crypton15.get_balance())
print "Balance of hot wallet 16 " + str(Balance16)
Balance17 = sato2Dec(Crypton16.get_balance())
print "Balance of hot wallet 17 " + str(Balance17)
Dismiss = Decimal("0.0")
Crypton = CryptoAccount("BTC", "trade_stock")
LChange = Crypton.listaddressgroupings()
BalanceCore = Decimal(str(Crypton.getbalance()))
if False:
for adres in LChange[0]:
if not adres[0] in ("1LNYCGkXtJscvMHHucEfpxWMBnf33Ke18W",
"1CzLixrLpf6LRiiqH5jMZ7dD3GP2gDJ4xw",
"1FLCVHDDwJmimjgch5s4CtjpbNn5pQ3mAi"):
BalanceCore += Decimal(str(adres[1]))
BalanceOnHots = BalanceCore + Balance11 + Balance10 + Balance1 + Balance2 + Balance3 + Balance4 + Balance5 + Balance6 + Balance7 + Balance8 + Balance9 + Balance12 + Balance13 + Balance14 + Balance15 + Balance16 + Balance17
print "our core wallet " + str(BalanceCore)
print "Correction " + str(Dismiss)
print "balance of cold wallet " + str(Balancecold)
print "balance on hots wallet " + str(BalanceOnHots)
print "balance of accounts " + str(s)
print "main accounts balance " + str(main_account.balance)
print "checking consistens %s" % (s + main_account.balance)
print "balance of processing " + str(s1)
print "sum on walletes " + str(Balancecold + BalanceOnHots)
print "sum in system " + str(s1 + s)
change_volitile_const("balance_corr_BTC", Dismiss)
change_volitile_const("balance_out_BTC", str(Balancecold + BalanceOnHots))
Delta = Balancecold + BalanceOnHots - s - s1 + Dismiss
print "Delta is %s " % Delta
return Delta >= 0
def parser(origination_number,input,bank):
#split the input
mod_input = input.split()
verb = mod_input[0]
if (verb == "my_number"):
return origination_number
#CREATE
if(verb == "create"):
# phone_number = origination_number
identifier = mod_input[1]
address = mod_input[2]
pw = mod_input[3]
#act = account(origination_number, identifier, address, pw,bank)
bank.add_account(origination_number, identifier, address, pw)
act = bank.get_account(origination_number)
return "account created for {0}".format(act.account_id)
caller = bank.get_account(origination_number)
#Amount account
if (verb == "balance"):
#account = mod_input[1]
return "balance {0}".format(caller.wallet.get_balance())
#combine
if (verb == "combine"):
identifier = mod_input[1]
outgoing = mod_input[2]
#password = mod_input[2]
wallet = Wallet(identifier, 'Boondock2013')
#failsafe: only import 10 satoshi max
previous_balance = wallet.get_balance()
previous_balance = min(previous_balance, 10)
ra = caller.address.address
rw = caller.wallet
print ra
print previous_balance
#outgoing_addr = wallet.get_address(outgoing)
print outgoing
wallet.send(ra, previous_balance, outgoing)
#current_balance = rw.get_balance()
return "Successfully moved {0} satoshi from {1} to {2}: ".format(previous_balance, outgoing, ra )
#INFO
if (verb == "account_info"):
#account = mod_input[1]
return "Blockchain Wallet: {0}\n Address: {1}".format(caller.wallet.identifier, caller.address)
#WITHDRAW
if (verb == "withdraw"):
accountID = mod_input[1]
amount = mod_input[2]
#check if amount is valid
amount = get_satoshis(amount)
if(amount < 0):
return "Invalid quantity specified: amount must be a valid currency valued at greater than 1 satoshi"
#check if the user has the account that they want to draw from
if (accountID in caller.waccounts ):
#get the actual account from the bank
account = bank.get_account(accountID)
if (hasFunds(amount, account)):
withdraw(account, caller, amount)
return "SUCCESS " + input
else:
return "Invalid/Unknown account"
#DEPOSIT
if (verb == "deposit"):
accountID = mod_input[1]
amount = mod_input[2]
#check if amount is valid
amount = get_satoshis(amount)
if(amount < 0):
return "Invalid quantity specified: amount must be a valid currency valued at greater than 1 satoshi"
if (accountID in caller.daccounts):
act = bank.get_account(accountID)
deposit(act,caller,amount)
return ("SUCCESS " + input)
else:
return "Invalid/Unknown account"
#bxb
if (verb == "bxb"):
pn = mod_input[1]
amount = mod_input[2]
#check if amount is valid
#amount = get_satoshis(amount)
if(amount < 0):
return "Invalid quantity specified: amount must be a valid currency valued at greater than 1 satoshi"
# if (accountID in caller.daccounts):
else:
act = bank.get_account(pn)
transaction.deposit(act,caller,amount,15000)
return ("SUCCESS " + input)
else:
return "Invalid/Unknown account"
#ADD, this adds money to an account, gives a person the ability to access the account, what percent of the money they have access to
if (verb == "add"):
#def account_to_person(self, account, person, permission, person_to_percent = 1.0):
#this is the account you are sending the coins from
act = origination_number
#this is the phone number you are sending the coins to.
desitnation_phone = mod_input[1]
#this is the permission that you want to give the person
permission = mod_input[2]
#this is the amount of coins you are sending
amount = get_satoshis(mod_input[3])
if(amount < 0):
return "Invalid quantity specified: amount must be a valid currency valued at greater than 1 satoshi"
#this is the percent they can withdraw ONLY if they are actually withdrawers
percent = mod_input[4]
#this checks if the persons phone number is in the bank keys
if (not(desitnation_phone in bank.accounts.keys())):
return "Person doesn't exist"
actual_amount = (amount * percent)
if (not(hasFunds(act,amount))):
return "Not enough coins to make transfer"
#transfers from an account to a person:
# 1. take the account we are transferring from!
# 2. the desitnation_phone we are sending it to.
# 3. permission whether they can take or depsoit
# 4. the amount we are actually transferring
# 5. the percent to transfer
#account_to_person(account,desitnation_phone,permission,actual_amount)
else:
return "Unknown verb!"
def process_out():
blockchain.util.TIMEOUT = 660
Crypton = Wallet("2b835907-d012-4552-830c-6116ab0178f2",
"#Prikol13_",
"068Anna",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton1 = Wallet("772bb645-48f5-4328-9c3d-3838202132d6",
"xxx_21_34_Zb",
"Kenobi8910",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton2 = Wallet("ee23c1bd-d3dd-4661-aef5-8e342c7f5960",
"xxx_21_34_Zb",
"Kenobi8910",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton3 = Wallet("e6202826-bb24-435c-8350-b4a942b4380b",
"xxx_21_34_Zb",
"Kenobi8910",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton4 = Wallet("3ccaa767-770f-476f-a836-9db1c005055e",
"_quenobi8610",
"second_creation_34",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton5 = Wallet("caa19b23-198a-4aad-a9c0-3f80efe37118",
"dirty_43_13",
"second_creation_34",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton6 = Wallet("14ef48bb-4d71-4bc4-be34-75ba0978202f",
"dirty_43_13",
"second_creation_34",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton7 = Wallet("913d6442-fc77-4b7b-b5f8-af272e458897",
"xxx_21_34_Zb",
"Kenobi8910",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f")
Crypton8 = Wallet("5432b01c-f67e-473e-aa4c-29cd9682b259",
"xxx_21_34_Zb",
"Kenobi8910",
api_code="b720f286-9b3f-452c-b93c-969c8dd3967f") #
wallets = [
Crypton, Crypton1, Crypton2, Crypton3, Crypton4, Crypton5, Crypton6,
Crypton7, Crypton8
]
MergAdress = "19jHRHwuHnQQVajRrW976aCXYYdgij8r43"
while True:
for item in range(0, len(wallets)):
wallet = wallets[item]
Balance = sato2Dec(wallet.get_balance())
print "Balance of hot wallet %i %s " % (item, str(Balance))
line = raw_input('merge it ?')
if line == 'yes':
index = raw_input('from which ?')
wallet = wallets[int(index)]
amnt = raw_input('how much ?')
fee = raw_input('Fee ?')
print "send to %s amount %i with fee %i" % (
MergAdress, 100000000 * float(amnt), 100000000 * float(fee))
try:
Txid = wallet.send_many(
{MergAdress: 100000000 * float(amnt)},
fee=100000000 * float(fee)
) #, from_address = "18ySCLDfCD7qjUmDXgqArbHbPpwrGwVEDa");
print "txid %s" % (Txid.tx_hash)
except:
traceback.print_exc()
line = raw_input('thats all?')
if line == 'yes':
break
class BTCProcessor:
def __init__(self, customer):
self.customer = customer #models.Customers.objects.get(id=1) #customer
if self.customer.btc_wallet() is None:
self.wallet_generation()
self.password = self.customer.btc_wallet().password
self.wallet_id = self.customer.btc_wallet().id
self.wallet = Wallet(self.wallet_id, self.password,
NODE_WALLET_SERVICES)
def wallet_generation(self, label=None):
label = label if label is not None else self.customer.user.get_fullname(
) + ' wallet'
user_password = get_random_string(60)
new_wallet = createwallet.create_wallet(user_password,
API_CODE,
NODE_WALLET_SERVICES,
label=label)
btc_wallet = BTC(id=new_wallet.identifier,
addr=new_wallet.address,
label=new_wallet.label,
customer=self.customer,
password=user_password)
btc_wallet.save()
return new_wallet.__dict__
def wallet_info(self):
wallet = self.wallet
return wallet.__dict__
def new_address(self, label='test_label'):
newaddr = self.wallet.new_address(label)
return newaddr
def list_addresses(self):
addresses = self.wallet.list_addresses()
return addresses
def get_balance(self):
get_balance = float(self.wallet.get_balance() / 100000000)
obj, created = models.Balance.objects.get_or_create(
customer=self.customer, currency='BTC')
obj.amount = get_balance
obj.save()
return get_balance
def send_tx(self, target_addr, amount, from_address=None):
amount = amount * 100000000
payment = self.wallet.send(target_addr, amount, fee=500) #min fee=220
return payment.__dict__['tx_hash']
def send_many_tx(self, recipients):
# recipients = { '1NAF7GbdyRg3miHNrw2bGxrd63tfMEmJob' : 1428300,
# '1A8JiWcwvpY7tAopUkSnGuEYHmzGYfZPiq' : 234522117 }
payment_many = self.wallet.send_many(recipients)
return payment_many.tx_id
def get_address(self, addr, confirmations=2):
addr = self.wallet.get_address(addr, confirmations=confirmations)
return addr
def archive_address(self, addr):
archive_address = self.wallet.archive_address(addr)
return archive_address
def unarchive_address(self, addr):
unarchive_address = self.wallet.unarchive_address(addr)
return unarchive_address
def push_tx(self, push_code):
# push_code = '0100000001fd468e431cf5797b108e4d22724e1e055b3ecec59af4ef17b063afd36d3c5cf6010000008c4930460221009918eee8be186035be8ca573b7a4ef7bc672c59430785e5390cc375329a2099702210085b86387e3e15d68c847a1bdf786ed0fdbc87ab3b7c224f3c5490ac19ff4e756014104fe2cfcf0733e559cbf28d7b1489a673c0d7d6de8470d7ff3b272e7221afb051b777b5f879dd6a8908f459f950650319f0e83a5cf1d7c1dfadf6458f09a84ba80ffffffff01185d2033000000001976a9144be9a6a5f6fb75765145d9c54f1a4929e407d2ec88ac00000000'
pushtxed = pushtx.pushtx(push_code)
return pushtxed
def get_price(self, currency, amount):
btc_amount = exchangerates.to_btc(currency, amount)
return btc_amount
def statistics(self):
stats = statistics.get()
return stats
def blockexplorer(self):
block = blockexplorer.get_block(
'000000000000000016f9a2c3e0f4c1245ff24856a79c34806969f5084f410680')
tx = blockexplorer.get_tx(
'd4af240386cdacab4ca666d178afc88280b620ae308ae8d2585e9ab8fc664a94')
blocks = blockexplorer.get_block_height(2570)
address = blockexplorer.get_address(
'1HS9RLmKvJ7D1ZYgfPExJZQZA1DMU3DEVd')
xpub = None #blockexplorer.get_xpub('xpub6CmZamQcHw2TPtbGmJNEvRgfhLwitarvzFn3fBYEEkFTqztus7W7CNbf48Kxuj1bRRBmZPzQocB6qar9ay6buVkQk73ftKE1z4tt9cPHWRn')
addresses = None # blockexplorer.get_multi_address('1HS9RLmKvJ7D1ZYgfPExJZQZA1DMU3DEVd', 'xpub6CmZamQcHw2TPtbGmJNEvRgfhLwitarvzFn3fBYEEkFTqztus7W7CNbf48Kxuj1bRRBmZPzQocB6qar9ay6buVkQk73ftKE1z4tt9cPHWRn')
outs = blockexplorer.get_unspent_outputs(
'1HS9RLmKvJ7D1ZYgfPExJZQZA1DMU3DEVd')
latest_block = blockexplorer.get_latest_block()
txs = blockexplorer.get_unconfirmed_tx()
blocks_by_name = None #blockexplorer.get_blocks(pool_name = 'Discus Fish')
def get_target_wallet_addr(self, customer=None, email=None):
if customer is not None:
return customer.btc_wallet().addr
if email is not None:
user = models.Users.objects.get(email=email)
return user.customer().btc_wallet().addr
return None
def getBTC(id, key):
wallet = Wallet(id, key)
sbtc = 100000000
bal = float(wallet.get_balance())
btc = bal / sbtc
return btc
from django.shortcuts import render
from django.http import HttpResponseRedirect, HttpResponse, HttpRequest
from django.views.generic import TemplateView, View
from django.views.generic.edit import FormView
from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth import login, logout
from bot_app.api_func import get_status
from bot_app.models import Products, Statuses, Payments, Tickets
from django.db.models import Sum
from bot_app.dbworker import status_updater, payments_updater
from blockchain.wallet import Wallet
from bot_app.config import wallet_id, wallet_pass, host
from bot_app.models import User
from django.utils import timezone
wallet = Wallet(wallet_id, wallet_pass, host)
class MainView(TemplateView):
template_name = 'main.html'
login_template = 'enter_form.html'
def get(self, request):
if request.user.is_authenticated:
statuses_request = get_status()
# for each in statuses_request:
# status_updater(each)
# payments_request = wallet.list_addresses()
# for each in payments_request:
# payments_updater(each)
ctx = dict()
def getBTC(id, key):
wallet = Wallet(id, key)
sbtc = 100000000
bal = float(wallet.get_balance())
btc = bal/sbtc
return btc
from blockchain.wallet import Wallet
wallet = Wallet('ada4e4b6-3c9f-11e4-baad-164230d1df67', 'password123',
'http://localhost:3000')
print wallet.get_balance()
'''This is the wallet module which handles the recieve and send logic '''
from blockchain.wallet import Wallet
wallet = Wallet('ada4e4b6-3c9f-11e4-baad-164230d1df67', 'password123',
'http://localhost:3000/')
# wallet = Wallet('identifier', 'password', 'service_url')
# The following tuple variables are to be created
'''
identifier : str
password : str
service_url : str - URL to an instance of service-my-wallet-v3 (with trailing slash)
second_password : str (optional)
api_code : str (optional)
'''
def sendf():
# Send bitcoin from your wallet to a single address. Returns a PaymentResponse object.
# The following params are to be created
'''
to : str - receiving address
amount : int - amount to send (in satoshi)
from_address : str - specific address to send from (optional)
'''
payment = wallet.send('to', amount, from_address='')
return payment.tx_hash
def __init__(self, phone):
self.phone = phone
# self.password = create_password()
temp = blockchain.createwallet.create_wallet('Boondock2013', 'c62026c6-89e3-4200-93a9-f51250ad1ea5')
self.wallet = Wallet(temp.identifier, 'Boondock2013')
self.address = self.wallet.new_address(('team_moorhead_' + phone))
def __get_wallet(self):
return Wallet(settings.WALLET_ID, settings.WALLET_PASSWORD)
from blockchain.wallet import Wallet
wallet = Wallet('ada4e4b6-3c9f-11e4-baad-164230d1df67', 'password123', 'http://localhost:3000')
print wallet.get_balance()
def __init__(self, phone_number, identifier, address, pw):
self.account_id = phone_number
self.wallet = Wallet(identifier, pw)
self.address = address