1730 lines
78 KiB
Python
1730 lines
78 KiB
Python
# coding=utf-8
|
||
import json
|
||
import os
|
||
import sys
|
||
import ujson
|
||
import time
|
||
import requests
|
||
from loguru import logger
|
||
from datetime import datetime, timedelta
|
||
from easybitcoinrpc import RPC
|
||
import csv
|
||
import sqlite3
|
||
from bitcoinutils.script import Script
|
||
from bitcoinutils.keys import P2wpkhAddress, P2wshAddress, P2shAddress, PrivateKey, PublicKey, SegwitAddress, P2pkhAddress
|
||
from bitcoinutils.setup import setup
|
||
import pymysql
|
||
import pymongo
|
||
from urllib import parse
|
||
|
||
import btc_historical_price
|
||
|
||
|
||
class UtxosIf:
|
||
def __init__(self):
|
||
self.balance_0 = 0
|
||
self.balance_001 = 0
|
||
self.balance_01 = 0
|
||
self.balance_1 = 0
|
||
self.balance_10 = 0
|
||
self.balance_100 = 0
|
||
self.balance_1000 = 0
|
||
self.balance_10000 = 0
|
||
|
||
self.balance_amount_0 = 0
|
||
self.balance_amount_001 = 0
|
||
self.balance_amount_01 = 0
|
||
self.balance_amount_1 = 0
|
||
self.balance_amount_10 = 0
|
||
self.balance_amount_100 = 0
|
||
self.balance_amount_1000 = 0
|
||
self.balance_amount_10000 = 0
|
||
|
||
self.profit_addresses = 0
|
||
self.loss_addresses = 0
|
||
self.profit_ratio = 0
|
||
self.lth_supply = 0
|
||
self.sth_supply = 0
|
||
self.realized_price = 0
|
||
self.relative_lth_sth = 0
|
||
self.lth_profit_supply = 0
|
||
self.lth_loss_supply = 0
|
||
self.lth_profit_ratio = 0
|
||
self.sth_profit_supply = 0
|
||
self.sth_loss_supply = 0
|
||
self.sth_profit_ratio = 0
|
||
self.slrv_ratio = 0
|
||
self.slrv_24h = 0
|
||
self.slrv_6m1y = 0
|
||
|
||
self.total_address = 0
|
||
self.miner_address = 0
|
||
self.miner_balance = 0
|
||
self.total_balance = 0
|
||
self.total_rcap = 0
|
||
self.holder_0 = 0
|
||
self.holder_1 = 0
|
||
self.holder_2 = 0
|
||
self.holder_3 = 0
|
||
self.holder_4 = 0
|
||
self.holder_5 = 0
|
||
self.holder_6 = 0
|
||
self.holder_7 = 0
|
||
self.holder_15 = 0
|
||
self.holder_30 = 0
|
||
self.holder_60 = 0
|
||
self.holder_90 = 0
|
||
self.holder_180 = 0
|
||
self.holder_360 = 0
|
||
self.holder_540 = 0
|
||
self.holder_720 = 0
|
||
self.holder_1080 = 0
|
||
self.holder_1440 = 0
|
||
self.holder_1800 = 0
|
||
self.holder_2160 = 0
|
||
self.holder_2520 = 0
|
||
self.holder_2880 = 0
|
||
self.holder_3240 = 0
|
||
self.holder_3600 = 0
|
||
self.holder_3960 = 0
|
||
|
||
self.holder_balance_0 = 0
|
||
self.holder_balance_1 = 0
|
||
self.holder_balance_2 = 0
|
||
self.holder_balance_3 = 0
|
||
self.holder_balance_4 = 0
|
||
self.holder_balance_5 = 0
|
||
self.holder_balance_6 = 0
|
||
self.holder_balance_7 = 0
|
||
self.holder_balance_15 = 0
|
||
self.holder_balance_30 = 0
|
||
self.holder_balance_60 = 0
|
||
self.holder_balance_90 = 0
|
||
self.holder_balance_180 = 0
|
||
self.holder_balance_360 = 0
|
||
self.holder_balance_540 = 0
|
||
self.holder_balance_720 = 0
|
||
self.holder_balance_1080 = 0
|
||
self.holder_balance_1440 = 0
|
||
self.holder_balance_1800 = 0
|
||
self.holder_balance_2160 = 0
|
||
self.holder_balance_2520 = 0
|
||
self.holder_balance_2880 = 0
|
||
self.holder_balance_3240 = 0
|
||
self.holder_balance_3600 = 0
|
||
self.holder_balance_3960 = 0
|
||
|
||
self.price_buy = {} # step 500
|
||
self.price_buy_amount = {} # step 500
|
||
self.diff_sell = {} # step 500
|
||
self.diff_sell_amount = {}
|
||
self.profit_sell = {} # step 5000
|
||
self.profit_sell_amount = {}
|
||
|
||
self.balance_0_days = {}
|
||
self.balance_001_days = {}
|
||
self.balance_01_days = {}
|
||
self.balance_1_days = {}
|
||
self.balance_10_days = {}
|
||
self.balance_100_days = {}
|
||
self.balance_1000_days = {}
|
||
self.balance_10000_days = {}
|
||
|
||
self.balance_amount_0_days = {}
|
||
self.balance_amount_001_days = {}
|
||
self.balance_amount_01_days = {}
|
||
self.balance_amount_1_days = {}
|
||
self.balance_amount_10_days = {}
|
||
self.balance_amount_100_days = {}
|
||
self.balance_amount_1000_days = {}
|
||
self.balance_amount_10000_days = {}
|
||
|
||
'''
|
||
self.current_dt = time.time()
|
||
self.current_dt2 = time.gmtime(int(self.current_dt))
|
||
self.current_daystr = time.strftime("%d %b %Y", self.current_dt2)
|
||
self.current_dayutc = int(time.mktime(time.strptime(self.current_daystr, "%d %b %Y")))
|
||
'''
|
||
|
||
self.mc = pymongo.MongoClient("mongodb://10.168.3.192:27018/")
|
||
self.mdb = self.mc["btcutxos2"]
|
||
# self.mdb.authenticate("root", "123456")
|
||
|
||
self.uprofit = 0
|
||
self.uloss = 0
|
||
self.lth_nupl = 0
|
||
self.sth_nupl = 0
|
||
self.lth_mv = 0
|
||
self.sth_mv = 0
|
||
self.lth_rcap = 0
|
||
self.sth_rcap = 0
|
||
self.lth_mvrv = 0
|
||
self.sth_mvrv = 0
|
||
# 此“UtxosIf”类使用默认值初始化大量属性。以下是属性的摘要：
|
||
#
|
||
# - 与平衡相关的属性：
|
||
# - 'balance_0'， 'balance_001'， ...， 'balance_10000'：这些是不同面额比特币的余额计数器。
|
||
# - 'balance_amount_0'， 'balance_amount_001'， ...， 'balance_amount_10000'：这些是与余额计数器相对应的余额金额。
|
||
#
|
||
# - 与地址和利润相关的属性：
|
||
# - 'profit_addresses'：利润计数器地址。
|
||
# - 'loss_addresses'： 丢失地址的计数器。
|
||
# - 与利润率、供应、已实现价格等相关的各种其他属性
|
||
#
|
||
#
|
||
# - 与持有人及其余额相关的属性：
|
||
# - 不同时间间隔的持有者计数器（'holder_0'、'holder_1'、...、'holder_3960'）。
|
||
# - 每个持有人的相应余额属性。
|
||
#
|
||
# - 与价格和交易相关的属性：
|
||
# - 用于存储价格和交易金额的字典（'price_buy'、'price_buy_amount'、'diff_sell'、'diff_sell_amount'、'profit_sell'、'profit_sell_amount'）。
|
||
#
|
||
# - 与余额随时间变化相关的属性：
|
||
# - 用于存储不同时间间隔的余额变化的字典（'balance_0_days'、'balance_001_days'、...、'balance_amount_10000_days'）。
|
||
#
|
||
# - 与
|
||
# MongoDB
|
||
# 连接和其他指标相关的属性：
|
||
# - 连接到MongoDB数据库（'mc'，'mdb'）。
|
||
# - 与利润、亏损、已实现资本化等相关的指标
|
||
#
|
||
# 此类似乎用于管理与比特币UTXO（未花费的交易输出）相关的各种指标和数据
|
||
def init_db(self):
|
||
return pymysql.connect(host="172.17.0.1", port=4419, user="root", password="IeQcJNnagkaFP1Or", database="btcdb",
|
||
cursorclass=pymysql.cursors.DictCursor)
|
||
# 'init_dbpymysql库来建立连接。
|
||
#
|
||
# 以下是该方法的作用的细分
|
||
#
|
||
# 它使用提供的主机、端口、用户名、密码和数据库名称建立与
|
||
# MySQL
|
||
# 数据库的连接。
|
||
def get_vout_addr(self, rpc, txid, vout):
|
||
addr = None
|
||
addrtype = None
|
||
ip = "127.0.0.1"
|
||
port = " 8332"
|
||
user = "user"
|
||
password = "password"
|
||
if rpc is None:
|
||
rpc = RPC(ip, port, user, password)
|
||
tx = None
|
||
while True:
|
||
try:
|
||
tx = rpc.transactions.get_raw_transaction(txid, True)
|
||
#break
|
||
except:
|
||
time.sleep(1)
|
||
#print("reconnect")
|
||
rpc = RPC(ip, port, user, password)
|
||
continue
|
||
|
||
txouts = tx["vout"]
|
||
txout = None
|
||
for outone in txouts:
|
||
# print(outone, vout)
|
||
if outone["n"] == vout:
|
||
txout = outone
|
||
break
|
||
scriptPubKey = txout["scriptPubKey"]
|
||
addrtype = scriptPubKey["type"]
|
||
|
||
#print("get_vout_addr", txid, vout, tx, scriptPubKey, addrtype)
|
||
if "address" not in scriptPubKey:
|
||
addr = scriptPubKey["hex"]
|
||
if scriptPubKey["type"] == "pubkey":
|
||
temphex = scriptPubKey["hex"]
|
||
try:
|
||
if temphex[2:4] == "04":
|
||
addr = PublicKey(temphex[2:132]).get_address(False).to_string()
|
||
else:
|
||
addr = PublicKey(temphex[2:68]).get_address().to_string()
|
||
print("pubkey", txid, temphex, addr)
|
||
except Exception as e:
|
||
print("pubkey exception", txid, vout, temphex, addr, e)
|
||
else:
|
||
print(scriptPubKey)
|
||
else:
|
||
addr = scriptPubKey["address"]
|
||
# print(addr)
|
||
|
||
break
|
||
|
||
return rpc, addr, addrtype
|
||
# “UtxosIf”类中的“get_vout_addr”方法旨在检索与给定事务 （txid） 中的特定事务输出 （vout） 相对应的地址和地址类型。以下是其功能的细分：
|
||
#
|
||
# -参数：
|
||
# - 'rpc'：用于与比特币网络交互的 RPC 类的实例。
|
||
# - 'txid'：交易 ID。
|
||
# - 'vout'：事务输出的索引。
|
||
#
|
||
# -初始化：
|
||
# - 它初始化用于 RPC 连接的 IP 地址、端口、用户名和密码的变量。
|
||
#
|
||
# - RPC连接：
|
||
# - 如果 'rpc' 参数为 'None'，则使用默认 IP、端口、用户名和密码初始化 RPC 连接。
|
||
#
|
||
# - 交易检索：
|
||
# - 它尝试使用 'get_raw_transaction' 方法从 RPC 对象中检索原始事务详细信息。
|
||
# - 如果在此过程中出现异常（可能是由于连接问题），它会等待 1 秒钟并重试。
|
||
#
|
||
# - 提取地址：
|
||
# - 一旦获得交易详细信息，它就会遍历交易的输出（'vout'）以找到特定的输出。
|
||
# - 它从输出中提取“scriptPubKey”及其类型。
|
||
# - 如果“scriptPubKey”不直接包含地址，它会尝试解析它（例如，如果它是一个公钥脚本）。
|
||
#
|
||
# - 返回结果：
|
||
# - 最后，它返回 RPC 实例、地址和地址类型。
|
||
#
|
||
# 方法如下：
|
||
#
|
||
# '''蟒蛇
|
||
# def get_vout_addr（self、rpc、txid、vout）：
|
||
# addr = 无
|
||
# addrtype = 无
|
||
# ip = “127.0.0.1”
|
||
# 端口 =“8332”
|
||
# user = “用户”
|
||
# password = “密码”
|
||
# 如果 rpc 为 None：
|
||
# rpc = RPC（ip， port， user， password）
|
||
# tx = 无
|
||
# 而 True：
|
||
# 尝试：
|
||
# tx = rpc.transactions.get_raw_transaction（txid， 真）
|
||
# 除了：
|
||
# 时间睡眠（1）
|
||
# rpc = RPC（ip， port， user， password）
|
||
# 继续
|
||
#
|
||
# txouts = tx[“vout”]
|
||
# txout = 无
|
||
# 对于 TXOUTS 中的 Outone：
|
||
# if outone[“n”] == vout：
|
||
# txout = outone
|
||
# 破
|
||
# scriptPubKey = txout[“scriptPubKey”]
|
||
# addrtype = scriptPubKey[“类型”]
|
||
#
|
||
# 如果 “address” 不在 scriptPubKey 中：
|
||
# addr = scriptPubKey[“十六进制”]
|
||
# if scriptPubKey[“type”] == “pubkey”：
|
||
# temphex = scriptPubKey[“十六进制”]
|
||
# 尝试：
|
||
# 如果 temphex[2：4] == “04”：
|
||
# addr = PublicKey（temphex[2：132]）.get_address（False）.to_string（）
|
||
# 还：
|
||
# addr = PublicKey（temphex[2：68]）.get_address（）.to_string（）
|
||
# print（“pubkey”， txid， temphex， addr）
|
||
# 除了 Exception as e：
|
||
# print（“pubkey exception”， txid， vout， temphex， addr， e）
|
||
# 还：
|
||
# print（scriptPubKey）
|
||
# 还：
|
||
# addr = scriptPubKey[“地址”]
|
||
#
|
||
# 破
|
||
#
|
||
# 返回 RPC、ADDR、ADdrType
|
||
# '''
|
||
#
|
||
# 此方法可确保从事务输出中正确提取地址和地址类型，从而处理检索过程中的潜在错误
|
||
def summary_toplist(self, txid, vout, coinbase, value, height, scriptpubkey, dt, price, dt2):
|
||
if value >= 100:
|
||
rpc = None
|
||
rpc, addr, addrtype = self.get_vout_addr(rpc, txid, vout)
|
||
if addrtype is None:
|
||
addrtype = "unknown"
|
||
if addr is None:
|
||
addr = "unknown"
|
||
toplist = {}
|
||
toplist["txid"] = txid
|
||
toplist["vout"] = vout
|
||
toplist["coinbase"] = coinbase
|
||
toplist["value"] = value
|
||
toplist["height"] = height
|
||
toplist["scriptpubkey"] = scriptpubkey
|
||
toplist["dt"] = dt
|
||
toplist["price"] = price
|
||
toplist["dt2"] = dt2
|
||
toplist["addr"] = addr
|
||
toplist["type"] = addrtype
|
||
|
||
result = self.mdbc_toplist.find_one(toplist)
|
||
if result is None or len(result) > 0:
|
||
|
||
self.mdbc_toplist.insert_one(toplist)
|
||
#print(self.mdbc_toplist.find_one())
|
||
# 该类中的方法似乎用于汇总和存储有关满足特定条件的事务的信息。以下是该方法的作用：summary_toplistUtxosIf
|
||
#
|
||
# 它需要与交易相关的几个参数（、、、）。txidvoutcoinbasevalueheightscriptpubkeydtpricedt2
|
||
# 它首先检查事务输出 （） 的值是否大于或等于100。value
|
||
# 如果该值满足条件，则将变量初始化为None。rpc
|
||
# 然后，它调用该方法来检索与事务输出对应的地址和地址类型。get_vout_addr
|
||
# 它创建一个名为的字典，其中包含有关交易的各种信息，包括其ID、输出索引、是否是
|
||
# coinbase交易、其值、区块高度、scriptPubKey、日期时间信息、价格、地址和地址类型。toplist
|
||
# 它检查MongoDB集合中是否存在具有相同事务ID和输出索引的记录。如果没有，它会将字典插入到集合中。mdbc_toplisttoplist
|
||
def summary_balance_days(self, dt, dt2, value, days_out, balance_out):
|
||
daysecs = 3600 * 24
|
||
days = (dt - dt2)/daysecs
|
||
if days < 1:
|
||
if "day_0" in days_out:
|
||
days_out["day_0"]+=1
|
||
balance_out["day_0"] += value
|
||
else:
|
||
days_out["day_0"]=1
|
||
balance_out["day_0"] = value
|
||
elif days < 1 * 2:
|
||
if "day_1" in days_out:
|
||
days_out["day_1"] += 1
|
||
balance_out["day_1"] += value
|
||
else:
|
||
days_out["day_1"] = 1
|
||
balance_out["day_1"] = value
|
||
elif days < 1 * 3:
|
||
if "day_2" in days_out:
|
||
days_out["day_2"] += 1
|
||
balance_out["day_2"] += value
|
||
else:
|
||
days_out["day_2"] = 1
|
||
balance_out["day_2"] = value
|
||
elif days < 1 * 4:
|
||
if "day_3" in days_out:
|
||
days_out["day_3"] += 1
|
||
balance_out["day_3"] += value
|
||
else:
|
||
days_out["day_3"] = 1
|
||
balance_out["day_3"] = value
|
||
elif days < 1 * 5:
|
||
if "day_4" in days_out:
|
||
days_out["day_4"] += 1
|
||
balance_out["day_4"] += value
|
||
else:
|
||
days_out["day_4"] = 1
|
||
balance_out["day_4"] = value
|
||
elif days < 1 * 6:
|
||
if "day_5" in days_out:
|
||
days_out["day_5"] += 1
|
||
balance_out["day_5"] += value
|
||
else:
|
||
days_out["day_5"] = 1
|
||
balance_out["day_5"] = value
|
||
elif days < 1 * 7:
|
||
if "day_6" in days_out:
|
||
days_out["day_6"] += 1
|
||
balance_out["day_6"] += value
|
||
else:
|
||
days_out["day_6"] = 1
|
||
balance_out["day_6"] = value
|
||
elif days < 1 * 8:
|
||
if "day_7" in days_out:
|
||
days_out["day_7"] += 1
|
||
balance_out["day_7"] += value
|
||
else:
|
||
days_out["day_7"] = 1
|
||
balance_out["day_7"] = value
|
||
elif days < 1 * 9:
|
||
if "day_8" in days_out:
|
||
days_out["day_8"] += 1
|
||
balance_out["day_8"] += value
|
||
else:
|
||
days_out["day_8"] = 1
|
||
balance_out["day_8"] = value
|
||
elif days < 1 * 10:
|
||
if "day_9" in days_out:
|
||
days_out["day_9"] += 1
|
||
balance_out["day_9"] += value
|
||
else:
|
||
days_out["day_9"] = 1
|
||
balance_out["day_9"] = value
|
||
elif days < 1 * 11:
|
||
if "day_10" in days_out:
|
||
days_out["day_10"] += 1
|
||
balance_out["day_10"] += value
|
||
else:
|
||
days_out["day_10"] = 1
|
||
balance_out["day_10"] = value
|
||
elif days < 1 * 12:
|
||
if "day_11" in days_out:
|
||
days_out["day_11"] += 1
|
||
balance_out["day_11"] += value
|
||
else:
|
||
days_out["day_11"] = 1
|
||
balance_out["day_11"] = value
|
||
elif days < 1 * 13:
|
||
if "day_12" in days_out:
|
||
days_out["day_12"] += 1
|
||
balance_out["day_12"] += value
|
||
else:
|
||
days_out["day_12"] = 1
|
||
balance_out["day_12"] = value
|
||
elif days < 1 * 14:
|
||
if "day_13" in days_out:
|
||
days_out["day_13"] += 1
|
||
balance_out["day_13"] += value
|
||
else:
|
||
days_out["day_13"] = 1
|
||
balance_out["day_13"] = value
|
||
elif days < 1 * 15:
|
||
if "day_14" in days_out:
|
||
days_out["day_14"] += 1
|
||
balance_out["day_14"] += value
|
||
else:
|
||
days_out["day_14"] = 1
|
||
balance_out["day_14"] = value
|
||
elif days < 1 * 16:
|
||
if "day_15" in days_out:
|
||
days_out["day_15"] += 1
|
||
balance_out["day_15"] += value
|
||
else:
|
||
days_out["day_15"] = 1
|
||
balance_out["day_15"] = value
|
||
elif days < 1 * 17:
|
||
if "day_16" in days_out:
|
||
days_out["day_16"] += 1
|
||
balance_out["day_16"] += value
|
||
else:
|
||
days_out["day_16"] = 1
|
||
balance_out["day_16"] = value
|
||
elif days < 1 * 18:
|
||
if "day_17" in days_out:
|
||
days_out["day_17"] += 1
|
||
balance_out["day_17"] += value
|
||
else:
|
||
days_out["day_17"] = 1
|
||
balance_out["day_17"] = value
|
||
elif days < 1 * 19:
|
||
if "day_18" in days_out:
|
||
days_out["day_18"] += 1
|
||
balance_out["day_18"] += value
|
||
else:
|
||
days_out["day_18"] = 1
|
||
balance_out["day_18"] = value
|
||
elif days < 1 * 20:
|
||
if "day_19" in days_out:
|
||
days_out["day_19"] += 1
|
||
balance_out["day_19"] += value
|
||
else:
|
||
days_out["day_19"] = 1
|
||
balance_out["day_19"] = value
|
||
elif days < 1 * 21:
|
||
if "day_20" in days_out:
|
||
days_out["day_20"] += 1
|
||
balance_out["day_20"] += value
|
||
else:
|
||
days_out["day_20"] = 1
|
||
balance_out["day_20"] = value
|
||
elif days < 1 * 22:
|
||
if "day_21" in days_out:
|
||
days_out["day_21"] += 1
|
||
balance_out["day_21"] += value
|
||
else:
|
||
days_out["day_21"] = 1
|
||
balance_out["day_21"] = value
|
||
elif days < 1 * 23:
|
||
if "day_22" in days_out:
|
||
days_out["day_22"] += 1
|
||
balance_out["day_22"] += value
|
||
else:
|
||
days_out["day_22"] = 1
|
||
balance_out["day_22"] = value
|
||
elif days < 1 * 24:
|
||
if "day_23" in days_out:
|
||
days_out["day_23"] += 1
|
||
balance_out["day_23"] += value
|
||
else:
|
||
days_out["day_23"] = 1
|
||
balance_out["day_23"] = value
|
||
elif days < 1 * 25:
|
||
if "day_24" in days_out:
|
||
days_out["day_24"] += 1
|
||
balance_out["day_24"] += value
|
||
else:
|
||
days_out["day_24"] = 1
|
||
balance_out["day_24"] = value
|
||
elif days < 1 * 26:
|
||
if "day_25" in days_out:
|
||
days_out["day_25"] += 1
|
||
balance_out["day_25"] += value
|
||
else:
|
||
days_out["day_25"] = 1
|
||
balance_out["day_25"] = value
|
||
elif days < 1 * 27:
|
||
if "day_26" in days_out:
|
||
days_out["day_26"] += 1
|
||
balance_out["day_26"] += value
|
||
else:
|
||
days_out["day_26"] = 1
|
||
balance_out["day_26"] = value
|
||
elif days < 1 * 28:
|
||
if "day_27" in days_out:
|
||
days_out["day_27"] += 1
|
||
balance_out["day_27"] += value
|
||
else:
|
||
days_out["day_27"] = 1
|
||
balance_out["day_27"] = value
|
||
elif days < 1 * 29:
|
||
if "day_28" in days_out:
|
||
days_out["day_28"] += 1
|
||
balance_out["day_28"] += value
|
||
else:
|
||
days_out["day_28"] = 1
|
||
balance_out["day_28"] = value
|
||
elif days < 1 * 30:
|
||
if "day_29" in days_out:
|
||
days_out["day_29"] += 1
|
||
balance_out["day_29"] += value
|
||
else:
|
||
days_out["day_29"] = 1
|
||
balance_out["day_29"] = value
|
||
elif days < 1 * 31:
|
||
if "day_30" in days_out:
|
||
days_out["day_30"] += 1
|
||
balance_out["day_30"] += value
|
||
else:
|
||
days_out["day_30"] = 1
|
||
balance_out["day_30"] = value
|
||
elif days < 1 * 60:
|
||
if "day_60" in days_out:
|
||
days_out["day_60"] += 1
|
||
balance_out["day_60"] += value
|
||
else:
|
||
days_out["day_60"] = 1
|
||
balance_out["day_60"] = value
|
||
elif days < 1 * 90:
|
||
if "day_90" in days_out:
|
||
days_out["day_90"] += 1
|
||
balance_out["day_90"] += value
|
||
else:
|
||
days_out["day_90"] = 1
|
||
balance_out["day_90"] = value
|
||
elif days < 1 * 180:
|
||
if "day_180" in days_out:
|
||
days_out["day_180"] += 1
|
||
balance_out["day_180"] += value
|
||
else:
|
||
days_out["day_180"] = 1
|
||
balance_out["day_180"] = value
|
||
elif days < 1 * 360:
|
||
if "day_360" in days_out:
|
||
days_out["day_360"] += 1
|
||
balance_out["day_360"] += value
|
||
else:
|
||
days_out["day_360"] = 1
|
||
balance_out["day_360"] = value
|
||
elif days < 1 * 540:
|
||
if "day_540" in days_out:
|
||
days_out["day_540"] += 1
|
||
balance_out["day_540"] += value
|
||
else:
|
||
days_out["day_540"] = 1
|
||
balance_out["day_540"] = value
|
||
elif days < 1 * 720:
|
||
if "day_720" in days_out:
|
||
days_out["day_720"] += 1
|
||
balance_out["day_720"] += value
|
||
else:
|
||
days_out["day_720"] = 1
|
||
balance_out["day_720"] = value
|
||
elif days < 1 * 1080:
|
||
if "day_1080" in days_out:
|
||
days_out["day_1080"] += 1
|
||
balance_out["day_1080"] += value
|
||
else:
|
||
days_out["day_1080"] = 1
|
||
balance_out["day_1080"] = value
|
||
elif days < 1 * 1440:
|
||
if "day_1440" in days_out:
|
||
days_out["day_1440"] += 1
|
||
balance_out["day_1440"] += value
|
||
else:
|
||
days_out["day_1440"] = 1
|
||
balance_out["day_1440"] = value
|
||
elif days < 1 * 1880:
|
||
if "day_1880" in days_out:
|
||
days_out["day_1880"] += 1
|
||
balance_out["day_1880"] += value
|
||
else:
|
||
days_out["day_1880"] = 1
|
||
balance_out["day_1880"] = value
|
||
elif days < 1 * 2160:
|
||
if "day_2160" in days_out:
|
||
days_out["day_2160"] += 1
|
||
balance_out["day_2160"] += value
|
||
else:
|
||
days_out["day_2160"] = 1
|
||
balance_out["day_2160"] = value
|
||
elif days < 1 * 2520:
|
||
if "day_2520" in days_out:
|
||
days_out["day_2520"] += 1
|
||
balance_out["day_2520"] += value
|
||
else:
|
||
days_out["day_2520"] = 1
|
||
balance_out["day_2520"] = value
|
||
elif days < 1 * 2880:
|
||
if "day_2880" in days_out:
|
||
days_out["day_2880"] += 1
|
||
balance_out["day_2880"] += value
|
||
else:
|
||
days_out["day_2880"] = 1
|
||
balance_out["day_2880"] = value
|
||
elif days < 1 * 3240:
|
||
if "day_3240" in days_out:
|
||
days_out["day_3240"] += 1
|
||
balance_out["day_3240"] += value
|
||
else:
|
||
days_out["day_3240"] = 1
|
||
balance_out["day_3240"] = value
|
||
elif days < 1 * 3600:
|
||
if "day_3600" in days_out:
|
||
days_out["day_3600"] += 1
|
||
balance_out["day_3600"] += value
|
||
else:
|
||
days_out["day_3600"] = 1
|
||
balance_out["day_3600"] = value
|
||
else:
|
||
if "day_3960" in days_out:
|
||
days_out["day_3960"] += 1
|
||
balance_out["day_3960"] += value
|
||
else:
|
||
days_out["day_3960"] = 1
|
||
balance_out["day_3960"] = value
|
||
return days_out, balance_out
|
||
# “summary_balance_days”功能似乎旨在根据持有余额的天数对余额进行分类。以下是其工作原理的细分：
|
||
#
|
||
# -参数：
|
||
# - 'dt'：当前日期。
|
||
# - “dt2”：获取余额的日期。
|
||
# - 'value'：余额的值。
|
||
# - 'days_out'：用于存储不同时期余额计数的字典。
|
||
# - 'balance_out'：存储不同时期累计余额的字典。
|
||
#
|
||
# - 计算天数：
|
||
# - 它通过从当前日期 （'dt'） 中减去购置日期 （'dt2'） 来计算余额持有的天数。此值存储在“days”变量中。
|
||
#
|
||
# - 对余额进行分类：
|
||
# - 根据计算的天数，该函数将余额分配给特定类别 （'day_X'），其中
|
||
# 'X'
|
||
# 表示天数。
|
||
# - 如果余额持有时间少于一天，则将其归类为“day_0”。
|
||
# - 如果余额已持有
|
||
# 1
|
||
# 到
|
||
# 30
|
||
# 天，则分别归类为“day_1”至“day_30”。
|
||
# - 如果余额已持有
|
||
# 31
|
||
# 到
|
||
# 60
|
||
# 天，则将其归类为“day_60”。
|
||
# - 如果余额已持有超过
|
||
# 3600
|
||
# 天（约
|
||
# 10
|
||
# 年），则将其归类为“day_3960”。
|
||
#
|
||
# - 累积余额：
|
||
# - 对于每个类别，该函数递增余额计数 （'days_out'） 并将余额值添加到累计余额 （'balance_out'）。
|
||
#
|
||
# - 返回结果：
|
||
# - 返回更新的“days_out”和“balance_out”字典。
|
||
# 0.01,0.1,1,10,100,1000,10000,total balance
|
||
# new addr, total address
|
||
def summary_utxos(self, current_price, txid, vout, coinbase, value, height, scriptpubkey, dt, price, dt2):
|
||
|
||
self.total_address += 1
|
||
self.total_balance += value
|
||
|
||
self.total_rcap += (value * price)
|
||
|
||
if coinbase == 1:
|
||
self.miner_address += 1
|
||
self.miner_balance += value
|
||
|
||
if current_price > price:
|
||
self.uprofit +=(value*(current_price-price))
|
||
self.profit_addresses += 1
|
||
if current_price <= price:
|
||
self.uloss += (value*(price - current_price))
|
||
self.loss_addresses += 1
|
||
|
||
n = int(price / 1000)
|
||
n = n * 1000
|
||
|
||
keystr = "buy" + str(n)
|
||
if keystr in self.price_buy:
|
||
self.price_buy[keystr] += 1
|
||
else:
|
||
self.price_buy[keystr] = 1
|
||
|
||
keystr = "buy_amount" + str(n)
|
||
if keystr in self.price_buy_amount:
|
||
self.price_buy_amount[keystr] += value
|
||
else:
|
||
self.price_buy_amount[keystr] = value
|
||
|
||
diff = current_price - price
|
||
n = int(diff / 1000)
|
||
n = n * 1000
|
||
keystr = "diff" + str(n)
|
||
if keystr in self.diff_sell:
|
||
self.diff_sell[keystr] += 1
|
||
else:
|
||
self.diff_sell[keystr] = 1
|
||
|
||
keystr = "diff_amount" + str(n)
|
||
if keystr in self.diff_sell_amount:
|
||
self.diff_sell_amount[keystr] += value
|
||
else:
|
||
self.diff_sell_amount[keystr] = value
|
||
|
||
|
||
try:
|
||
profit = (current_price - price)/(price)*10
|
||
except:
|
||
profit = current_price*10
|
||
|
||
if int(profit) < 100:
|
||
n = int(profit)
|
||
keystr = "profit" + str(n)
|
||
if keystr in self.profit_sell:
|
||
self.profit_sell[keystr] += 1
|
||
else:
|
||
self.profit_sell[keystr] = 1
|
||
|
||
keystr = "profit_amount" + str(n)
|
||
if keystr in self.profit_sell_amount:
|
||
self.profit_sell_amount[keystr] += value
|
||
else:
|
||
self.profit_sell_amount[keystr] = value
|
||
else:
|
||
profit = profit/100
|
||
n = int(profit)
|
||
keystr = "profit10" + str(n)
|
||
if keystr in self.profit_sell:
|
||
self.profit_sell[keystr] += 1
|
||
else:
|
||
self.profit_sell[keystr] = 1
|
||
|
||
keystr = "profit_amount10" + str(n)
|
||
if keystr in self.profit_sell_amount:
|
||
self.profit_sell_amount[keystr] += value
|
||
else:
|
||
self.profit_sell_amount[keystr] = value
|
||
|
||
if value < 0.01:
|
||
self.balance_0 += 1
|
||
self.balance_amount_0 += value
|
||
self.balance_0_days, self.balance_amount_0_days = self.summary_balance_days(self.current_dayutc, dt2, value, self.balance_0_days,
|
||
self.balance_amount_0_days)
|
||
elif value < 0.1:
|
||
self.balance_001 += 1
|
||
self.balance_amount_001 += value
|
||
self.balance_001_days, self.balance_amount_001_days = self.summary_balance_days(self.current_dayutc, dt2, value,
|
||
self.balance_001_days,
|
||
self.balance_amount_001_days)
|
||
elif value < 1:
|
||
self.balance_01 += 1
|
||
self.balance_amount_01 += value
|
||
self.balance_01_days, self.balance_amount_01_days = self.summary_balance_days(self.current_dayutc, dt2, value, self.balance_01_days,
|
||
self.balance_amount_01_days)
|
||
elif value < 10:
|
||
self.balance_1 += 1
|
||
self.balance_amount_1 += value
|
||
self.balance_1_days, self.balance_amount_1_days = self.summary_balance_days(self.current_dayutc, dt2, value, self.balance_1_days,
|
||
self.balance_amount_1_days)
|
||
elif value < 100:
|
||
self.balance_10 += 1
|
||
self.balance_amount_10 += value
|
||
self.balance_10_days, self.balance_amount_10_days = self.summary_balance_days(self.current_dayutc, dt2, value, self.balance_10_days,
|
||
self.balance_amount_10_days)
|
||
elif value < 1000:
|
||
self.balance_100 += 1
|
||
self.balance_amount_100 += value
|
||
self.balance_100_days, self.balance_amount_100_days = self.summary_balance_days(self.current_dayutc, dt2, value,
|
||
self.balance_100_days,
|
||
self.balance_amount_100_days)
|
||
elif value < 10000:
|
||
self.balance_1000 += 1
|
||
self.balance_amount_1000 += value
|
||
self.balance_1000_days, self.balance_amount_1000_days = self.summary_balance_days(self.current_dayutc, dt2, value,
|
||
self.balance_1000_days,
|
||
self.balance_amount_1000_days)
|
||
else:
|
||
self.balance_10000 += 1
|
||
self.balance_amount_10000 += value
|
||
self.balance_10000_days, self.balance_amount_10000_days = self.summary_balance_days(self.current_dayutc, dt2, value,
|
||
self.balance_10000_days,
|
||
self.balance_amount_10000_days)
|
||
|
||
daysecs = 3600 * 24
|
||
|
||
if self.current_dayutc - dt2 >= 180 * daysecs:
|
||
if self.current_dayutc - dt2 <= 365 * daysecs:
|
||
self.slrv_6m1y += (value*price)
|
||
|
||
if self.current_dayutc - dt2 <= daysecs:
|
||
self.slrv_24h += (value*price)
|
||
|
||
if self.current_dayutc - dt2 >= 155*daysecs:
|
||
self.lth_nupl += (value*(current_price-price))
|
||
self.lth_rcap += (value*price)
|
||
self.lth_mv += (value*current_price)
|
||
self.lth_supply += value
|
||
if current_price > price:
|
||
self.lth_profit_supply += value
|
||
if current_price < price:
|
||
self.lth_loss_supply += value
|
||
else:
|
||
self.sth_nupl += (value*(price - current_price))
|
||
self.sth_rcap += (value * price)
|
||
self.sth_mv += (value * current_price)
|
||
self.sth_supply += value
|
||
if current_price > price:
|
||
self.sth_profit_supply += value
|
||
if current_price < price:
|
||
self.sth_loss_supply += value
|
||
|
||
if self.current_dayutc - dt2 < daysecs:
|
||
self.holder_0 += 1
|
||
self.holder_balance_0 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 2:
|
||
self.holder_1 += 1
|
||
self.holder_balance_1 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 3:
|
||
self.holder_2 += 1
|
||
self.holder_balance_2 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 4:
|
||
self.holder_3 += 1
|
||
self.holder_balance_3 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 5:
|
||
self.holder_4 += 1
|
||
self.holder_balance_4 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 6:
|
||
self.holder_5 += 1
|
||
self.holder_balance_5 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 7:
|
||
self.holder_6 += 1
|
||
self.holder_balance_6 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 8:
|
||
self.holder_7 += 1
|
||
self.holder_balance_7 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 15:
|
||
self.holder_15 += 1
|
||
self.holder_balance_15 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 30:
|
||
self.holder_30 += 1
|
||
self.holder_balance_30 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 60:
|
||
self.holder_60 += 1
|
||
self.holder_balance_60 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 90:
|
||
self.holder_90 += 1
|
||
self.holder_balance_90 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 180:
|
||
self.holder_180 += 1
|
||
self.holder_balance_180 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 360:
|
||
self.holder_360 += 1
|
||
self.holder_balance_360 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 540:
|
||
self.holder_540 += 1
|
||
self.holder_balance_540 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 720:
|
||
self.holder_720 += 1
|
||
self.holder_balance_720 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 1080:
|
||
self.holder_1080 += 1
|
||
self.holder_balance_1080 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 1440:
|
||
self.holder_1440 += 1
|
||
self.holder_balance_1440 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 1880:
|
||
self.holder_1800 += 1
|
||
self.holder_balance_1800 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 2160:
|
||
self.holder_2160 += 1
|
||
self.holder_balance_2160 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 2520:
|
||
self.holder_2520 += 1
|
||
self.holder_balance_2520 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 2880:
|
||
self.holder_2880 += 1
|
||
self.holder_balance_2880 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 3240:
|
||
self.holder_3240 += 1
|
||
self.holder_balance_3240 += value
|
||
elif self.current_dayutc - dt2 < daysecs * 3600:
|
||
self.holder_3600 += 1
|
||
self.holder_balance_3600 += value
|
||
else:
|
||
self.holder_3960 += 1
|
||
self.holder_balance_3960 += value
|
||
# “summary_utxos”功能似乎是用于分析交易及其相关余额的更大系统的一部分。以下是该函数的功能细分：
|
||
#
|
||
# - ** 更新计数器和总计： **
|
||
# - 'self.total_address'：递增
|
||
# 1
|
||
# 以计算地址总数。
|
||
# - “self.total_balance”：累积总余额。
|
||
# - 'self.total_rcap'：累计已实现的总资本化（余额 * 价格）。
|
||
# - “self.miner_address”和“self.miner_balance”：如果交易是
|
||
# coinbase
|
||
# 交易（“coinbase == 1”），则增加矿工地址计数并累积矿工余额。
|
||
#
|
||
# - ** 盈亏计算： **
|
||
# - 'self.uprofit'
|
||
# 和
|
||
# 'self.uloss'：如果当前价格分别高于或低于成交价格，则计算并累计未实现损益。
|
||
# - “self.profit_addresses”和“self.loss_addresses”：统计有未实现盈亏的地址。
|
||
#
|
||
# - ** 价格分析： **
|
||
# - 'n'：将价格四舍五入到最接近的千位。
|
||
# - 'keystr'：根据四舍五入的价格生成密钥。
|
||
# - 更新买入价格（“self.price_buy”）及其相应金额（“self.price_buy_amount”）的计数器。
|
||
# - 计算当前价格和交易价格之间的差额 （'diff'），将其四舍五入到最接近的千位，并更新价格差异计数器（'self.diff_sell'
|
||
# 和
|
||
# 'self.diff_sell_amount'）。
|
||
#
|
||
# - ** 利润百分比分析： **
|
||
# - 根据当前价格和交易价格之间的差额计算利润百分比（“利润”）。
|
||
# - 将利润分类为不同的范围，并相应地更新计数器（“self.profit_sell”和“self.profit_sell_amount”）。
|
||
#
|
||
# - ** 余额分类： **
|
||
# - 根据余额的值将余额分类为不同的范围，并相应地更新计数器。
|
||
# - 对于每个范围，更新地址计数 （'self.balance_X'） 和累计余额 （'self.balance_amount_X'） 的计数器。
|
||
#
|
||
# - ** 基于时间的分析： **
|
||
# - 分析余额被持有的时间（“self.summary_balance_days”）并相应地更新计数器。
|
||
#
|
||
# - ** 其他指标： **
|
||
# - 根据余额持有的时间长度更新各种指标，例如短期和长期已实现资本化、市场价值、供应、利润和损失。
|
||
#
|
||
# - ** 持有人分析： **
|
||
# - 根据持有余额的时间对持有人进行分类，并更新相应的计数器，以显示持有人的数量及其累计余额。
|
||
#
|
||
# 总体而言，此功能似乎提供了对交易数据的全面分析，包括与余额、价格、利润和持有人行为相关的各种指标。
|
||
def save_db(self):
|
||
db_conn = self.init_db()
|
||
with db_conn.cursor() as cursor:
|
||
|
||
sql_insert = 'REPLACE INTO `utxosv3` (`unixdt`, `total_address`, `total_balance`, `total_rcap`, `miner_address`,`miner_balance`, `balance_0`, `balance_001`, `balance_01`, `balance_1`, `balance_10`,`balance_100`, `balance_1000`, `balance_10000`, uprofit, uloss, lthnupl, sthnupl, lthmarketcap, lthrcap, sthmarketcap, sthrcap, lthmvrv, sthmvrv) VALUES (FROM_UNIXTIME(%s), %s, %s, %s, %s, %s,%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)'
|
||
cursor.execute(sql_insert, (
|
||
self.current_dayutc, self.total_address, self.total_balance, self.total_rcap, self.miner_address, self.miner_balance, self.balance_0,
|
||
self.balance_001,
|
||
self.balance_01, self.balance_1, self.balance_10, self.balance_100, self.balance_1000, self.balance_10000, self.uprofit, self.uloss, self.lth_nupl, self.sth_nupl, self.lth_mv, self.lth_rcap, self.sth_mv, self.sth_rcap, self.lth_mvrv, self.sth_mvrv))
|
||
sql_insert = 'REPLACE INTO `utxos3nd` (`unixdt`, `balance_amount_0`, `balance_amount_001`, `balance_amount_01`, `balance_amount_1`, `balance_amount_10`,`balance_amount_100`, `balance_amount_1000`, `balance_amount_10000`) VALUES (FROM_UNIXTIME(%s), %s, %s, %s, %s, %s,%s, %s, %s)'
|
||
cursor.execute(sql_insert, (
|
||
self.current_dayutc, self.balance_amount_0,
|
||
self.balance_amount_001,
|
||
self.balance_amount_01, self.balance_amount_1, self.balance_amount_10, self.balance_amount_100, self.balance_amount_1000,
|
||
self.balance_amount_10000))
|
||
sql_insert = 'REPLACE INTO `holder3` (`unixdt`,`holder_0`,`holder_1`,`holder_2`,`holder_3`,`holder_4`,`holder_5`,`holder_6`,`holder_7`,`holder_15`,`holder_30`,`holder_60`,`holder_90`,`holder_180`,`holder_360`,`holder_540`,`holder_720`,`holder_1080`,`holder_1440`,`holder_1800`,`holder_2160`,`holder_2520`,`holder_2880`,`holder_3240`,`holder_3600`,`holder_3960`) VALUES(FROM_UNIXTIME(%s), %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)'
|
||
cursor.execute(sql_insert, (
|
||
self.current_dayutc, self.holder_0, self.holder_1, self.holder_2, self.holder_3, self.holder_4, self.holder_5, self.holder_6, self.holder_7,
|
||
self.holder_15,
|
||
self.holder_30, self.holder_60, self.holder_90, self.holder_180, self.holder_360, self.holder_540, self.holder_720, self.holder_1080,
|
||
self.holder_1440,
|
||
self.holder_1800, self.holder_2160, self.holder_2520, self.holder_2880, self.holder_3240, self.holder_3600, self.holder_3960))
|
||
sql_insert = 'REPLACE INTO `holder_balance3` (`unixdt`,`holder_balance_0`,`holder_balance_1`,`holder_balance_2`,`holder_balance_3`,`holder_balance_4`,`holder_balance_5`,`holder_balance_6`,`holder_balance_7`,`holder_balance_15`,`holder_balance_30`,`holder_balance_60`,`holder_balance_90`,`holder_balance_180`,`holder_balance_360`,`holder_balance_540`,`holder_balance_720`,`holder_balance_1080`,`holder_balance_1440`,`holder_balance_1800`,`holder_balance_2160`,`holder_balance_2520`,`holder_balance_2880`,`holder_balance_3240`,`holder_balance_3600`,`holder_balance_3960`) VALUES(FROM_UNIXTIME(%s), %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)'
|
||
cursor.execute(sql_insert, (
|
||
self.current_dayutc, self.holder_balance_0, self.holder_balance_1, self.holder_balance_2, self.holder_balance_3,
|
||
self.holder_balance_4,
|
||
self.holder_balance_5, self.holder_balance_6, self.holder_balance_7, self.holder_balance_15,
|
||
self.holder_balance_30, self.holder_balance_60, self.holder_balance_90, self.holder_balance_180, self.holder_balance_360,
|
||
self.holder_balance_540, self.holder_balance_720, self.holder_balance_1080, self.holder_balance_1440,
|
||
self.holder_balance_1800, self.holder_balance_2160, self.holder_balance_2520, self.holder_balance_2880, self.holder_balance_3240,
|
||
self.holder_balance_3600, self.holder_balance_3960))
|
||
|
||
|
||
#v2
|
||
if self.loss_addresses > 0:
|
||
self.profit_ratio = self.profit_addresses/self.loss_addresses
|
||
if self.total_balance > 0:
|
||
self.realized_price = self.total_rcap/self.total_balance
|
||
if self.sth_loss_supply > 0:
|
||
self.sth_profit_ratio = self.sth_profit_supply/self.sth_loss_supply
|
||
if self.lth_loss_supply > 0:
|
||
self.lth_profit_ratio = self.lth_profit_supply / self.lth_loss_supply
|
||
if self.sth_profit_ratio > 0:
|
||
self.relative_lth_sth = self.lth_profit_ratio/self.sth_profit_ratio
|
||
if self.slrv_6m1y > 0:
|
||
self.slrv_ratio = self.slrv_24h/self.slrv_6m1y
|
||
|
||
sql_insert = 'REPLACE INTO `utxosv4` (`unixdt`,`profit_addresses`,`loss_addresses`,`profit_ratio`,`lth_supply`,`sth_supply`,`realized_price`,`relative_lth_sth`,`lth_profit_supply`,`lth_loss_supply`,`lth_profit_ratio`,`sth_profit_supply`,`sth_loss_supply`,`sth_profit_ratio`,`slrv_ratio`) VALUES(FROM_UNIXTIME(%s), %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)'
|
||
cursor.execute(sql_insert, (self.current_dayutc, self.profit_addresses, self.loss_addresses, self.profit_ratio, self.lth_supply, self.sth_supply, self.realized_price, self.relative_lth_sth, self.lth_profit_supply, self.lth_loss_supply, self.lth_profit_ratio, self.sth_profit_supply, self.sth_loss_supply, self.sth_profit_ratio, self.slrv_ratio))
|
||
db_conn.commit()
|
||
|
||
|
||
mc = pymongo.MongoClient("mongodb://10.168.3.192:27018/")
|
||
mdb = mc["btcutxos2"]
|
||
# mdb.authenticate("root", "123456")
|
||
|
||
self.price_buy["unixdt"] = int(self.current_dt)
|
||
mdbc_buy = mdb["buy"]
|
||
mdbc_buy.insert_one(self.price_buy)
|
||
print(mdbc_buy.find_one())
|
||
self.price_buy_amount["unixdt"] = int(self.current_dt)
|
||
mdbc_buy_amount = mdb["buy_amount"]
|
||
mdbc_buy_amount.insert_one(self.price_buy_amount)
|
||
print(mdbc_buy_amount.find_one())
|
||
|
||
self.diff_sell["unixdt"] = int(self.current_dt)
|
||
mdbc_diff = mdb["diff"]
|
||
mdbc_diff.insert_one(self.diff_sell)
|
||
print(mdbc_diff.find_one())
|
||
self.diff_sell_amount["unixdt"] = int(self.current_dt)
|
||
mdbc_diff_amount = mdb["diff_amount"]
|
||
mdbc_diff_amount.insert_one(self.diff_sell_amount)
|
||
print(mdbc_diff_amount.find_one())
|
||
|
||
self.profit_sell["unixdt"] = int(self.current_dt)
|
||
mdbc_profit = mdb["profit"]
|
||
mdbc_profit.insert_one(self.profit_sell)
|
||
print(mdbc_profit.find_one())
|
||
self.profit_sell_amount["unixdt"] = int(self.current_dt)
|
||
mdbc_profit_amount = mdb["profit_amount"]
|
||
mdbc_profit_amount.insert_one(self.profit_sell_amount)
|
||
print(mdbc_profit_amount.find_one())
|
||
|
||
self.balance_0_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_days = mdb["balance_0_days"]
|
||
mdbc_balance_days.insert_one(self.balance_0_days)
|
||
print(mdbc_balance_days.find_one())
|
||
self.balance_amount_0_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_amount_days = mdb["balance_amount_0_days"]
|
||
mdbc_balance_amount_days.insert_one(self.balance_amount_0_days)
|
||
print(mdbc_balance_amount_days.find_one())
|
||
|
||
self.balance_001_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_days = mdb["balance_001_days"]
|
||
mdbc_balance_days.insert_one(self.balance_001_days)
|
||
print(mdbc_balance_days.find_one())
|
||
self.balance_amount_001_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_amount_days = mdb["balance_amount_001_days"]
|
||
mdbc_balance_amount_days.insert_one(self.balance_amount_001_days)
|
||
print(mdbc_balance_amount_days.find_one())
|
||
|
||
self.balance_01_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_days = mdb["balance_01_days"]
|
||
mdbc_balance_days.insert_one(self.balance_01_days)
|
||
print(mdbc_balance_days.find_one())
|
||
self.balance_amount_01_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_amount_days = mdb["balance_amount_01_days"]
|
||
mdbc_balance_amount_days.insert_one(self.balance_amount_01_days)
|
||
print(mdbc_balance_amount_days.find_one())
|
||
|
||
self.balance_1_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_days = mdb["balance_1_days"]
|
||
mdbc_balance_days.insert_one(self.balance_1_days)
|
||
print(mdbc_balance_days.find_one())
|
||
self.balance_amount_1_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_amount_days = mdb["balance_amount_1_days"]
|
||
mdbc_balance_amount_days.insert_one(self.balance_amount_1_days)
|
||
print(mdbc_balance_amount_days.find_one())
|
||
|
||
self.balance_10_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_days = mdb["balance_10_days"]
|
||
mdbc_balance_days.insert_one(self.balance_10_days)
|
||
print(mdbc_balance_days.find_one())
|
||
self.balance_amount_10_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_amount_days = mdb["balance_amount_10_days"]
|
||
mdbc_balance_amount_days.insert_one(self.balance_amount_10_days)
|
||
print(mdbc_balance_amount_days.find_one())
|
||
|
||
self.balance_100_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_days = mdb["balance_100_days"]
|
||
mdbc_balance_days.insert_one(self.balance_100_days)
|
||
print(mdbc_balance_days.find_one())
|
||
self.balance_amount_100_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_amount_days = mdb["balance_amount_100_days"]
|
||
mdbc_balance_amount_days.insert_one(self.balance_amount_100_days)
|
||
print(mdbc_balance_amount_days.find_one())
|
||
|
||
self.balance_1000_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_days = mdb["balance_1000_days"]
|
||
mdbc_balance_days.insert_one(self.balance_1000_days)
|
||
print(mdbc_balance_days.find_one())
|
||
self.balance_amount_1000_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_amount_days = mdb["balance_amount_1000_days"]
|
||
mdbc_balance_amount_days.insert_one(self.balance_amount_1000_days)
|
||
print(mdbc_balance_amount_days.find_one())
|
||
|
||
self.balance_10000_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_days = mdb["balance_10000_days"]
|
||
mdbc_balance_days.insert_one(self.balance_10000_days)
|
||
print(mdbc_balance_days.find_one())
|
||
self.balance_amount_10000_days["unixdt"] = int(self.current_dt)
|
||
mdbc_balance_amount_days = mdb["balance_amount_10000_days"]
|
||
mdbc_balance_amount_days.insert_one(self.balance_amount_10000_days)
|
||
print(mdbc_balance_amount_days.find_one())
|
||
# “save_db”方法负责将分析期间收集的数据保存到数据库和MongoDB实例中。以下是它的作用的细分：
|
||
# - MySQL数据库： **
|
||
# - 使用'init_db'方法连接到MySQL数据库。
|
||
# - 使用SQL查询将记录插入或替换到多个表（'utxosv1'、'utxos2nd'、'holder'、'holder_balance'和'utxosv2'）中。这些表包含用于分析的各种指标和汇总数据。
|
||
# - ** MongoDB： **
|
||
# - 连接到MongoDB实例。
|
||
# - 将数据插入多个集合（'buy'、'buy_amount'、'diff'、'diff_amount'、'profit'、'profit_amount'、'balance_0_days'、'balance_amount_0_days'
|
||
# 等）中，以进行不同类型的分析。
|
||
# 对于MongoDB中的每个集合，该方法将数据插入到集合中，并打印插入的文档以进行验证。
|
||
# 此外，该方法还会计算和更新一些其他指标（如利润率、实现价格、短期和长期持有者的利润率、相对比率等），并将它们插入“utxosv2”表中。
|
||
# 总体而言，这种方法有助于将分析的数据存储到关系数据库 （MySQL） 和NoSQL数据库 （MongoDB） 中，从而便于检索和进一步分析。
|
||
def get_history_price(self):
|
||
prices = {}
|
||
response_price = requests.get(
|
||
'https://data.nasdaq.com/api/v3/datatables/QDL/BCHAIN?code=MKPRU;api_key=FZqXog4sR-b7cYnXcRVV')
|
||
if response_price.status_code == 200:
|
||
#print(response_price.content)
|
||
priceweb = ujson.loads(response_price.content)
|
||
if "datatable" in priceweb:
|
||
priceset = priceweb["datatable"]
|
||
if "data" in priceset:
|
||
pricedata = priceset["data"]
|
||
for price in pricedata:
|
||
daystr = price[1]
|
||
p = price[2]
|
||
dayutc = time.mktime(time.strptime(daystr, "%Y-%m-%d"))
|
||
prices[str(int(dayutc))] = float(p)
|
||
#print(price, int(dayutc), g_prices[str(int(dayutc))])
|
||
return prices
|
||
# “get_history_price”方法似乎用于从WebAPI终结点检索历史价格数据。以下是它的作用的细分：
|
||
# - 初始化一个空字典“prices”来存储历史价格数据。
|
||
# - 向指定的API端点发送HTTP GET请求，该端点可能提供历史比特币价格数据。
|
||
# - 检查响应状态代码是否为200（表示响应成功）。
|
||
# - 如果响应成功：
|
||
# - 使用“ujson”库解析JSON响应。
|
||
# - 检查解析的JSON响应中是否存在键'“dataset''。
|
||
# - 如果'“dataset”'存在：
|
||
# - 检索“data”' 字段，该字段可能包含历史价格数据点的列表。
|
||
# - 遍历列表中的每个价格数据点。
|
||
# - 使用'strptime'将日期字符串 （'daystr'） 解析为Unix时间戳 （'dayutc'）。
|
||
# - 将Unix 时间戳作为键存储在“prices”字典中，并将相应的price （'p'） 作为值。
|
||
# 最后，它返回包含历史价格数据的“prices”字典，其中Unix时间戳作为键，价格作为值
|
||
def get_history_price2(self, pricedict):
|
||
#pricedict = {}
|
||
dayt = time.gmtime()
|
||
daystr = time.strftime("%Y", dayt)
|
||
year = int(daystr)
|
||
end_year = year
|
||
while True:
|
||
url = ""
|
||
if end_year != year:
|
||
start_year = end_year
|
||
url = "https://data.messari.io/api/v1/assets/bitcoin/metrics/price/time-series?start="
|
||
else:
|
||
url = "https://data.messari.io/api/v1/assets/bitcoin/metrics/price/time-series?after=" + str(
|
||
year) + "-01-01&order=descending&interval=1d"
|
||
|
||
if end_year != year:
|
||
url = url + str(start_year) + "-01-01&end=" + str(end_year) + "-12-31&order=descending&interval=1d"
|
||
header_set = {}
|
||
header_set["x-messari-api-key"] = "aH2pyj5i4QGo1k1gLxXEbIJ5RJr+FYKLEWk6cRT6RuSc6lRY"
|
||
# header_set["Content-Type"] = "application/json"
|
||
print(header_set, url)
|
||
response_price = requests.get(url, headers=header_set)
|
||
# print(response_price)
|
||
if response_price.status_code == 200:
|
||
# print(response_price.content)
|
||
priceweb = ujson.loads(response_price.content)
|
||
if "data" in priceweb:
|
||
priceset = priceweb["data"]
|
||
if "values" in priceset:
|
||
valueset = priceset["values"]
|
||
if valueset is not None:
|
||
for supply in valueset:
|
||
dayutc = int(supply[0] / 1000)
|
||
s = supply[1]
|
||
ret_time = time.gmtime(dayutc)
|
||
ret_daystr = time.strftime("%d %b %Y", ret_time)
|
||
ret_dayutc = int(time.mktime(time.strptime(ret_daystr, "%d %b %Y")))
|
||
pricedict[str(ret_dayutc)] = float(s)
|
||
# print(s, dayutc, pricedict[str(dayutc)])
|
||
# break
|
||
else:
|
||
break
|
||
else:
|
||
break
|
||
end_year -= 1
|
||
time.sleep(2)
|
||
print(pricedict)
|
||
return pricedict
|
||
# 'get_history
|
||
# 初始化与时间相关的变量，包括当前年份。
|
||
# 进入一个循环，从当前年份开始，向后循环访问年份。
|
||
# 根据当前年份和端点构造一个URL，用于获取比特币价格数据。
|
||
# 向构造的URL发送HTTP
|
||
# GET请求，包括标头中的特定API密钥。
|
||
# 检查响应状态代码是否为
|
||
# 2
|
||
# 使用'u 解析 JSON 响应
|
||
# 从JSON响应中提取相关价格数据，并将其添加到“pricedict”
|
||
# 将时间戳转换为人类可读的日期字符串，然后转换回Unix时间戳，并将它们作为键存储在'pricedic 中
|
||
# 在发出下一个请求之前暂停执行2秒，以避免API过载。
|
||
# 继续此过程，直到遍历所有年份或发生错误。
|
||
# 最后，它返回“pricedict”
|
||
def get_current_price(self):
|
||
price = 0
|
||
try:
|
||
response_price = requests.get(
|
||
'https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT')
|
||
prices = ujson.loads(response_price.text)
|
||
price = float(prices["price"])
|
||
print(response_price.text, price)
|
||
response_price.close()
|
||
# print("price", price)
|
||
return price
|
||
except:
|
||
response_price = requests.get("https://api.coinpaprika.com/v1/tickers/btc-bitcoin")
|
||
prices = ujson.loads(response_price.text)
|
||
price = float(prices["quotes"]["USD"]["price"])
|
||
response_price.close()
|
||
return price
|
||
# 该函数似乎是一种从特定
|
||
# API端点检索比特币当前价格的方法。以下是其功能的细分：get_current_price
|
||
# 初始化默认值为0的变量。price
|
||
# 向指定的URL （） 发送HTTP
|
||
# GET请求，以获取当前以美元为单位的比特币价格。'https://bitcoinexplorer.org/api/price/usd'
|
||
# 检查响应状态代码是否为200，表示响应成功。
|
||
# 如果响应成功，它将打印响应文本（大概是当前价格），并在删除逗号并将其转换为浮点数后将其分配给变量。price
|
||
# 关闭响应对象。
|
||
# 打印检索到的价格以进行调试。
|
||
# 返回检索到的价格。
|
||
# 此函数实质上是从指定的API端点检索和处理当前比特币价格，并将其作为浮点数返回
|
||
def get_ht(self):
|
||
try:
|
||
with open('height_time.csv', mode='r') as f:
|
||
reader = csv.reader(f)
|
||
height_time = {rows[0]: rows[1] for rows in reader}
|
||
'''for key in height_time.keys():
|
||
print(key, height_time[key])
|
||
break'''
|
||
return height_time
|
||
return None
|
||
except:
|
||
return None
|
||
# 这get_ht函数似乎从名为“height_time.csv”
|
||
# 的CSV文件中读取数据并将其转换为字典，其中键取自第一列，值取自第二列。以下是其功能的细分：
|
||
# 尝试在读取模式下打开文件“height_time.csv”
|
||
# 初始化名为“height”的字典
|
||
# 使用“csv.reade”循环访问CSV文件中的每一行
|
||
# 构造一个字典，其中每个键值对对应于CSV文件中的一行，键取自第一列，值取自第二列。
|
||
# 返回“height_time
|
||
# 如果在文件读取或字典构造过程中发生异常，该函数将返回“无”
|
||
# 此函数实质上是从CSV文件中读取数据并将其作为字典返回，该字典可能在代码中的其他位置用于进一步处理或分析
|
||
def get_day_utc(self, utc_time):
|
||
t = time.gmtime(utc_time)
|
||
daystr = time.strftime("%d %b %Y", t)
|
||
dayutc = int(time.mktime(time.strptime(daystr, "%d %b %Y")))
|
||
return dayutc
|
||
# 该函数将
|
||
# UTC时间戳作为输入，并返回表示与该输入时间戳对应的一天 （00：00：00UTC） 开始的
|
||
# UTC时间戳。以下是其功能的细分：get_day_utc
|
||
# 它接收UTC时间戳作为输入。utc_time
|
||
# 它使用将UTC时间戳转换为时间元组。此元组表示UTC中的时间。time.gmtime()
|
||
# 它将时间元组格式化为一个字符串，以“DD Mon YYYY”
|
||
# （例如，“2022年1月1日”）表示日期。
|
||
# 它使用和将此格式化的字符串转换回UTC时间戳。这有效地将时间设置为同一天的
|
||
# 00：00：00UTC。time.strptime()
|
||
# time.mktime()
|
||
# 它返回表示一天开始的UTC时间戳。
|
||
# 总体而言，此函数可用于将任何UTC时间戳转换为UTC中相应日期的开始
|
||
def get_dh_height(self):
|
||
try:
|
||
with open('daily_height.csv', mode='r') as f:
|
||
reader = csv.reader(f)
|
||
daily_height = {rows[0]: rows[1] for rows in reader}
|
||
return daily_height
|
||
return None
|
||
except:
|
||
print("failed open daily_height.csv")
|
||
return None
|
||
# 该函数尝试从名为“daily_height.csv”的CSV
|
||
# 文件中读取数据，并将其转换为字典，其中键是日期，值是相应的高度。get_dh_height
|
||
# 其工作原理如下：
|
||
# 它尝试在读取模式下打开文件“daily_height.csv”。
|
||
# 如果文件已成功打开，它将使用函数读取其内容，该函数将返回
|
||
# CSV文件各行的可迭代对象。csv.reader()
|
||
# 然后，它将每行转换为键值对，其中第一列（索引0）表示日期，第二列（索引1）表示高度。这是使用字典理解来完成的。
|
||
# 返回生成的字典。daily_height
|
||
# 如果在此过程中发生任何错误（例如无法打开文件），它会打印一条消息指示失败并返回.
|
||
# None
|
||
# 此函数可用于从CSV文件中检索每日身高数据，以便在程序中进行进一步处理或分析
|
||
def get_dh_hash(self):
|
||
try:
|
||
with open('daily_height.csv', mode='r') as f:
|
||
reader = csv.reader(f)
|
||
daily_hash = {rows[0]: rows[2] for rows in reader}
|
||
return daily_hash
|
||
return None
|
||
except:
|
||
print("failed open daily_height.csv")
|
||
return None
|
||
# 该函数类似于 ，但它不是检索高度值，而是从同一个CSV
|
||
# 文件 “daily_height.csv” 中检索哈希值。get_dh_hashget_dh_height
|
||
# 以下是其工作原理的细分：
|
||
# 它尝试在读取模式下打开文件“daily_height.csv”。
|
||
# 如果文件已成功打开，它将使用函数读取其内容，该函数将返回
|
||
# CSV文件各行的可迭代对象。csv.reader()
|
||
# 然后，它将每行转换为键值对，其中第一列（索引0）表示日期，第三列（索引2）表示哈希值。这是使用字典理解来完成的。
|
||
# 返回生成的字典。daily_hash
|
||
# 如果在此过程中发生任何错误（例如无法打开文件），它会打印一条消息指示失败并返回.
|
||
# None与
|
||
# 一样，此函数可用于从CSV文件中检索每日哈希数据，以便在程序中进一步处理或分析。get_dh_height
|
||
def get_daily_height(self):
|
||
height = 1
|
||
last_dayutc = None
|
||
daily_height = self.get_dh_height()
|
||
daily_hash = self.get_dh_hash()
|
||
#print(daily_height)
|
||
#print(daily_hash)
|
||
if daily_height is None:
|
||
daily_height = {}
|
||
daily_hash = {}
|
||
else:
|
||
if len(daily_height) > 0:
|
||
item = daily_height.popitem()
|
||
#print(item, type(item[1]))
|
||
height = int(item[1])+1
|
||
daily_height[item[0]] = int(item[1])
|
||
|
||
ip = "127.0.0.1"
|
||
port = "8332"
|
||
user = "user"
|
||
password = "password"
|
||
|
||
rpc = RPC(ip, port, user, password)
|
||
while True:
|
||
try:
|
||
total_height = rpc.blockchain.get_block_count()
|
||
break
|
||
except Exception as e:
|
||
print(f"❌ get_block_count 超时或异常：{e}，重试中...")
|
||
time.sleep(3)
|
||
rpc = RPC(ip, port, user, password) # 重新建立连接
|
||
if height >= total_height:
|
||
return
|
||
prev_height = None
|
||
prev_hash = None
|
||
while True:
|
||
blockh = None
|
||
while True:
|
||
try:
|
||
blockh = rpc.blockchain.get_block_header(height, True)
|
||
#print(blockh)
|
||
break
|
||
except:
|
||
time.sleep(1)
|
||
#print("reconnect")
|
||
rpc = RPC(ip, port, user, password)
|
||
|
||
if blockh is not None:
|
||
block_time = blockh["time"]
|
||
block_height = blockh["height"]
|
||
block_hash = blockh["hash"]
|
||
dayutc = self.get_day_utc(block_time)
|
||
if last_dayutc is None:
|
||
last_dayutc = dayutc
|
||
print(dayutc, last_dayutc)
|
||
if dayutc != last_dayutc:
|
||
daily_height[str(last_dayutc)] = prev_height
|
||
daily_hash[str(last_dayutc)] = prev_hash
|
||
last_dayutc = dayutc
|
||
#print(dayutc, daily_height[str(dayutc)], daily_hash[str(dayutc)])
|
||
prev_height = block_height
|
||
prev_hash = block_hash
|
||
while True:
|
||
try:
|
||
total_height = rpc.blockchain.get_block_count()
|
||
if height == total_height:
|
||
break
|
||
else:
|
||
height += 1
|
||
print("next height " + str(height))
|
||
break
|
||
except:
|
||
time.sleep(1)
|
||
#print("reconnect")
|
||
rpc = RPC(ip, port, user, password)
|
||
|
||
if height == total_height:
|
||
break
|
||
|
||
with open('daily_height.csv', 'w') as f:
|
||
for key in daily_height.keys():
|
||
#print(key)
|
||
#print(daily_height[key])
|
||
#print(daily_hash[key])
|
||
f.write("%s, %s, %s\n" % (key, daily_height[key], daily_hash[key]))
|
||
f.close()
|
||
# 该函数负责从区块链中检索每日身高数据并将其存储在名为“daily_height.csv”的CSV文件中。其工作原理如下：
|
||
# get_daily_height
|
||
# 它使用默认值1初始化变量，并将其设置为 。heightlast_dayutcNone
|
||
# 它调用
|
||
# 和
|
||
# 函数以从CSV文件中检索任何现有的每日高度和哈希数据。如果数据不可用，它将初始化空字典。get_dh_heightget_dh_hash
|
||
# 如果存在现有的每日身高数据，它将检索最后一个条目，将身高递增1，并使用新的身高值更新字典。
|
||
# 它设置了与比特币区块链交互的RPC连接细节。
|
||
# 它使用RPC调用检索区块链的总高度。rpc.blockchain.get_block_count()
|
||
# 它进入一个循环来获取每个区块高度的区块头，直到达到区块链的总高度。
|
||
# 在循环中，如果RPC调用期间出现异常，它会尝试重新连接，从而处理网络问题。
|
||
# 对于成功获取的每个区块标头，它都会提取区块时间、高度、哈希值和UTC日。
|
||
# 如果UTC日发生更改，它会使用当天以前的高度和哈希值更新每日高度和哈希字典。
|
||
# 它将每日高度和哈希数据写入“daily_height.csv”文件。
|
||
# 一旦它处理了所有区块高度，直到区块链的总高度，该函数就会结束。
|
||
# 该功能使用最新的区块链信息有效地更新CSV文件中的每日高度和哈希数据，方便历史数据分析或程序内的其他目的。
|
||
def get_height_timestamp(self):
|
||
height = 0
|
||
height_time = self.get_ht()
|
||
if height_time is None:
|
||
height_time = {}
|
||
else:
|
||
height = len(height_time)
|
||
|
||
print("exist height", height)
|
||
|
||
ip = "127.0.0.1"
|
||
port = "8332"
|
||
user = "user"
|
||
password = "password"
|
||
|
||
rpc = RPC(ip, port, user, password)
|
||
while True:
|
||
try:
|
||
total_height = rpc.blockchain.get_block_count()
|
||
break
|
||
except Exception as e:
|
||
print(f"❌ get_block_count 超时或异常：{e}，重试中...")
|
||
time.sleep(10)
|
||
rpc = RPC(ip, port, user, password) # 重新建立连接
|
||
if height >= total_height:
|
||
return
|
||
#total_height = rpc.blockchain.get_block_count()
|
||
# print("last_height", total_height)
|
||
|
||
while True:
|
||
blockh = None
|
||
while True:
|
||
try:
|
||
blockh = rpc.blockchain.get_block_header(height, True)
|
||
#print(blockh)
|
||
break
|
||
except:
|
||
time.sleep(1)
|
||
print("reconnect")
|
||
rpc = RPC(ip, port, user, password)
|
||
|
||
if blockh is not None:
|
||
block_time = blockh["time"]
|
||
block_height = blockh["height"]
|
||
height_time[str(block_height)] = block_time
|
||
#print(str(block_height), height_time[str(block_height)])
|
||
|
||
while True:
|
||
try:
|
||
total_height = rpc.blockchain.get_block_count()
|
||
if height == total_height:
|
||
break
|
||
else:
|
||
height += 1
|
||
print("next height " + str(height))
|
||
break
|
||
except:
|
||
time.sleep(1)
|
||
#print("reconnect")
|
||
rpc = RPC(ip, port, user, password)
|
||
|
||
if height == total_height:
|
||
break
|
||
|
||
with open('height_time.csv', 'w') as f:
|
||
for key in height_time.keys():
|
||
f.write("%s, %s\n" % (key, height_time[key]))
|
||
f.close()
|
||
# 该函数从区块链中检索区块高度和相应的时间戳，并将它们存储在名为“height_time.csv”的CSV文件中。以下是其工作原理的细分：
|
||
# get_height_timestamp
|
||
# 它将变量初始化为0，并使用该函数检索现有的高度时间数据。如果不存在任何数据，则初始化一个空字典。heightget_ht
|
||
# 它设置了与比特币区块链交互的RPC连接细节。
|
||
# 它使用RPC调用检索区块链的总高度。rpc.blockchain.get_block_count()
|
||
# 如果存在现有的高度时间数据，则将变量设置为字典中的条目数。height
|
||
# 它进入一个循环来获取每个区块高度的区块头，直到达到区块链的总高度。
|
||
# 在循环中，如果RPC调用期间出现异常，它会尝试重新连接，从而处理网络问题。
|
||
# 对于每个成功获取的块头，它都会提取块时间和高度，并更新高度时间字典。
|
||
# 它将高度时间数据写入“height_time.csv”文件。
|
||
# 循环一直持续到它处理完所有区块高度，直到区块链的总高度。
|
||
# 该功能有效地将CSV文件中的高度时间数据更新为最新的区块链信息，方便程序内的历史数据分析或其他目的。
|
||
def handle_utxos(self, prices, ht, check_dayutc):
|
||
current_price = 0
|
||
#current_price = self.get_current_price()
|
||
#if current_price == 0:
|
||
# return
|
||
connin = sqlite3.connect("utxos.sqlite")
|
||
cin = connin.cursor()
|
||
cursorin = cin.execute("SELECT * from utxos")
|
||
|
||
#connout = sqlite3.connect("utxos.db")
|
||
#cout = connout.cursor()
|
||
#cout.execute('CREATE TABLE IF NOT EXISTS utxos(txid TEXT PRIMARY KEY NOT NULL, vout INT, value INT, coinbase INT, height INT, scriptpubkey TEXT, dt TIMESTAMP, price INT, dt2 TIMESTAMP)')
|
||
#connout.commit()
|
||
coin_idx = 0
|
||
rpc = None
|
||
for row in cursorin:
|
||
#print(row)
|
||
txid = row[0]
|
||
vout = row[1]
|
||
value = row[2]
|
||
coinbase = row[3]
|
||
height = row[4]
|
||
scriptpubkey = row[5]
|
||
dt = ht[str(height)]
|
||
#print(dt)
|
||
dt2 = time.gmtime(int(dt))
|
||
daystr = time.strftime("%d %b %Y", dt2)
|
||
dayutc = int(time.mktime(time.strptime(daystr, "%d %b %Y")))
|
||
price = 0
|
||
dayutc=dayutc-28800
|
||
current_price=current_price-28800
|
||
print("ceshi",str(dayutc))
|
||
print("ceshi2", str(current_price))
|
||
if str(dayutc) > str(check_dayutc):
|
||
continue
|
||
if str(dayutc) in prices:
|
||
price = int(prices[str(dayutc)])
|
||
else:
|
||
print("failed get tx price")
|
||
return
|
||
|
||
if str(check_dayutc) in prices:
|
||
current_price = int(prices[str(check_dayutc)])
|
||
else:
|
||
print("failed get check price")
|
||
return
|
||
|
||
value = value / 100000000
|
||
#print(self.current_dayutc, txid, value, coinbase, height, daystr, dayutc, price, current_price)
|
||
|
||
self.summary_utxos(current_price, txid, vout, coinbase, value, height, scriptpubkey, dt, price, dayutc)
|
||
self.summary_toplist(txid, vout, coinbase, value, height, scriptpubkey, dt, price, dayutc)
|
||
|
||
#sql_insert = 'INSERT INTO utxos VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
|
||
#insert_data = (txid, vout, value, coinbase, height, scriptpubkey, dt, price, dayutc)
|
||
#cout.execute(sql_insert, insert_data)
|
||
#if coin_idx % (1024 * 1024) == 0:
|
||
#print(coin_idx)
|
||
#connout.commit()
|
||
coin_idx+=1
|
||
#connout.commit()
|
||
if self.lth_rcap > 0:
|
||
self.lth_mvrv = self.lth_mv / self.lth_rcap
|
||
if self.sth_rcap > 0:
|
||
self.sth_mvrv = self.sth_mv / self.sth_rcap
|
||
self.save_db()
|
||
|
||
cin.close()
|
||
#cout.close()
|
||
connin.close()
|
||
#connout.close()
|
||
# 该方法似乎用于处理来自名为“utxos.sqlite”的
|
||
# SQLite
|
||
# 数据库的未使用的事务输出 （UTXO）。以下是其功能的细分：handle_utxos
|
||
# 它需要三个参数：（包含历史价格的字典）、（包含区块高度和时间戳的字典）和（检查价格的特定日期）。priceshtcheck_dayutc
|
||
# 它初始化为0和0。current_pricecoin_idx
|
||
# 它建立与SQLite
|
||
# 数据库的连接，并检索用于执行SQL查询的游标。
|
||
# 它循环访问从数据库提取的表中的每一行。utxos对于每一行，它提取各种属性，例如交易
|
||
# ID（）、输出索引 （）、值、是否是coinbase交易 （）、区块高度 （）、scriptPubKey （） 和时间戳 （）。txidvoutcoinbaseheightscriptpubkeydt
|
||
# 它将时间戳转换为人类可读的日期字符串，然后转换为UTC时间戳。dtdaystrdayutc
|
||
# 它从字典中获取与对应的历史价格，并将其分配给变量。dayutcpricesprice
|
||
# 它检查字典中是否存在 ，并将其相应的价格分配给 。check_dayutcpricescurrent_price
|
||
# 它将UTXO值除以1000000000以将其转换为比特币单位。
|
||
# 它调用和方法与相关参数来处理UTXO数据。summary_utxossummary_toplist
|
||
# 如有必要，根据某些条件进行计算。lth_mvrvsth_mvrv
|
||
# 最后，它调用该方法将处理后的数据保存到数据库中。save_db
|
||
# 它关闭游标和数据库连接。
|
||
# 此方法有效地处理来自SQLite数据库的UTXO的处理，执行必要的计算和更新，并将处理后的数据保存回数据库
|
||
def utxos(self, check_dayutc):
|
||
|
||
self.current_dt = check_dayutc
|
||
self.current_dt2 = time.gmtime(int(self.current_dt))
|
||
self.current_daystr = time.strftime("%d %b %Y", self.current_dt2)
|
||
self.current_dayutc = int(time.mktime(time.strptime(self.current_daystr, "%d %b %Y")))
|
||
|
||
topliststr = "toplist" + self.current_daystr
|
||
print(topliststr)
|
||
self.mdbc_toplist = self.mdb[topliststr]
|
||
|
||
# prices_temp = self.get_history_price()
|
||
# prices = self.get_history_price2(prices_temp)
|
||
prices_temp=btc_historical_price.prices_temp
|
||
prices=btc_historical_price.prices
|
||
'''for key in prices.keys():
|
||
print(key, prices[key])
|
||
break'''
|
||
print(prices)
|
||
if len(prices) <= 0:
|
||
print("failed get price")
|
||
return
|
||
ht = self.get_ht()
|
||
if ht is None:
|
||
print("failed get height and time")
|
||
return
|
||
|
||
self.handle_utxos(prices, ht, check_dayutc)
|
||
# 该方法似乎负责处理 表示的特定日期的未使用事务输出 （UTXO）。以下是其功能的摘要：utxoscheck_dayutc
|
||
#
|
||
# 它根据提供的 .check_dayutc
|
||
# 它使用 和 方法检索历史价格数据。get_history_priceget_history_price2
|
||
# 该方法从纳斯达克 API 检索历史比特币价格数据。get_history_price
|
||
# 该方法从 Messari API 检索其他历史价格数据。get_history_price2
|
||
# 它使用该方法检索高度和时间戳数据。get_ht
|
||
# 它调用该方法以使用检索到的价格和高度数据处理 UTXO。handle_utxos
|
||
# 该方法进一步与 SQLite 数据库交互以处理 UTXO 并执行必要的计算。handle_utxos
|
||
# 总体而言，该方法协调了获取历史价格和高度数据并使用它来处理特定日期的 UTXO 的过程。如果成功，它将使用处理后的 UTXO 数据更新相关数据库。utxos
|
||
if __name__ == '__main__':
|
||
if len(sys.argv) > 1:
|
||
check_dt = sys.argv[1]
|
||
stats = UtxosIf()
|
||
setup('mainnet')
|
||
stats.get_height_timestamp()
|
||
stats.get_daily_height()
|
||
daily_hash = stats.get_dh_hash()
|
||
#print(daily_hash)
|
||
if daily_hash is None:
|
||
print("failed get daily height")
|
||
else:
|
||
os.system("if [ -e utxos.dat ]; then rm utxos.dat; fi")
|
||
os.system("if [ -e utxos.sqlite ]; then rm utxos.sqlite; fi")
|
||
check_dayutc = int(time.mktime(time.strptime(check_dt, "%Y-%m-%d")))
|
||
cmd = "~/bitcoin-29.0/bin/bitcoin-cli -rpcuser=user -rpcpassword=password invalidateblock " + daily_hash[str(check_dayutc)]
|
||
os.system(cmd)
|
||
print("select ok")
|
||
time.sleep(60);
|
||
os.system("~/bitcoin-29.0/bin/bitcoin-cli -rpcuser=user -rpcpassword=password dumptxoutset ~/utxos.dat")
|
||
print("dumptxoutset ok")
|
||
time.sleep(60);
|
||
# os.system("./utxo_to_sqlite ./utxos.dat ./utxos.sqlite")
|
||
os.system("python3 ~/utxo_to_sqlite.py ~/utxos.dat ~/utxos.sqlite")
|
||
print("utxo_to_sqlite ok")
|
||
time.sleep(60);
|
||
stats.utxos(check_dayutc)
|
||
print("utxos stat ok")
|
||
cmd = "~/bitcoin-29.0/bin/bitcoin-cli -rpcuser=user -rpcpassword=password reconsiderblock " + daily_hash[str(check_dayutc)]
|
||
os.system(cmd)
|
||
print("reconsiderblock ok")
|
||
# 此脚本似乎基于命令行参数执行与比特币 UTXO（未花费的交易输出）相关的几个任务。以下是它的作用的细分：
|
||
# 1. 它检查脚本是否直接运行 （'__name__ == '__main__''）。
|
||
# 2. 它检查是否提供了命令行参数 （'len（sys.argv） > 1'）。
|
||
# 3. 它初始化“UtxosIf”类的实例，可能包含与处理 UTXO 相关的方法。
|
||
# 4. 它使用“设置”功能设置比特币网络（假设为“主网”）。
|
||
# 5. 它分别使用“get_height_timestamp”和“get_daily_height”方法检索高度和时间戳数据。
|
||
# 6. 它使用“get_dh_hash”方法获取每日哈希数据。
|
||
# 7. 如果每日哈希数据可用，则继续进行进一步操作：
|
||
# - 如果存在现有的“utxos.dat”和“utxos.sqlite”文件，它会删除它们。
|
||
# - 它使用比特币 CLI 命令“invalidateblock”使区块失效。
|
||
# - 它会等待一段时间（大概是网络处理区块失效）。
|
||
# - 它使用比特币CLI命令'dumptxoutset'转储UTXO集。
|
||
# - 它再次等待。
|
||
# - 它使用“utxo_to_sqlite”脚本将转储的 UTXO 数据转换为 SQLite 数据库。
|
||
# - 它使用“utxos”方法处理指定日期的 UTXO。
|
||
# - 它使用比特币 CLI 命令“reconsiderblock”重新考虑之前失效的区块。
|
||
# 8. 每个步骤都附有指示脚本进度的打印语句。
|
||
# 这个脚本似乎是一个更大的系统的一部分，该系统与比特币网络交互并执行与UTXO相关的任务。它严重依赖比特币核心软件和命令行界面（“bitcoin-cli”） |