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