def __init__(self, price_f_config, config_net, connection_net):
super().__init__(price_f_config, config_net, connection_net)
address_medianizer = self.options['networks'][self.config_network]['addresses']['MoCMedianizer']
address_pricefeed = self.options['networks'][self.config_network]['addresses']['PriceFeed']
address_mocstate = self.options['networks'][self.config_network]['addresses']['MoCState']
self.contract_medianizer = MoCMedianizer(network_manager,
contract_address=address_medianizer).from_abi()
self.contract_price_feed = PriceFeed(network_manager,
contract_address=address_pricefeed,
contract_address_moc_medianizer=address_medianizer).from_abi()
self.contract_moc_state = MoCState(network_manager,
contract_address=address_mocstate).from_abi()
from moneyonchain.manager import ConnectionManager
from moneyonchain.moc import MoCState
from moneyonchain.rdoc import RDOCMoCState
import datetime
import csv
import time
network = 'rdocMainnet'
connection_manager = ConnectionManager(network=network)
print("Connecting to %s..." % network)
print(
"Connected: {conectado}".format(conectado=connection_manager.is_connected))
if connection_manager.options['networks'][network]['app_mode'] == 'MoC':
moc_state = MoCState(connection_manager)
else:
moc_state = RDOCMoCState(connection_manager)
from_block = 2243000 # can be manually setting
to_block = 2244000 # can be manually setting
block_steps = 2880
block_skip = 120
hours_delta = 0
last_block_number = int(connection_manager.block_number)
if to_block <= 0:
to_block = last_block_number # last block number in the node
current_block = from_block
from moneyonchain.manager import ConnectionManager
from moneyonchain.moc import MoCState
network = 'mocMainnet2'
connection_manager = ConnectionManager(network=network)
print("Connecting to %s..." % network)
print(
"Connected: {conectado}".format(conectado=connection_manager.is_connected))
print("Connecting to MoCState")
moc_state = MoCState(connection_manager)
print("Bitcoin Price in USD: {0}".format(moc_state.bitcoin_price()))
print("Bitcoin Moving Average in USD: {0}".format(
moc_state.bitcoin_moving_average()))
print("Smoothing Factor: {0}".format(moc_state.smoothing_factor()))
"""
Connecting to mocMainnet2...
Connected: True
Connecting to MoCState
Bitcoin Price in USD: 9206.600000000000509579
Bitcoin Moving Average in USD: 8691.773665743441728397
Smoothing Factor: 0.009950249
Connecting to mocTestnet...
Connected: True
Connecting to MoCState
Bitcoin Price in USD: 9205.31
Bitcoin Moving Average in USD: 8881.279549746037722543
Smoothing Factor: 0.016528926
class PriceFeederJobMoC(PriceFeederJobBase):
def __init__(self, price_f_config, config_net, connection_net):
super().__init__(price_f_config, config_net, connection_net)
address_medianizer = self.options['networks'][self.config_network]['addresses']['MoCMedianizer']
address_pricefeed = self.options['networks'][self.config_network]['addresses']['PriceFeed']
address_mocstate = self.options['networks'][self.config_network]['addresses']['MoCState']
self.contract_medianizer = MoCMedianizer(network_manager,
contract_address=address_medianizer).from_abi()
self.contract_price_feed = PriceFeed(network_manager,
contract_address=address_pricefeed,
contract_address_moc_medianizer=address_medianizer).from_abi()
self.contract_moc_state = MoCState(network_manager,
contract_address=address_mocstate).from_abi()
def get_price(self):
return decimal.Decimal(self.price_source.prices_weighted_median())
def price_feed(self):
# now
now = datetime.datetime.now()
# price variation accepted
price_variation = self.options['networks'][self.config_network]['price_variation_write_blockchain']
# max time in seconds that price is valid
block_expiration = self.options['networks'][self.config_network]['block_expiration']
# get the last price we insert as a feeder
last_price = decimal.Decimal(self.last_price)
# get the price from oracle
#last_price_oracle = self.contract_medianizer.peek()[0]
last_price_oracle = self.contract_medianizer.price()
# calculate the price variation from the last price from oracle
price_variation_accepted = decimal.Decimal(price_variation) * last_price_oracle
min_price = abs(last_price_oracle - price_variation_accepted)
max_price = last_price_oracle + price_variation_accepted
price_no_precision = self.get_price()
# if the price is below the floor, I don't publish it
price_floor = self.options['networks'][self.config_network].get('price_floor', None)
if price_floor != None:
price_floor = str(price_floor)
ema = self.contract_moc_state.bitcoin_moving_average()
kargs = {'ema': float(ema)}
try:
price_floor = decimal.Decimal(str(eval(price_floor, kargs)))
except Exception as e:
raise ValueError('price_floor: {}'.format(e))
not_under_the_floor = not(price_floor and price_floor > price_no_precision)
# is outside the range so we need to write to blockchain
is_in_range = price_no_precision < min_price or price_no_precision > max_price
# is more than 5 minutes from the last write
is_in_time = (self.last_price_timestamp + datetime.timedelta(seconds=300) < now)
log.info("[PRICE FEED] ORACLE: [{0:.6f}] MIN: [{1:.6f}] MAX: [{2:.6f}] "
"NEW: [{3:.6f}] IS IN RANGE: [{4}] IS IN TIME: [{5}]".format(
last_price_oracle,
min_price,
max_price,
price_no_precision,
is_in_range,
is_in_time))
# IF is in range or not in range but is in time
if not_under_the_floor and (is_in_range or (not is_in_range and is_in_time)):
# set the precision to price
price_to_set = price_no_precision * 10 ** 18
# submit the value to contract
if not self.is_simulation:
self.contract_price_feed.post(price_to_set,
block_expiration=block_expiration)
else:
log.info("[PRICE FEED] SIMULATION POST! ")
# save the last price to compare
self.last_price = price_no_precision
# save the last timestamp to compare
self.last_price_timestamp = datetime.datetime.now()
return price_no_precision
def price_feed_backup(self):
""" Only start to work only when we dont have price """
if not self.contract_medianizer.compute()[1] or self.backup_writes > 0:
self.price_feed()
self.aws_put_metric_exception(1)
if self.backup_writes <= 0:
if 'backup_writes' in self.options:
self.backup_writes = self.options['backup_writes']
else:
self.backup_writes = 100
self.backup_writes -= 1
log.error("[BACKUP MODE ACTIVATED!] WRITE REMAINING:{0}".format(self.backup_writes))
else:
log.info("[NO BACKUP MODE ACTIVATED]")
from moneyonchain.manager import ConnectionManager
from moneyonchain.moc import MoCState
network = 'mocTestnet'
connection_manager = ConnectionManager(network=network)
print("Connecting to %s..." % network)
print("Connected: {conectado}".format(conectado=connection_manager.is_connected))
print("Connecting to MoCState")
moc_state = MoCState(connection_manager)
print("Bitcoin Price in USD: {0}".format(moc_state.bitcoin_price()))
print("Bitcoin Moving Average in USD: {0}".format(moc_state.bitcoin_moving_average()))
print("Days to settlement: {0}".format(moc_state.days_to_settlement()))
print("Global Coverage: {0}".format(moc_state.global_coverage()))
print("Bitpro Total Supply: {0}".format(moc_state.bitpro_total_supply()))
print("DOC Total Supply: {0}".format(moc_state.doc_total_supply()))
print("Implementation: {0}".format(moc_state.implementation()))
# MOC
count += 1
line = '| {0} | {1} | {2} | {3} |'.format(count, 'MOC', addresses['MoC'], moc_main.implementation())
lines.append(line)
# MoCConnector
count += 1
contract = MoCConnector(connection_manager)
line = '| {0} | {1} | {2} | {3} |'.format(count, 'MoCConnector', contract.address(),
contract.implementation())
lines.append(line)
# MoCState
count += 1
contract = MoCState(connection_manager)
line = '| {0} | {1} | {2} | {3} |'.format(count, 'MoCState', addresses['MoCState'],
contract.implementation())
lines.append(line)
# MoCConverter
contract = MoCConverter(connection_manager)
count += 1
line = '| {0} | {1} | {2} | {3} |'.format(count, 'MoCConverter', addresses['MoCConverter'],
contract.implementation())
lines.append(line)
# MoCSettlement
contract = MoCSettlement(connection_manager)
count += 1
line = '| {0} | {1} | {2} | {3} |'.format(count, 'MoCSettlement', addresses['MoCSettlement'],
from moneyonchain.manager import ConnectionManager
from moneyonchain.moc import MoCInrate, MoCState
network = 'mocTestnet'
connection_manager = ConnectionManager(network=network)
print("Connecting to %s..." % network)
print("Connected: {conectado}".format(conectado=connection_manager.is_connected))
moc_inrate = MoCInrate(connection_manager)
moc_state = MoCState(connection_manager)
print("BTCX Inrate")
print("===========")
# amount to mint
amount_value = 0.001
# get days to settlement from the contract
days_to_settlement = moc_state.days_to_settlement()
print("Interest of MINT {0} BTCX".format(amount_value))
interest_no_days = moc_inrate.btc2x_inrate_avg(amount_value, on_minting=True)
print("Current day to settlement: {0} Interest: {1}".format(days_to_settlement,
interest_no_days * days_to_settlement))
print("Current day to settlement: {0} Interest %: {1} %".format(days_to_settlement,
interest_no_days * days_to_settlement * 100))
print("Interest on minting...")
for day_to_sett in reversed(range(0, 30)):
from moneyonchain.manager import ConnectionManager
from moneyonchain.moc import MoCState
network = 'mocMainnet2'
connection_manager = ConnectionManager(network=network)
print("Connecting to %s..." % network)
print("Connected: {conectado}".format(conectado=connection_manager.is_connected))
print("Connecting to MoCState...")
moc_state = MoCState(connection_manager)
print("Max Mint BPRO setted: {0}".format(moc_state.max_mint_bpro()))
print("Max mint BPRO avalaible: {0}".format(moc_state.max_mint_bpro_available()))
def block_info(block):
network = 'mocMainnet2'
connection_manager = ConnectionManager(network=network)
#print("Connecting to %s..." % network)
#print("Connected: {conectado}".format(conectado=connection_manager.is_connected))
if connection_manager.options['networks'][network]['app_mode'] == 'MoC':
moc_state = MoCState(connection_manager)
else:
moc_state = RDOCMoCState(connection_manager)
n_block = int(block)
if isinstance(block, int):
n_block = int(connection_manager.block_number)
if n_block <= 0:
n_block = int(connection_manager.block_number)
hours_delta = 0
ts = connection_manager.block_timestamp(n_block)
dt = ts - datetime.timedelta(hours=hours_delta)
d_timestamp = dt.strftime("%Y-%m-%d %H:%M:%S")
d_info_data = dict()
d_info_data['blockNumber'] = n_block
d_info_data['Timestamp'] = d_timestamp
# bitcoin price
d_info_data['BTCprice'] = float(
moc_state.bitcoin_price(block_identifier=n_block))
# Moving average
d_info_data['EMAvalue'] = float(
moc_state.bitcoin_moving_average(block_identifier=n_block))
# days to settlement, 0 is the day of the settlement
d_info_data['daysToSettlement'] = int(
moc_state.days_to_settlement(block_identifier=n_block))
# bkt_0 Storage DOC
d_info_data['C0_getBucketNDoc'] = float(
moc_state.bucket_ndoc(str.encode('C0'), block_identifier=n_block))
# bkt_0 Storage BPro
d_info_data['C0_getBucketNBPro'] = float(
moc_state.bucket_nbpro(str.encode('C0'), block_identifier=n_block))
# bkt_0 Storage BTC
d_info_data['C0_getBucketNBTC'] = float(
moc_state.bucket_nbtc(str.encode('C0'), block_identifier=n_block))
# bkt_0 Storage InrateBag
d_info_data['C0_getInrateBag'] = float(
moc_state.get_inrate_bag(str.encode('C0'), block_identifier=n_block))
# bkt_0 Storage Coverage
d_info_data['C0_coverage'] = float(
moc_state.coverage(str.encode('C0'), block_identifier=n_block))
# bkt_0 Storage Leverage
d_info_data['C0_leverage'] = float(
moc_state.leverage(str.encode('C0'), block_identifier=n_block))
# bkt_2 Storage DOC
d_info_data['X2_getBucketNDoc'] = float(
moc_state.bucket_ndoc(str.encode('X2'), block_identifier=n_block))
# bkt_2 Storage BPro
d_info_data['X2_getBucketNBPro'] = float(
moc_state.bucket_nbpro(str.encode('X2'), block_identifier=n_block))
# bkt_2 Storage BTC
d_info_data['X2_getBucketNBTC'] = float(
moc_state.bucket_nbtc(str.encode('X2'), block_identifier=n_block))
# bkt_2 Inrate Bag
d_info_data['X2_getInrateBag'] = float(
moc_state.get_inrate_bag(str.encode('X2'), block_identifier=n_block))
# bkt_2 Coverage
d_info_data['X2_coverage'] = float(
moc_state.coverage(str.encode('X2'), block_identifier=n_block))
# bkt_2 Storage Leverage
d_info_data['X2_leverage'] = float(
moc_state.leverage(str.encode('X2'), block_identifier=n_block))
# Global Coverage
d_info_data['globalCoverage'] = float(
moc_state.global_coverage(block_identifier=n_block))
# Bitpro total supply in system
d_info_data['bproTotalSupply'] = float(
moc_state.bitpro_total_supply(block_identifier=n_block))
# All DOC in circulation
d_info_data['docTotalSupply'] = float(
moc_state.doc_total_supply(block_identifier=n_block))
# RBTC in sytem
d_info_data['rbtcInSystem'] = float(
moc_state.rbtc_in_system(block_identifier=n_block))
# BPro Tec price
d_info_data['bproTecPrice'] = float(
moc_state.bpro_tec_price(block_identifier=n_block))
# BTC2X Tec price
d_info_data['BTC2XTecPrice'] = float(
moc_state.btc2x_tec_price(str.encode('X2'), block_identifier=n_block))
return d_info_data