// Copyright (c) 2016-2024 The Hush developers
// Distributed under the GPLv3 software license, see the accompanying
// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
/******************************************************************************
* Copyright © 2014 - 2019 The SuperNET Developers . *
* *
* See the AUTHORS , DEVELOPER - AGREEMENT and LICENSE files at *
* the top - level directory of this distribution for the individual copyright *
* holder information and the developer policies on copyright and licensing . *
* *
* Unless otherwise agreed in a custom licensing agreement , no part of the *
* SuperNET software , including this file may be copied , modified , propagated *
* or distributed except according to the terms contained in the LICENSE file *
* *
* Removal or modification of this copyright notice is prohibited . *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# ifndef H_HUSHEVENTS_H
# define H_HUSHEVENTS_H
# include "hush_defs.h"
struct hush_event * hush_eventadd ( struct hush_state * sp , int32_t height , char * symbol , uint8_t type , uint8_t * data , uint16_t datalen )
{
struct hush_event * ep = 0 ; uint16_t len = ( uint16_t ) ( sizeof ( * ep ) + datalen ) ;
if ( sp ! = 0 & & SMART_CHAIN_SYMBOL [ 0 ] ! = 0 )
{
portable_mutex_lock ( & hush_mutex ) ;
ep = ( struct hush_event * ) calloc ( 1 , len ) ;
ep - > len = len ;
ep - > height = height ;
ep - > type = type ;
strcpy ( ep - > symbol , symbol ) ;
if ( datalen ! = 0 )
memcpy ( ep - > space , data , datalen ) ;
sp - > Hush_events = ( struct hush_event * * ) realloc ( sp - > Hush_events , ( 1 + sp - > Hush_numeventss ) * sizeof ( * sp - > Hush_events ) ) ;
sp - > Hush_events [ sp - > Hush_numeventss + + ] = ep ;
portable_mutex_unlock ( & hush_mutex ) ;
}
return ( ep ) ;
}
void hush_eventadd_notarized ( struct hush_state * sp , char * symbol , int32_t height , char * dest , uint256 notarized_hash , uint256 notarized_desttxid , int32_t notarizedheight , uint256 MoM , int32_t MoMdepth )
{
static uint32_t counter ; int32_t verified = 0 ; char * coin ; struct hush_event_notarized N ;
coin = ( SMART_CHAIN_SYMBOL [ 0 ] = = 0 ) ? ( char * ) " HUSH3 " : SMART_CHAIN_SYMBOL ;
if ( IS_HUSH_NOTARY ! = 0 & & ( verified = hush_verifynotarization ( symbol , dest , height , notarizedheight , notarized_hash , notarized_desttxid ) ) < 0 )
{
if ( counter + + < 100 )
printf ( " [%s] error validating notarization ht.%d notarized_height.%d, if on a pruned %s node this can be ignored \n " , SMART_CHAIN_SYMBOL , height , notarizedheight , dest ) ;
}
else if ( strcmp ( symbol , coin ) = = 0 )
{
if ( 0 & & IS_HUSH_NOTARY ! = 0 & & verified ! = 0 )
fprintf ( stderr , " validated [%s] ht.%d notarized %d \n " , coin , height , notarizedheight ) ;
memset ( & N , 0 , sizeof ( N ) ) ;
N . blockhash = notarized_hash ;
N . desttxid = notarized_desttxid ;
N . notarizedheight = notarizedheight ;
N . MoM = MoM ;
N . MoMdepth = MoMdepth ;
strncpy ( N . dest , dest , sizeof ( N . dest ) - 1 ) ;
hush_eventadd ( sp , height , symbol , HUSH_EVENT_NOTARIZED , ( uint8_t * ) & N , sizeof ( N ) ) ;
if ( sp ! = 0 )
hush_notarized_update ( sp , height , notarizedheight , notarized_hash , notarized_desttxid , MoM , MoMdepth ) ;
}
}
void hush_eventadd_pubkeys ( struct hush_state * sp , char * symbol , int32_t height , uint8_t num , uint8_t pubkeys [ 64 ] [ 33 ] )
{
struct hush_event_pubkeys P ;
fprintf ( stderr , " %s: eventadd pubkeys height=%d \n " , __func__ , height ) ;
memset ( & P , 0 , sizeof ( P ) ) ;
P . num = num ;
memcpy ( P . pubkeys , pubkeys , 33 * num ) ;
hush_eventadd ( sp , height , symbol , HUSH_EVENT_RATIFY , ( uint8_t * ) & P , ( int32_t ) ( sizeof ( P . num ) + 33 * num ) ) ;
if ( sp ! = 0 )
hush_notarysinit ( height , pubkeys , num ) ;
}
void hush_eventadd_pricefeed ( struct hush_state * sp , char * symbol , int32_t height , uint32_t * prices , uint8_t num )
{
struct hush_event_pricefeed F ;
if ( num = = sizeof ( F . prices ) / sizeof ( * F . prices ) )
{
memset ( & F , 0 , sizeof ( F ) ) ;
F . num = num ;
memcpy ( F . prices , prices , sizeof ( * F . prices ) * num ) ;
hush_eventadd ( sp , height , symbol , HUSH_EVENT_PRICEFEED , ( uint8_t * ) & F , ( int32_t ) ( sizeof ( F . num ) + sizeof ( * F . prices ) * num ) ) ;
if ( sp ! = 0 )
hush_pvals ( height , prices , num ) ;
} //else fprintf(stderr,"skip pricefeed[%d]\n",num);
}
void hush_eventadd_opreturn ( struct hush_state * sp , char * symbol , int32_t height , uint256 txid , uint64_t value , uint16_t vout , uint8_t * buf , uint16_t opretlen )
{
struct hush_event_opreturn O ; uint8_t * opret ;
if ( SMART_CHAIN_SYMBOL [ 0 ] ! = 0 )
{
opret = ( uint8_t * ) calloc ( 1 , sizeof ( O ) + opretlen + 16 ) ;
O . txid = txid ;
O . value = value ;
O . vout = vout ;
memcpy ( opret , & O , sizeof ( O ) ) ;
memcpy ( & opret [ sizeof ( O ) ] , buf , opretlen ) ;
O . oplen = ( int32_t ) ( opretlen + sizeof ( O ) ) ;
hush_eventadd ( sp , height , symbol , HUSH_EVENT_OPRETURN , opret , O . oplen ) ;
free ( opret ) ;
if ( sp ! = 0 )
hush_opreturn ( height , value , buf , opretlen , txid , vout , symbol ) ;
}
}
void hush_event_undo ( struct hush_state * sp , struct hush_event * ep )
{
switch ( ep - > type )
{
case HUSH_EVENT_RATIFY : printf ( " rewind of ratify, needs to be coded.%d \n " , ep - > height ) ; break ;
case HUSH_EVENT_NOTARIZED : break ;
case HUSH_EVENT_HUSHHEIGHT :
if ( ep - > height < = sp - > SAVEDHEIGHT )
sp - > SAVEDHEIGHT = ep - > height ;
break ;
case HUSH_EVENT_PRICEFEED :
// backtrack prices;
break ;
case HUSH_EVENT_OPRETURN :
// backtrack opreturns
break ;
}
}
void hush_event_rewind ( struct hush_state * sp , char * symbol , int32_t height )
{
struct hush_event * ep ;
if ( sp ! = 0 )
{
if ( SMART_CHAIN_SYMBOL [ 0 ] = = 0 & & height < = HUSH_LASTMINED & & prevHUSH_LASTMINED ! = 0 )
{
printf ( " undo HUSH_LASTMINED %d <- %d \n " , HUSH_LASTMINED , prevHUSH_LASTMINED ) ;
HUSH_LASTMINED = prevHUSH_LASTMINED ;
prevHUSH_LASTMINED = 0 ;
}
while ( sp - > Hush_events ! = 0 & & sp - > Hush_numeventss > 0 )
{
if ( ( ep = sp - > Hush_events [ sp - > Hush_numeventss - 1 ] ) ! = 0 )
{
if ( ep - > height < height )
break ;
//printf("[%s] undo %s event.%c ht.%d for rewind.%d\n",SMART_CHAIN_SYMBOL,symbol,ep->type,ep->height,height);
hush_event_undo ( sp , ep ) ;
sp - > Hush_numeventss - - ;
}
}
}
}
void hush_sethushheight ( struct hush_state * sp , int32_t hushheight , uint32_t timestamp )
{
if ( sp ! = 0 )
{
if ( hushheight > sp - > SAVEDHEIGHT )
{
sp - > SAVEDHEIGHT = hushheight ;
sp - > SAVEDTIMESTAMP = timestamp ;
}
if ( hushheight > sp - > CURRENT_HEIGHT )
sp - > CURRENT_HEIGHT = hushheight ;
}
}
void hush_eventadd_hushheight ( struct hush_state * sp , char * symbol , int32_t height , int32_t hushheight , uint32_t timestamp )
{
uint32_t buf [ 2 ] ;
if ( hushheight > 0 ) {
buf [ 0 ] = ( uint32_t ) hushheight ;
buf [ 1 ] = timestamp ;
hush_eventadd ( sp , height , symbol , HUSH_EVENT_HUSHHEIGHT , ( uint8_t * ) buf , sizeof ( buf ) ) ;
if ( sp ! = 0 )
hush_sethushheight ( sp , hushheight , timestamp ) ;
} else {
//fprintf(stderr,"REWIND hushheight.%d\n",hushheight);
hushheight = - hushheight ;
hush_eventadd ( sp , height , symbol , HUSH_EVENT_REWIND , ( uint8_t * ) & height , sizeof ( height ) ) ;
if ( sp ! = 0 )
hush_event_rewind ( sp , symbol , height ) ;
}
}
# endif