Line data Source code
1 : #include "../fd_flamenco.h"
2 : #include "fd_solcap_proto.h"
3 : #include "fd_solcap_reader.h"
4 : #include "fd_solcap.pb.h"
5 : #include "../../ballet/base58/fd_base58.h"
6 : #include "../types/fd_types.h"
7 : #include "../types/fd_types_yaml.h"
8 : #include "../../ballet/nanopb/pb_decode.h"
9 :
10 : #include <errno.h>
11 : #include <stdio.h>
12 : #include <sys/stat.h> /* mkdir(2) */
13 : #include <fcntl.h> /* open(2) */
14 : #include <unistd.h> /* close(2) */
15 :
16 : /* TODO: Ugly -- These should not be hard coded! */
17 0 : #define SOLCAP_FILE_NAME_LEN (13UL)
18 0 : #define SOLCAP_SUFFIX_LEN (7UL) /* .solcap */
19 :
20 : #if FD_USING_GCC && __GNUC__ >= 15
21 : #pragma GCC diagnostic ignored "-Wunterminated-string-initialization"
22 : #endif
23 :
24 : static const uchar
25 : _vote_program_address[ 32 ] =
26 : "\x07\x61\x48\x1d\x35\x74\x74\xbb\x7c\x4d\x76\x24\xeb\xd3\xbd\xb3"
27 : "\xd8\x35\x5e\x73\xd1\x10\x43\xfc\x0d\xa3\x53\x80\x00\x00\x00\x00";
28 :
29 : static const uchar
30 : _stake_program_address[ 32 ] =
31 : "\x06\xa1\xd8\x17\x91\x37\x54\x2a\x98\x34\x37\xbd\xfe\x2a\x7a\xb2"
32 : "\x55\x7f\x53\x5c\x8a\x78\x72\x2b\x68\xa4\x9d\xc0\x00\x00\x00\x00";
33 :
34 : static void
35 0 : normalize_filename( const char * original_str, char * file_name, char prefix ) {
36 : /* We either need to truncate if too long or pad if too short (16 chars) */
37 :
38 0 : file_name[0] = prefix;
39 0 : ulong original_str_len = strlen( original_str ) - SOLCAP_SUFFIX_LEN + 1;
40 0 : if ( original_str_len <= SOLCAP_FILE_NAME_LEN ) {
41 0 : fd_memcpy( file_name + 1, original_str, original_str_len );
42 0 : for ( ulong i = original_str_len; i < SOLCAP_FILE_NAME_LEN; i++ ) {
43 0 : file_name[ i ] = ' ';
44 0 : }
45 0 : }
46 0 : else {
47 0 : ulong start_idx = original_str_len - SOLCAP_FILE_NAME_LEN;
48 0 : fd_memcpy( file_name + 1, original_str + start_idx, SOLCAP_FILE_NAME_LEN );
49 :
50 0 : }
51 0 : file_name[ SOLCAP_FILE_NAME_LEN ] = '\0';
52 0 : }
53 :
54 : /* Define routines for sorting the bank hash account delta accounts.
55 : The solcap format does not mandate accounts to be sorted. */
56 :
57 : static inline int
58 : fd_solcap_account_tbl_lt( fd_solcap_account_tbl_t const * a,
59 0 : fd_solcap_account_tbl_t const * b ) {
60 0 : return memcmp( a->key, b->key, 32UL ) < 0;
61 0 : }
62 : #define SORT_NAME sort_account_tbl
63 : #define SORT_KEY_T fd_solcap_account_tbl_t
64 : #define SORT_BEFORE(a,b) fd_solcap_account_tbl_lt( &(a), &(b) )
65 : #include "../../util/tmpl/fd_sort.c"
66 : struct fd_solcap_differ {
67 : fd_solcap_chunk_iter_t iter [2];
68 : fd_solcap_BankPreimage preimage[2];
69 :
70 : int verbose;
71 : int dump_dir_fd;
72 : char const * dump_dir;
73 : char const * file_paths[2];
74 : };
75 :
76 : typedef struct fd_solcap_differ fd_solcap_differ_t;
77 :
78 : struct fd_solcap_txn_differ {
79 : FILE * file[2];
80 : fd_solcap_chunk_iter_t iter[2];
81 : long chunk_gaddr[2];
82 : fd_solcap_Transaction transaction[2];
83 : uchar meta_buf[128][2];
84 : };
85 :
86 : typedef struct fd_solcap_txn_differ fd_solcap_txn_differ_t;
87 :
88 : static fd_solcap_differ_t *
89 : fd_solcap_differ_new( fd_solcap_differ_t * diff,
90 : FILE * streams[2],
91 0 : const char * cap_path[2] ) {
92 :
93 : /* Attach to capture files */
94 :
95 0 : for( ulong i=0UL; i<2UL; i++ ) {
96 0 : FILE * stream = streams[i];
97 :
98 : /* Set file names */
99 0 : diff->file_paths[i] = cap_path[i];
100 :
101 : /* Read file header */
102 0 : fd_solcap_fhdr_t hdr[1];
103 0 : if( FD_UNLIKELY( 1UL!=fread( hdr, sizeof(fd_solcap_fhdr_t), 1UL, stream ) ) ) {
104 0 : FD_LOG_WARNING(( "Failed to read file=%s header (%d-%s)",
105 0 : diff->file_paths[i], errno, strerror( errno ) ));
106 0 : return NULL;
107 0 : }
108 :
109 : /* Seek to first chunk */
110 0 : long skip = ( (long)hdr->chunk0_foff - (long)sizeof(fd_solcap_fhdr_t) );
111 0 : if( FD_UNLIKELY( 0!=fseek( stream, skip, SEEK_CUR ) ) ) {
112 0 : FD_LOG_WARNING(( "Failed to seek to first chunk (%d-%s)", errno, strerror( errno ) ));
113 0 : return NULL;
114 0 : }
115 :
116 0 : if( FD_UNLIKELY( !fd_solcap_chunk_iter_new( &diff->iter[i], stream ) ) )
117 0 : FD_LOG_CRIT(( "fd_solcap_chunk_iter_new() failed" ));
118 0 : }
119 :
120 0 : return diff;
121 0 : }
122 :
123 : /* fd_solcap_differ_advance seeks an iterator to the next bank hash.
124 : idx identifies the iterator. Returns 1 on success, 0 if end-of-file
125 : reached, and negated errno-like on failure. */
126 :
127 : static int
128 : fd_solcap_differ_advance( fd_solcap_differ_t * diff,
129 0 : ulong idx ) { /* [0,2) */
130 :
131 0 : fd_solcap_chunk_iter_t * iter = &diff->iter [ idx ];
132 0 : fd_solcap_BankPreimage * preimage = &diff->preimage[ idx ];
133 :
134 0 : long off = fd_solcap_chunk_iter_find( iter, FD_SOLCAP_V1_BANK_MAGIC );
135 0 : if( FD_UNLIKELY( off<0L ) )
136 0 : return fd_solcap_chunk_iter_err( iter );
137 :
138 0 : int err = fd_solcap_read_bank_preimage( iter->stream, iter->chunk_off, preimage, &iter->chunk );
139 0 : if( FD_UNLIKELY( err!=0 ) ) return -err;
140 0 : return 1;
141 0 : }
142 :
143 : /* fd_solcap_differ_sync synchronizes the given two iterators such that
144 : both point to the lowest common slot number. Returns 1 on success
145 : and 0 if no common slot was found. Negative values are negated
146 : errno-like. */
147 :
148 : static int
149 0 : fd_solcap_differ_sync( fd_solcap_differ_t * diff, ulong start_slot, ulong end_slot ) {
150 :
151 : /* Seek to first bank preimage object */
152 :
153 0 : for( ulong i=0UL; i<2UL; i++ ) {
154 0 : int res = fd_solcap_differ_advance( diff, i );
155 0 : if( FD_UNLIKELY( res!=1 ) ) return res;
156 0 : }
157 :
158 0 : ulong prev_slot0 = diff->preimage[ 0 ].slot;
159 0 : ulong prev_slot1 = diff->preimage[ 1 ].slot;
160 :
161 0 : for(;;) {
162 0 : ulong slot0 = diff->preimage[ 0 ].slot;
163 0 : ulong slot1 = diff->preimage[ 1 ].slot;
164 :
165 : /* Handle cases where slot is skipped in one or the other */
166 0 : if ( FD_UNLIKELY( prev_slot0 < slot1 && slot0 > slot1 ) ) {
167 0 : FD_LOG_WARNING(("Slot range (%lu,%lu) skipped in file=%s\n",
168 0 : prev_slot0, slot0, diff->file_paths[0]));
169 0 : }
170 0 : else if ( FD_UNLIKELY( prev_slot1 < slot0 && slot1 > slot0 ) ) {
171 0 : FD_LOG_WARNING(("Slot range (%lu,%lu) skipped in file=%s\n",
172 0 : prev_slot1, slot1, diff->file_paths[1]));
173 0 : }
174 :
175 0 : if( slot0 == slot1 ) {
176 0 : if ( slot0 < start_slot ) {
177 0 : int res;
178 0 : res = fd_solcap_differ_advance( diff, 0 );
179 0 : if( FD_UNLIKELY( res <= 0 ) ) return res;
180 0 : res = fd_solcap_differ_advance( diff, 1 );
181 0 : if( FD_UNLIKELY( res <= 0 ) ) return res;
182 0 : }
183 0 : else if ( slot0 > end_slot ) {
184 0 : return 0;
185 0 : }
186 0 : else {
187 0 : return 1;
188 0 : }
189 0 : }
190 0 : else {
191 0 : ulong idx = slot0>slot1;
192 0 : int res = fd_solcap_differ_advance( diff, idx );
193 0 : if( FD_UNLIKELY( res<=0 ) ) return res;
194 0 : }
195 0 : prev_slot0 = slot0;
196 0 : prev_slot1 = slot1;
197 0 : }
198 :
199 0 : return 0;
200 0 : }
201 :
202 : static int
203 : fd_solcap_can_pretty_print( uchar const owner [ static 32 ],
204 0 : uchar const pubkey[ static 32 ] ) {
205 :
206 : /* TODO clean up */
207 0 : uchar _sysvar_clock[ 32 ];
208 0 : fd_base58_decode_32( "SysvarC1ock11111111111111111111111111111111", _sysvar_clock );
209 0 : uchar _sysvar_rent[ 32 ];
210 0 : fd_base58_decode_32( "SysvarRent111111111111111111111111111111111", _sysvar_rent );
211 0 : uchar _sysvar_epoch_rewards[ 32 ];
212 0 : fd_base58_decode_32( "SysvarEpochRewards1111111111111111111111111", _sysvar_epoch_rewards );
213 0 : uchar _sysvar_stake_history[ 32 ];
214 0 : fd_base58_decode_32( "SysvarStakeHistory1111111111111111111111111", _sysvar_stake_history );
215 :
216 0 : if( 0==memcmp( owner, _vote_program_address, 32UL ) )
217 0 : return 1;
218 0 : if( 0==memcmp( owner, _stake_program_address, 32UL ) )
219 0 : return 1;
220 :
221 0 : if( 0==memcmp( pubkey, _sysvar_clock, 32UL ) )
222 0 : return 1;
223 0 : if( 0==memcmp( pubkey, _sysvar_rent, 32UL ) )
224 0 : return 1;
225 0 : if( 0==memcmp( pubkey, _sysvar_epoch_rewards, 32UL ) )
226 0 : return 1;
227 0 : if( 0==memcmp( pubkey, _sysvar_stake_history, 32UL ) )
228 0 : return 1;
229 0 : return 0;
230 0 : }
231 :
232 : static int
233 : fd_solcap_account_pretty_print( uchar const pubkey[ static 32 ],
234 : uchar const owner[ static 32 ],
235 : uchar const * data,
236 : ulong data_sz,
237 0 : FILE * file ) {
238 :
239 0 : FD_SCRATCH_SCOPE_BEGIN {
240 :
241 0 : fd_flamenco_yaml_t * yaml =
242 0 : fd_flamenco_yaml_init( fd_flamenco_yaml_new(
243 0 : fd_scratch_alloc( fd_flamenco_yaml_align(), fd_flamenco_yaml_footprint() ) ),
244 0 : file );
245 0 : FD_TEST( yaml );
246 :
247 : /* TODO clean up */
248 0 : uchar _sysvar_clock[ 32 ];
249 0 : fd_base58_decode_32( "SysvarC1ock11111111111111111111111111111111", _sysvar_clock );
250 0 : uchar _sysvar_rent[ 32 ];
251 0 : fd_base58_decode_32( "SysvarRent111111111111111111111111111111111", _sysvar_rent );
252 0 : uchar _sysvar_epoch_rewards[ 32 ];
253 0 : fd_base58_decode_32( "SysvarEpochRewards1111111111111111111111111", _sysvar_epoch_rewards );
254 0 : uchar _sysvar_stake_history[ 32 ];
255 0 : fd_base58_decode_32( "SysvarStakeHistory1111111111111111111111111", _sysvar_stake_history );
256 :
257 0 : if( 0==memcmp( owner, _vote_program_address, 32UL ) ) {
258 0 : fd_vote_state_versioned_t * vote_state = fd_bincode_decode_scratch( vote_state_versioned, data, data_sz, NULL );
259 0 : if( FD_UNLIKELY( !vote_state ) ) return -ENOMEM;
260 0 : fd_vote_state_versioned_walk( yaml, vote_state, fd_flamenco_yaml_walk, NULL, 0U, 0U );
261 0 : } else if( 0==memcmp( owner, _stake_program_address, 32UL ) ) {
262 0 : fd_stake_state_v2_t * stake_state = fd_bincode_decode_scratch( stake_state_v2, data, data_sz, NULL );
263 0 : if( FD_UNLIKELY( !stake_state ) ) return -ENOMEM;
264 0 : fd_stake_state_v2_walk( yaml, stake_state, fd_flamenco_yaml_walk, NULL, 0U, 0U );
265 0 : } else if( 0==memcmp( pubkey, _sysvar_clock, 32UL ) ) {
266 0 : fd_sol_sysvar_clock_t * clock = fd_bincode_decode_scratch( sol_sysvar_clock, data, data_sz, NULL );
267 0 : if( FD_UNLIKELY( !clock ) ) return -ENOMEM;
268 0 : fd_sol_sysvar_clock_walk( yaml, clock, fd_flamenco_yaml_walk, NULL, 0U, 0U );
269 0 : } else if( 0==memcmp( pubkey, _sysvar_rent, 32UL ) ) {
270 0 : fd_rent_t * rent = fd_bincode_decode_scratch( rent, data, data_sz, NULL );
271 0 : if( FD_UNLIKELY( !rent ) ) return -ENOMEM;
272 0 : fd_rent_walk( yaml, rent, fd_flamenco_yaml_walk, NULL, 0U, 0U );
273 0 : } else if( 0==memcmp( pubkey, _sysvar_epoch_rewards, 32UL ) ) {
274 0 : fd_sysvar_epoch_rewards_t * epoch_rewards = fd_bincode_decode_scratch( sysvar_epoch_rewards, data, data_sz, NULL );
275 0 : if( FD_UNLIKELY( !epoch_rewards ) ) return -ENOMEM;
276 0 : fd_sysvar_epoch_rewards_walk( yaml, epoch_rewards, fd_flamenco_yaml_walk, NULL, 0U, 0U );
277 0 : } else if( 0==memcmp( pubkey, _sysvar_stake_history, 32UL ) ) {
278 0 : fd_stake_history_t * stake_history = fd_bincode_decode_scratch( stake_history, data, data_sz, NULL );
279 0 : if( FD_UNLIKELY( !stake_history ) ) return -ENOMEM;
280 0 : fd_stake_history_walk( yaml, stake_history, fd_flamenco_yaml_walk, NULL, 0U, 0U );
281 0 : }
282 :
283 0 : int err = ferror( file );
284 0 : if( FD_UNLIKELY( err!=0 ) ) return err;
285 :
286 : /* No need to destroy structures, using fd_scratch allocator */
287 :
288 0 : fd_flamenco_yaml_delete( yaml );
289 0 : return 0;
290 0 : } FD_SCRATCH_SCOPE_END;
291 0 : }
292 :
293 : /* fd_solcap_dump_account_data writes a binary file containing exactly
294 : the given account's content. */
295 :
296 : static void
297 : fd_solcap_dump_account_data( fd_solcap_differ_t * diff,
298 : fd_solcap_AccountMeta const * meta,
299 : char const * filename,
300 0 : void const * acc_data ) {
301 : /* Create dump file */
302 0 : int fd = openat( diff->dump_dir_fd, filename, O_CREAT|O_WRONLY|O_TRUNC, 0666 );
303 0 : if( FD_UNLIKELY( fd<0 ) )
304 0 : FD_LOG_ERR(( "openat(%d,%s) failed (%d-%s)",
305 0 : diff->dump_dir_fd, filename, errno, strerror( errno ) ));
306 :
307 : /* Write dump file */
308 0 : FILE * file = fdopen( fd, "wb" );
309 0 : FD_TEST( meta->data_sz == fwrite( acc_data, 1UL, meta->data_sz, file ) );
310 0 : fclose( file ); /* Closes fd */
311 0 : }
312 :
313 : static void
314 : fd_solcap_diff_account_data( fd_solcap_differ_t * diff,
315 : fd_solcap_AccountMeta const meta [ static 2 ],
316 : fd_solcap_account_tbl_t const * const entry [ static 2 ],
317 0 : ulong const data_goff[ static 2 ] ) {\
318 0 :
319 : /* Streaming diff */
320 0 : int data_eq = meta[0].data_sz == meta[1].data_sz;
321 0 : if( data_eq ) {
322 0 : for( ulong i=0UL; i<2UL; i++ ) {
323 0 : if ( data_goff[i] == ULONG_MAX ) {
324 0 : continue;
325 0 : }
326 0 : FD_TEST( 0==fseek( diff->iter[ i ].stream, (long)data_goff[i], SEEK_SET ) );
327 0 : }
328 :
329 0 : for( ulong off=0UL; off<meta[0].data_sz; ) {
330 0 : # define BUFSZ (512UL)
331 :
332 : /* Read chunks */
333 0 : uchar buf[2][ BUFSZ ];
334 0 : ulong sz = fd_ulong_min( BUFSZ, meta[0].data_sz-off );
335 0 : for( ulong i=0UL; i<2UL; i++ )
336 0 : FD_TEST( sz==fread( &buf[i], 1UL, sz, diff->iter[i].stream ) );
337 :
338 : /* Compare chunks */
339 0 : data_eq = 0==memcmp( buf[0], buf[1], sz );
340 0 : if( !data_eq ) break;
341 :
342 0 : off += sz;
343 0 : # undef BUFSZ
344 0 : }
345 0 : }
346 0 : if( data_eq ) return;
347 :
348 : /* Dump account data to file */
349 0 : if( diff->verbose >= 4 ) {
350 :
351 : /* TODO: Remove hardcoded account size check */
352 0 : FD_TEST( meta[0].data_sz <= 1048576 );
353 0 : FD_TEST( meta[1].data_sz <= 1048576 );
354 :
355 0 : FD_SCRATCH_SCOPE_BEGIN {
356 0 : void * acc_data[2];
357 0 : acc_data[0] = fd_scratch_alloc( 1UL, meta[0].data_sz );
358 0 : acc_data[1] = fd_scratch_alloc( 1UL, meta[1].data_sz );
359 0 : fd_memset( acc_data[0], 0, meta[0].data_sz );
360 0 : fd_memset( acc_data[1], 0, meta[1].data_sz );
361 :
362 0 : for( ulong i=0UL; i<2UL; i++ ) {
363 0 : if ( data_goff[i] == ULONG_MAX ) {
364 0 : continue;
365 0 : }
366 :
367 : /* Rewind capture stream */
368 0 : FD_TEST( 0==fseek( diff->iter[ i ].stream, (long)data_goff[i], SEEK_SET ) );
369 :
370 : /* Copy data */
371 0 : FD_TEST( meta[i].data_sz == fread( acc_data[i], 1UL, meta[i].data_sz, diff->iter[i].stream ) );
372 0 : }
373 :
374 0 : for( ulong i=0; i<2; i++ ) {
375 0 : char filename[ FD_BASE58_ENCODED_32_LEN+2+4+1 ];
376 0 : int res = snprintf( filename, sizeof(filename), "%s.%lu.bin",
377 0 : FD_BASE58_ENC_32_ALLOCA( entry[i]->key ), i );
378 0 : FD_TEST( (res>0) & (res<(int)sizeof(filename)) );
379 0 : fd_solcap_dump_account_data( diff, meta+i, filename, acc_data[i] );
380 0 : }
381 :
382 : /* Inform user */
383 0 : printf( " (%s) data: %s/%s.0.bin\n"
384 0 : " (%s) data: %s/%s.1.bin\n"
385 0 : " vimdiff <(xxd '%s/%s.bin') <(xxd '%s/%s.bin')\n",
386 0 : diff->file_paths[0], diff->dump_dir, FD_BASE58_ENC_32_ALLOCA( entry[0]->key ),
387 0 : diff->file_paths[1], diff->dump_dir, FD_BASE58_ENC_32_ALLOCA( entry[1]->key ),
388 0 : diff->dump_dir, FD_BASE58_ENC_32_ALLOCA( entry[0]->key ),
389 0 : diff->dump_dir, FD_BASE58_ENC_32_ALLOCA( entry[1]->key ) );
390 :
391 0 : if( fd_solcap_can_pretty_print( meta[0].owner, entry[0]->key )
392 0 : & fd_solcap_can_pretty_print( meta[1].owner, entry[1]->key ) ) {
393 :
394 0 : for( ulong i=0UL; i<2UL; i++ ) {
395 : /* Create YAML file */
396 0 : char path[ FD_BASE58_ENCODED_32_LEN+2+4+1 ];
397 0 : int res = snprintf( path, sizeof(path), "%s.%lu.yml", FD_BASE58_ENC_32_ALLOCA( entry[i]->key ), i );
398 0 : FD_TEST( (res>0) & (res<(int)sizeof(path)) );
399 0 : int fd = openat( diff->dump_dir_fd, path, O_CREAT|O_WRONLY|O_TRUNC, 0666 );
400 0 : if( FD_UNLIKELY( fd<0 ) )
401 0 : FD_LOG_ERR(( "openat(%d,%s) failed (%d-%s)",
402 0 : diff->dump_dir_fd, path, errno, strerror( errno ) ));
403 :
404 : /* Write YAML file */
405 0 : FILE * file = fdopen( fd, "wb" );
406 0 : fd_solcap_account_pretty_print( entry[i]->key, meta[i].owner, acc_data[i], meta[i].data_sz, file );
407 0 : fclose( file ); /* closes fd */
408 0 : }
409 :
410 :
411 : /* Inform user */
412 0 : printf( " vimdiff '%s/%s.0.yml' '%s/%s.1.yml'\n",
413 0 : diff->dump_dir, FD_BASE58_ENC_32_ALLOCA( entry[0]->key ),
414 0 : diff->dump_dir, FD_BASE58_ENC_32_ALLOCA( entry[1]->key ) );
415 :
416 0 : }
417 0 : } FD_SCRATCH_SCOPE_END;
418 0 : }
419 0 : }
420 :
421 : /* fd_solcap_diff_account prints further details about a mismatch
422 : between two accounts. Preserves stream cursors. */
423 :
424 : static void
425 : fd_solcap_diff_account( fd_solcap_differ_t * diff,
426 : fd_solcap_account_tbl_t const * const entry [ static 2 ],
427 0 : ulong const acc_tbl_goff[ static 2 ] ) {
428 :
429 : /* Remember current file offsets (should probably just use readat) */
430 0 : long orig_off[ 2 ];
431 0 : for( ulong i=0UL; i<2UL; i++ ) {
432 0 : orig_off[ i ] = ftell( diff->iter[ i ].stream );
433 0 : if( FD_UNLIKELY( orig_off[ i ]<0L ) )
434 0 : FD_LOG_ERR(( "ftell failed (%d-%s)", errno, strerror( errno ) ));
435 0 : }
436 :
437 : /* Read account meta */
438 0 : fd_solcap_AccountMeta meta[2];
439 0 : ulong data_goff[2] = {ULONG_MAX, ULONG_MAX};
440 0 : for( ulong i=0UL; i<2UL; i++ ) {
441 0 : FILE * stream = diff->iter[ i ].stream;
442 0 : int err = fd_solcap_find_account( stream, meta+i, &data_goff[i], entry[i], acc_tbl_goff[i] );
443 0 : FD_TEST( err==0 );
444 0 : }
445 :
446 0 : if( 0!=memcmp( meta[0].owner, meta[1].owner, 32UL ) ||
447 0 : meta[0].lamports!=meta[1].lamports ||
448 0 : meta[0].data_sz!=meta[1].data_sz ||
449 0 : meta[0].slot!=meta[1].slot ||
450 0 : meta[0].executable!=meta[1].executable ) {
451 0 : printf( "account: %s\n", FD_BASE58_ENC_32_ALLOCA( entry[0]->key ) );
452 0 : }
453 :
454 0 : if( 0!=memcmp( meta[0].owner, meta[1].owner, 32UL ) )
455 0 : printf( "%s owner: %s\n"
456 0 : "%s owner: %s\n",
457 0 : diff->file_paths[0], FD_BASE58_ENC_32_ALLOCA( meta[0].owner ),
458 0 : diff->file_paths[1], FD_BASE58_ENC_32_ALLOCA( meta[1].owner ) );
459 0 : if( meta[0].lamports != meta[1].lamports )
460 0 : printf( " (%s) lamports: %lu\n"
461 0 : " (%s) lamports: %lu\n",
462 0 : diff->file_paths[0], meta[0].lamports,
463 0 : diff->file_paths[1], meta[1].lamports );
464 0 : if( meta[0].data_sz != meta[1].data_sz )
465 0 : printf( " (%s) data_sz: %lu\n"
466 0 : " (%s) data_sz: %lu\n",
467 0 : diff->file_paths[0], meta[0].data_sz,
468 0 : diff->file_paths[1], meta[1].data_sz );
469 0 : if( meta[0].slot != meta[1].slot )
470 0 : printf( " (%s) slot: %lu\n"
471 0 : " (%s) slot: %lu\n",
472 0 : diff->file_paths[0], meta[0].slot,
473 0 : diff->file_paths[1], meta[1].slot );
474 0 : if( meta[0].executable != meta[1].executable )
475 0 : printf( " (%s) executable: %d\n"
476 0 : " (%s) executable: %d\n",
477 0 : diff->file_paths[0], meta[0].executable,
478 0 : diff->file_paths[1], meta[1].executable );
479 0 : if( ( (meta[0].data_sz != 0UL) | fd_solcap_includes_account_data( &meta[0] ) )
480 0 : | ( (meta[1].data_sz != 0UL) | fd_solcap_includes_account_data( &meta[1] ) ) )
481 0 : fd_solcap_diff_account_data( diff, meta, entry, data_goff );
482 :
483 : /* Restore file offsets */
484 0 : for( ulong i=0UL; i<2UL; i++ ) {
485 0 : if( FD_UNLIKELY( 0!=fseek( diff->iter[ i ].stream, orig_off[ i ], SEEK_SET ) ) )
486 0 : FD_LOG_ERR(( "fseek failed (%d-%s)", errno, strerror( errno ) ));
487 0 : }
488 0 : }
489 :
490 : /* fd_solcap_diff_missing_account is like fd_solcap_diff_account but in
491 : the case that either side of the account is missing entirely. */
492 :
493 : static void
494 : fd_solcap_diff_missing_account( fd_solcap_differ_t * diff,
495 : fd_solcap_account_tbl_t const * const entry,
496 : ulong const acc_tbl_goff,
497 0 : FILE * stream ) {
498 :
499 : /* Remember current file offset */
500 0 : long orig_off = ftell( stream );
501 0 : if( FD_UNLIKELY( orig_off<0L ) )
502 0 : FD_LOG_ERR(( "ftell failed (%d-%s)", errno, strerror( errno ) ));
503 :
504 : /* Read account meta */
505 0 : fd_solcap_AccountMeta meta[1];
506 0 : ulong data_goff[1];
507 0 : int err = fd_solcap_find_account( stream, meta, data_goff, entry, acc_tbl_goff );
508 0 : FD_TEST( err==0 );
509 :
510 0 : printf(
511 0 : " lamports: %lu\n"
512 0 : " data_sz: %lu\n"
513 0 : " owner: %s\n"
514 0 : " slot: %lu\n"
515 0 : " executable: %d\n",
516 0 : meta->lamports,
517 0 : meta->data_sz,
518 0 : FD_BASE58_ENC_32_ALLOCA( meta->owner ),
519 0 : meta->slot,
520 0 : meta->executable
521 0 : );
522 :
523 : /* Dump account data to file */
524 0 : if( diff->verbose >= 4 ) {
525 :
526 : /* TODO: Remove hardcoded account size check */
527 0 : FD_TEST( meta->data_sz <= 8388608 );
528 :
529 0 : FD_SCRATCH_SCOPE_BEGIN {
530 0 : void * acc_data = fd_scratch_alloc( 1UL, meta->data_sz );
531 :
532 : /* Rewind capture stream */
533 0 : FD_TEST( 0==fseek(stream, (long)*data_goff, SEEK_SET ) );
534 :
535 : /* Copy data */
536 0 : FD_TEST( meta->data_sz == fread( acc_data, 1UL, meta->data_sz, stream ) );
537 :
538 0 : char filename[ FD_BASE58_ENCODED_32_LEN+4+1 ];
539 0 : int res = snprintf( filename, sizeof(filename), "%s.bin", FD_BASE58_ENC_32_ALLOCA( entry->key ) );
540 0 : FD_TEST( (res>0) & (res<(int)sizeof(filename)) );
541 0 : fd_solcap_dump_account_data( diff, meta, filename, acc_data );
542 :
543 : /* Inform user */
544 0 : printf( " data: %s/%s.bin\n"
545 0 : " xxd '%s/%s.bin'\n"
546 0 : " explorer: 'https://explorer.solana.com/block/%lu?accountFilter=%s&filter=all'",
547 0 : diff->dump_dir, FD_BASE58_ENC_32_ALLOCA( entry->key ),
548 0 : diff->dump_dir, FD_BASE58_ENC_32_ALLOCA( entry->key ),
549 0 : meta->slot, FD_BASE58_ENC_32_ALLOCA( entry->key ) );
550 :
551 0 : #pragma GCC diagnostic push
552 0 : #pragma GCC diagnostic ignored "-Wnonnull"
553 0 : if( fd_solcap_can_pretty_print( meta->owner, entry->key ) ) {
554 0 : #pragma GCC diagnostic pop
555 : /* Create YAML file */
556 0 : char path[ FD_BASE58_ENCODED_32_LEN+4+1 ];
557 0 : int res = snprintf( path, sizeof(path), "%s.yml", FD_BASE58_ENC_32_ALLOCA( entry->key ) );
558 0 : FD_TEST( (res>0) & (res<(int)sizeof(path)) );
559 0 : int fd = openat( diff->dump_dir_fd, path, O_CREAT|O_WRONLY|O_TRUNC, 0666 );
560 0 : if( FD_UNLIKELY( fd<0 ) )
561 0 : FD_LOG_ERR(( "openat(%d,%s) failed (%d-%s)",
562 0 : diff->dump_dir_fd, path, errno, strerror( errno ) ));
563 :
564 : /* Write YAML file */
565 0 : FILE * file = fdopen( fd, "wb" );
566 0 : fd_solcap_account_pretty_print( entry->key, meta->owner, acc_data, meta->data_sz, file );
567 0 : fclose( file ); /* closes fd */
568 :
569 : /* Inform user */
570 0 : printf( " cat '%s/%s.yml'\n",
571 0 : diff->dump_dir, FD_BASE58_ENC_32_ALLOCA( entry->key ) );
572 0 : }
573 0 : } FD_SCRATCH_SCOPE_END;
574 0 : }
575 0 : }
576 :
577 : /* fd_solcap_diff_account_tbl detects and prints differences in the
578 : accounts that were hashed into the account delta hash. */
579 :
580 : static int
581 0 : fd_solcap_diff_account_tbl( fd_solcap_differ_t * diff ) {
582 0 : int has_mismatch = 0;
583 :
584 : /* Read and sort tables */
585 :
586 0 : fd_solcap_account_tbl_t * tbl [2];
587 0 : fd_solcap_account_tbl_t * tbl_end[2];
588 0 : ulong chunk_goff[2];
589 0 : for( ulong i=0UL; i<2UL; i++ ) {
590 0 : if( diff->preimage[i].account_table_coff == 0L ) {
591 0 : FD_LOG_WARNING(( "Missing accounts table in capture" ));
592 0 : return 1;
593 0 : }
594 0 : chunk_goff[i] = (ulong)( (long)diff->iter[i].chunk_off + diff->preimage[i].account_table_coff );
595 :
596 : /* Read table meta and seek to table */
597 0 : FILE * stream = diff->iter[i].stream;
598 0 : fd_solcap_AccountTableMeta meta[1];
599 0 : int err = fd_solcap_find_account_table( stream, meta, chunk_goff[i] );
600 0 : FD_TEST( err==0 );
601 :
602 0 : if( FD_UNLIKELY( meta->account_table_cnt > INT_MAX ) ) {
603 0 : FD_LOG_WARNING(( "Too many accounts in capture" ));
604 0 : return 1;
605 0 : }
606 :
607 : /* Allocate table */
608 0 : ulong tbl_cnt = meta->account_table_cnt;
609 0 : ulong tbl_align = alignof(fd_solcap_account_tbl_t);
610 0 : ulong tbl_sz = tbl_cnt * sizeof(fd_solcap_account_tbl_t);
611 0 : FD_TEST( fd_scratch_alloc_is_safe( tbl_align, tbl_sz ) );
612 0 : tbl [i] = fd_scratch_alloc( tbl_align, tbl_sz );
613 0 : tbl_end[i] = tbl[i] + tbl_cnt;
614 :
615 : /* Read table */
616 0 : FD_TEST( tbl_cnt==fread( tbl[i], sizeof(fd_solcap_account_tbl_t), tbl_cnt, stream ) );
617 0 : }
618 :
619 0 : typedef struct {
620 0 : fd_solcap_account_tbl_t const * entry;
621 0 : int is_last_occurrence;
622 0 : } account_entry_info_t;
623 :
624 0 : account_entry_info_t * entries[2];
625 0 : ulong tbl_cnt[2];
626 0 : for( ulong i=0UL; i<2UL; i++ ) {
627 0 : tbl_cnt[i] = (ulong)(tbl_end[i] - tbl[i]);
628 0 : entries[i] = fd_scratch_alloc( alignof(account_entry_info_t), tbl_cnt[i] * sizeof(account_entry_info_t) );
629 :
630 0 : for( ulong j=0UL; j < tbl_cnt[i]; j++ ) {
631 0 : entries[i][j].entry = &tbl[i][j];
632 0 : entries[i][j].is_last_occurrence = 1;
633 0 : }
634 :
635 0 : for( ulong j=0UL; j < tbl_cnt[i]; j++ ) {
636 0 : for( ulong k=j+1UL; k < tbl_cnt[i]; k++ ) {
637 0 : if( memcmp(entries[i][j].entry->key, entries[i][k].entry->key, sizeof(entries[i][j].entry->key)) == 0 ) {
638 0 : entries[i][j].is_last_occurrence = 0;
639 0 : break;
640 0 : }
641 0 : }
642 0 : }
643 0 : }
644 :
645 0 : for( ulong i=0UL; i<2UL; i++ ) {
646 0 : for( ulong j=0UL; j < tbl_cnt[i]-1UL; j++ ) {
647 0 : for( ulong k=j+1UL; k < tbl_cnt[i]; k++ ) {
648 0 : if( memcmp(entries[i][j].entry->key, entries[i][k].entry->key, sizeof(entries[i][j].entry->key)) > 0 ) {
649 0 : account_entry_info_t temp = entries[i][j];
650 0 : entries[i][j] = entries[i][k];
651 0 : entries[i][k] = temp;
652 0 : }
653 0 : }
654 0 : }
655 0 : }
656 :
657 : /* Walk tables in parallel */
658 0 : ulong idx[2] = {0UL, 0UL};
659 :
660 0 : for(;;) {
661 0 : while( idx[0] < tbl_cnt[0] && !entries[0][idx[0]].is_last_occurrence ) idx[0]++;
662 0 : while( idx[1] < tbl_cnt[1] && !entries[1][idx[1]].is_last_occurrence ) idx[1]++;
663 :
664 0 : if( idx[0] >= tbl_cnt[0] ) break;
665 0 : if( idx[1] >= tbl_cnt[1] ) break;
666 :
667 0 : fd_solcap_account_tbl_t const * a = entries[0][idx[0]].entry;
668 0 : fd_solcap_account_tbl_t const * b = entries[1][idx[1]].entry;
669 :
670 0 : int key_cmp = memcmp( a->key, b->key, 32UL );
671 0 : if( key_cmp==0 ) {
672 0 : if( diff->verbose >= 3 ) {
673 0 : fd_solcap_account_tbl_t const * const entry_pair[2] = {a, b};
674 0 : fd_solcap_diff_account( diff, entry_pair, chunk_goff );
675 0 : }
676 0 : idx[0]++;
677 0 : idx[1]++;
678 0 : continue;
679 0 : }
680 :
681 0 : if( key_cmp<0 ) {
682 0 : has_mismatch = 1;
683 0 : printf( "\n (%s) account: %s\n", diff->file_paths[0], FD_BASE58_ENC_32_ALLOCA( a->key ) );
684 0 : if( diff->verbose >= 3 )
685 0 : fd_solcap_diff_missing_account( diff, a, chunk_goff[0], diff->iter[0].stream );
686 0 : idx[0]++;
687 0 : continue;
688 0 : }
689 :
690 0 : if( key_cmp>0 ) {
691 0 : has_mismatch = 1;
692 0 : printf( "\n (%s) account: %s\n", diff->file_paths[1], FD_BASE58_ENC_32_ALLOCA( b->key ) );
693 0 : if( diff->verbose >= 3 )
694 0 : fd_solcap_diff_missing_account( diff, b, chunk_goff[1], diff->iter[1].stream );
695 0 : idx[1]++;
696 0 : continue;
697 0 : }
698 0 : }
699 :
700 0 : while( idx[0] < tbl_cnt[0] ) {
701 0 : has_mismatch = 1;
702 0 : if( entries[0][idx[0]].is_last_occurrence ) {
703 0 : printf( "\n (%s) account: %s\n", diff->file_paths[0], FD_BASE58_ENC_32_ALLOCA( entries[0][idx[0]].entry->key ) );
704 0 : if( diff->verbose >= 3 )
705 0 : fd_solcap_diff_missing_account( diff, entries[0][idx[0]].entry, chunk_goff[0], diff->iter[0].stream );
706 0 : }
707 0 : idx[0]++;
708 0 : }
709 0 : while( idx[1] < tbl_cnt[1] ) {
710 0 : has_mismatch = 1;
711 0 : if( entries[1][idx[1]].is_last_occurrence ) {
712 0 : printf( "\n (%s) account: %s\n", diff->file_paths[1], FD_BASE58_ENC_32_ALLOCA( entries[1][idx[1]].entry->key ) );
713 0 : if( diff->verbose >= 3 )
714 0 : fd_solcap_diff_missing_account( diff, entries[1][idx[1]].entry, chunk_goff[1], diff->iter[1].stream );
715 0 : }
716 0 : idx[1]++;
717 0 : }
718 :
719 0 : return has_mismatch;
720 0 : }
721 :
722 : /* fd_solcap_diff_bank detects bank hash mismatches and prints a
723 : human-readable description of the root cause to stdout. Returns 0
724 : if bank hashes match, 1 if a mismatch was detected. */
725 :
726 : static int
727 0 : fd_solcap_diff_bank( fd_solcap_differ_t * diff ) {
728 :
729 0 : fd_solcap_BankPreimage const * pre = diff->preimage;
730 :
731 0 : FD_TEST( pre[0].slot == pre[1].slot );
732 :
733 0 : int has_bank_hash_mismatch = 0!=memcmp( pre[0].bank_hash, pre[1].bank_hash, 32UL );
734 :
735 0 : int has_any_mismatch = has_bank_hash_mismatch;
736 0 : if( 0!=memcmp( pre[0].prev_bank_hash, pre[1].prev_bank_hash, 32UL ) ) has_any_mismatch = 1;
737 0 : if( 0!=memcmp( pre[0].account_delta_hash, pre[1].account_delta_hash, 32UL ) ) has_any_mismatch = 1;
738 0 : if( 0!=memcmp( pre[0].accounts_lt_hash_checksum, pre[1].accounts_lt_hash_checksum, 32UL ) ) has_any_mismatch = 1;
739 0 : if( 0!=memcmp( pre[0].poh_hash, pre[1].poh_hash, 32UL ) ) has_any_mismatch = 1;
740 0 : if( pre[0].signature_cnt != pre[1].signature_cnt ) has_any_mismatch = 1;
741 0 : if( pre[0].account_cnt != pre[1].account_cnt ) has_any_mismatch = 1;
742 :
743 :
744 0 : if( diff->verbose < 2 ) {
745 0 : if( has_bank_hash_mismatch ) {
746 0 : printf( "\nbank hash mismatch at slot=%lu\n", pre[0].slot );
747 0 : printf( "(%s) bank_hash: %s\n"
748 0 : "(%s) bank_hash: %s\n",
749 0 : diff->file_paths[0], FD_BASE58_ENC_32_ALLOCA( pre[0].bank_hash ),
750 0 : diff->file_paths[1], FD_BASE58_ENC_32_ALLOCA( pre[1].bank_hash ) );
751 0 : }
752 0 : return has_bank_hash_mismatch;
753 0 : }
754 :
755 0 : if( has_any_mismatch )
756 0 : printf( "\nbank hash mismatch at slot=%lu\n", pre[0].slot );
757 :
758 0 : if( 0!=memcmp( pre[0].bank_hash, pre[1].bank_hash, 32UL ) ) {
759 0 : printf( "(%s) bank_hash: %s\n"
760 0 : "(%s) bank_hash: %s\n",
761 0 : diff->file_paths[0], FD_BASE58_ENC_32_ALLOCA( pre[0].bank_hash ),
762 0 : diff->file_paths[1], FD_BASE58_ENC_32_ALLOCA( pre[1].bank_hash ) );
763 0 : }
764 :
765 0 : if( 0!=memcmp( pre[0].account_delta_hash, pre[1].account_delta_hash, 32UL ) ) {
766 0 : printf( "(%s) account_delta_hash: %s\n"
767 0 : "(%s) account_delta_hash: %s\n",
768 0 : diff->file_paths[0], FD_BASE58_ENC_32_ALLOCA( pre[0].account_delta_hash ),
769 0 : diff->file_paths[1], FD_BASE58_ENC_32_ALLOCA( pre[1].account_delta_hash ) );
770 0 : }
771 0 : if( 0!=memcmp( pre[0].accounts_lt_hash_checksum, pre[1].accounts_lt_hash_checksum, 32UL ) ) {
772 0 : printf( "(%s) accounts_lt_hash_checksum: %s\n"
773 0 : "(%s) accounts_lt_hash_checksum: %s\n",
774 0 : diff->file_paths[0], FD_BASE58_ENC_32_ALLOCA( pre[0].accounts_lt_hash_checksum ),
775 0 : diff->file_paths[1], FD_BASE58_ENC_32_ALLOCA( pre[1].accounts_lt_hash_checksum ) );
776 0 : }
777 0 : if( 0!=memcmp( pre[0].prev_bank_hash, pre[1].prev_bank_hash, 32UL ) ) {
778 0 : printf( "(%s) prev_bank_hash: %s\n"
779 0 : "(%s) prev_bank_hash: %s\n",
780 0 : diff->file_paths[0], FD_BASE58_ENC_32_ALLOCA( pre[0].prev_bank_hash ),
781 0 : diff->file_paths[1], FD_BASE58_ENC_32_ALLOCA( pre[1].prev_bank_hash ) );
782 0 : }
783 0 : if( 0!=memcmp( pre[0].poh_hash, pre[1].poh_hash, 32UL ) ) {
784 0 : printf( "(%s) poh_hash: %s\n"
785 0 : "(%s) poh_hash: %s\n",
786 0 : diff->file_paths[0], FD_BASE58_ENC_32_ALLOCA( pre[0].poh_hash ),
787 0 : diff->file_paths[1], FD_BASE58_ENC_32_ALLOCA( pre[1].poh_hash ) );
788 0 : }
789 0 : if( pre[0].signature_cnt != pre[1].signature_cnt ) {
790 0 : printf( "(%s) signature_cnt: %lu\n"
791 0 : "(%s) signature_cnt: %lu\n",
792 0 : diff->file_paths[0], pre[0].signature_cnt,
793 0 : diff->file_paths[1], pre[1].signature_cnt );
794 0 : }
795 0 : if( pre[0].account_cnt != pre[1].account_cnt ) {
796 0 : printf( "(%s) account_cnt: %lu\n"
797 0 : "(%s) account_cnt: %lu\n",
798 0 : diff->file_paths[0], pre[0].account_cnt,
799 0 : diff->file_paths[1], pre[1].account_cnt );
800 0 : }
801 0 : printf( "\n" );
802 :
803 0 : int has_account_tbl_mismatch = 0;
804 0 : if( diff->verbose >= 3 ) {
805 0 : fd_scratch_push();
806 0 : has_account_tbl_mismatch = fd_solcap_diff_account_tbl( diff );
807 0 : fd_scratch_pop();
808 0 : }
809 :
810 0 : return has_any_mismatch || has_account_tbl_mismatch;
811 0 : }
812 :
813 : /* Diffs two transaction results with each other. */
814 : static void
815 0 : fd_solcap_transaction_fd_diff( fd_solcap_txn_differ_t * txn_differ ) {
816 0 : if ( FD_UNLIKELY( memcmp( txn_differ->transaction[0].txn_sig,
817 0 : txn_differ->transaction[1].txn_sig, 32UL ) != 0 ) ) {
818 : /* Transactions don't line up. */
819 0 : FD_LOG_WARNING(( "Transaction signatures are different for slot=%lu, signature=(%s != %s)."
820 0 : "It is possible that either the transactions are out of order or some transactions are missing.",
821 0 : txn_differ->transaction[0].slot,
822 0 : FD_BASE58_ENC_64_ALLOCA( txn_differ->transaction[0].txn_sig ),
823 0 : FD_BASE58_ENC_64_ALLOCA( txn_differ->transaction[1].txn_sig ) ));
824 0 : }
825 0 : else {
826 0 : bool diff_txns = txn_differ->transaction[0].fd_txn_err != txn_differ->transaction[1].fd_txn_err;
827 0 : bool diff_cus = txn_differ->transaction[0].fd_cus_used != txn_differ->transaction[1].fd_cus_used;
828 0 : bool diff_instr_err_idx = txn_differ->transaction[0].instr_err_idx != txn_differ->transaction[1].instr_err_idx;
829 0 : if ( diff_txns || diff_cus ) {
830 0 : printf(
831 0 : "\nslot: %lu\n"
832 0 : "txn_sig: '%s'\n",
833 0 : txn_differ->transaction[0].slot,
834 0 : FD_BASE58_ENC_64_ALLOCA( txn_differ->transaction[0].txn_sig) );
835 0 : }
836 0 : if ( diff_txns ) {
837 0 : printf(
838 0 : " (+) txn_err: %d\n"
839 0 : " (-) txn_err: %d\n",
840 0 : txn_differ->transaction[0].fd_txn_err,
841 0 : txn_differ->transaction[1].fd_txn_err );
842 0 : }
843 0 : if ( diff_cus ) {
844 0 : printf(
845 0 : " (+) cus_used: %lu\n"
846 0 : " (-) cus_used: %lu\n",
847 0 : txn_differ->transaction[0].fd_cus_used,
848 0 : txn_differ->transaction[1].fd_cus_used );
849 0 : }
850 0 : if ( diff_instr_err_idx ) {
851 0 : printf(
852 0 : " (+) instr_err_idx: %d\n"
853 0 : " (-) instr_err_idx: %d\n",
854 0 : txn_differ->transaction[0].instr_err_idx,
855 0 : txn_differ->transaction[1].instr_err_idx );
856 0 : }
857 0 : }
858 0 : }
859 :
860 : /* Diffs firedancer transaction result with solana's result iff it is included
861 : in the solcap. The solana result comes from rocksdb. This diff is generated
862 : from just one fd_solcap_Transaction object */
863 : static void
864 : fd_solcap_transaction_solana_diff( fd_solcap_Transaction * transaction,
865 : ulong start_slot,
866 0 : ulong end_slot ) {
867 0 : if ( transaction->slot < start_slot || transaction->slot > end_slot ) {
868 0 : return;
869 0 : }
870 :
871 0 : if ( transaction->solana_txn_err == ULONG_MAX && transaction->solana_cus_used == ULONG_MAX ) {
872 : /* If solana_txn_err and solana_cus_used are both not populated, don't print diff */
873 0 : return;
874 0 : } else if ( transaction->solana_txn_err == ULONG_MAX ) {
875 : /* Print diff if the solana_txn_err is not set (txn executed successfully) */
876 0 : transaction->solana_txn_err = 0;
877 0 : }
878 :
879 : /* Only print a diff if cus or transaction result is different */
880 0 : if( !!( transaction->fd_txn_err ) != !!( transaction->solana_txn_err ) ||
881 0 : transaction->fd_cus_used != transaction->solana_cus_used ) {
882 0 : printf(
883 0 : "slot: %lu\n"
884 0 : "txn_sig: '%s'\n"
885 0 : " (+) txn_err: %d\n"
886 0 : " (-) solana_txn_err: %lu\n"
887 0 : " (+) cus_used: %lu\n"
888 0 : " (-) solana_cus_used: %lu\n"
889 0 : " instr_err_idx: %d\n"
890 0 : " explorer: 'https://explorer.solana.com/tx/%s'\n"
891 0 : " solscan: 'https://solscan.io/tx/%s'\n"
892 0 : " solanafm: 'https://solana.fm/tx/%s'\n",
893 0 : transaction->slot,
894 0 : FD_BASE58_ENC_64_ALLOCA( transaction->txn_sig ),
895 0 : transaction->fd_txn_err,
896 0 : transaction->solana_txn_err,
897 0 : transaction->fd_cus_used,
898 0 : transaction->solana_cus_used,
899 0 : transaction->instr_err_idx,
900 0 : FD_BASE58_ENC_64_ALLOCA( transaction->txn_sig ),
901 0 : FD_BASE58_ENC_64_ALLOCA( transaction->txn_sig ),
902 0 : FD_BASE58_ENC_64_ALLOCA( transaction->txn_sig ) );
903 0 : }
904 0 : }
905 :
906 : static void
907 0 : fd_solcap_get_transaction_from_iter( fd_solcap_txn_differ_t * differ, ulong idx ) {
908 0 : if ( fd_solcap_chunk_iter_done( &differ->iter[idx] ) )
909 0 : return;
910 :
911 0 : fd_solcap_chunk_t const * chunk = fd_solcap_chunk_iter_item( &differ->iter[idx] );
912 :
913 0 : if( FD_UNLIKELY( 0!=fseek( differ->file[idx], differ->chunk_gaddr[idx] + (long)chunk->meta_coff, SEEK_SET ) ) ) {
914 0 : FD_LOG_ERR(( "fseek transaction meta failed (%d-%s)", errno, strerror( errno ) ));
915 0 : }
916 0 : if( FD_UNLIKELY( chunk->meta_sz != fread( &differ->meta_buf[idx], 1UL, chunk->meta_sz, differ->file[idx] ) ) ) {
917 0 : FD_LOG_ERR(( "fread transaction meta failed (%d-%s)", errno, strerror( errno ) ));
918 0 : }
919 :
920 0 : pb_istream_t stream = pb_istream_from_buffer( differ->meta_buf[idx], chunk->meta_sz );
921 0 : if( FD_UNLIKELY( !pb_decode( &stream, fd_solcap_Transaction_fields, &differ->transaction[idx] ) ) ) {
922 0 : FD_LOG_HEXDUMP_DEBUG(( "transaction meta", differ->meta_buf[idx], chunk->meta_sz ));
923 0 : FD_LOG_ERR(( "pb_decode transaction meta failed (%s)", PB_GET_ERROR(&stream) ));
924 0 : }
925 0 : }
926 :
927 : static void
928 0 : fd_solcap_transaction_iter( fd_solcap_txn_differ_t * txn_differ, ulong idx ) {
929 0 : while ( !fd_solcap_chunk_iter_done( &txn_differ->iter[idx] ) ) {
930 0 : txn_differ->chunk_gaddr[idx] = fd_solcap_chunk_iter_find( &txn_differ->iter[idx], FD_SOLCAP_V1_TRXN_MAGIC );
931 0 : fd_solcap_get_transaction_from_iter( txn_differ, idx );
932 0 : fd_solcap_transaction_solana_diff( &txn_differ->transaction[idx], 0, ULONG_MAX );
933 0 : }
934 0 : }
935 :
936 : static void
937 0 : fd_solcap_txn_differ_advance( fd_solcap_txn_differ_t * txn_differ ) {
938 0 : while ( !fd_solcap_chunk_iter_done( &txn_differ->iter[0] ) &&
939 0 : !fd_solcap_chunk_iter_done( &txn_differ->iter[1] ) ) {
940 : /* Diff transactions against both solana result (rocksdb) and against each other */
941 0 : fd_solcap_transaction_fd_diff( txn_differ );
942 0 : fd_solcap_transaction_solana_diff( &txn_differ->transaction[0], 0, ULONG_MAX );
943 0 : txn_differ->chunk_gaddr[0] = fd_solcap_chunk_iter_find( &txn_differ->iter[0], FD_SOLCAP_V1_TRXN_MAGIC );
944 0 : txn_differ->chunk_gaddr[1] = fd_solcap_chunk_iter_find( &txn_differ->iter[1], FD_SOLCAP_V1_TRXN_MAGIC );
945 0 : fd_solcap_get_transaction_from_iter( txn_differ, 0 );
946 0 : fd_solcap_get_transaction_from_iter( txn_differ, 1 );
947 0 : }
948 0 : }
949 :
950 0 : static void fd_solcap_txn_differ_sync( fd_solcap_txn_differ_t * txn_differ ) {
951 : /* Find first transaction for both files */
952 0 : for( int i=0; i<2; i++ ) {
953 0 : txn_differ->chunk_gaddr[i] = fd_solcap_chunk_iter_find( &txn_differ->iter[i], FD_SOLCAP_V1_TRXN_MAGIC );
954 0 : if( FD_UNLIKELY( txn_differ->chunk_gaddr[i] < 0L ) ) {
955 0 : int err = fd_solcap_chunk_iter_err( &txn_differ->iter[i] );
956 0 : if( err == 0 ) break;
957 0 : FD_LOG_ERR(( "fd_solcap_chunk_iter_next() failed (%d-%s)", err, strerror( err ) ));
958 0 : }
959 0 : }
960 :
961 : /* Get first transaction on both */
962 0 : fd_solcap_get_transaction_from_iter( txn_differ, 0 );
963 0 : fd_solcap_get_transaction_from_iter( txn_differ, 1 );
964 :
965 0 : for(;;) {
966 : /* If one is done but not the other, iterate through the rest of the
967 : transactions in order to generate a diff against solana's transactions */
968 0 : if( fd_solcap_chunk_iter_done( &txn_differ->iter[0] ) ) {
969 0 : fd_solcap_transaction_iter( txn_differ, 1 );
970 0 : break;
971 0 : } else if( fd_solcap_chunk_iter_done( &txn_differ->iter[1] ) ) {
972 0 : fd_solcap_transaction_iter( txn_differ, 0 );
973 0 : break;
974 0 : }
975 :
976 : /* Otherwise, try to sync up the two files, printing any solana diffs along the way */
977 0 : if( txn_differ->transaction[0].slot == txn_differ->transaction[1].slot ) {
978 0 : fd_solcap_txn_differ_advance( txn_differ );
979 0 : } else if( txn_differ->transaction[0].slot < txn_differ->transaction[1].slot ) {
980 : /* Advance index 0 only */
981 0 : fd_solcap_transaction_solana_diff( &txn_differ->transaction[0], 0, ULONG_MAX );
982 0 : txn_differ->chunk_gaddr[0] = fd_solcap_chunk_iter_find( &txn_differ->iter[0], FD_SOLCAP_V1_TRXN_MAGIC );
983 0 : fd_solcap_get_transaction_from_iter( txn_differ, 0 );
984 0 : } else if( txn_differ->transaction[1].slot < txn_differ->transaction[0].slot ) {
985 : /* Advance index 1 only */
986 0 : fd_solcap_transaction_solana_diff( &txn_differ->transaction[1], 0, ULONG_MAX );
987 0 : txn_differ->chunk_gaddr[1] = fd_solcap_chunk_iter_find( &txn_differ->iter[1], FD_SOLCAP_V1_TRXN_MAGIC );
988 0 : fd_solcap_get_transaction_from_iter( txn_differ, 1 );
989 0 : }
990 0 : }
991 0 : }
992 :
993 0 : static void fd_solcap_transaction_diff( FILE * file_zero, FILE * file_one ) {
994 :
995 0 : if ( FD_UNLIKELY( fseek( file_zero, 0, SEEK_SET ) != 0 ) ) {
996 0 : FD_LOG_ERR(( "fseek to start of file failed (%d-%s)", errno, strerror( errno ) ));
997 0 : }
998 0 : if ( FD_UNLIKELY( fseek( file_one, 0, SEEK_SET ) != 0 ) ) {
999 0 : FD_LOG_ERR(( "fseek to start of file failed (%d-%s)", errno, strerror( errno ) ));
1000 0 : }
1001 :
1002 : /* Read file header and seek to first chunk to begin interation */
1003 0 : fd_solcap_fhdr_t fhdr_zero[1];
1004 0 : fd_solcap_fhdr_t fhdr_one[1];
1005 0 : ulong n_zero = fread( fhdr_zero, sizeof(fd_solcap_fhdr_t), 1UL, file_zero );
1006 0 : ulong n_one = fread( fhdr_one, sizeof(fd_solcap_fhdr_t), 1UL, file_one );
1007 :
1008 0 : if ( FD_UNLIKELY( n_zero != 1UL ) ) {
1009 0 : FD_LOG_ERR(( "fread file header failed (%d-%s)", errno, strerror( errno ) ));
1010 0 : }
1011 0 : if ( FD_UNLIKELY( n_one != 1UL ) ) {
1012 0 : FD_LOG_ERR(( "fread file header failed (%d-%s)", errno, strerror( errno ) ));
1013 0 : }
1014 0 : int err;
1015 0 : err = fseek( file_zero, (long)fhdr_zero->chunk0_foff - (long)sizeof(fd_solcap_fhdr_t), SEEK_CUR );
1016 0 : if( FD_UNLIKELY( err < 0L ) ) {
1017 0 : FD_LOG_ERR(( "fseek chunk0 failed (%d-%s)", errno, strerror( errno ) ));
1018 0 : }
1019 0 : err = fseek( file_one, (long)fhdr_one->chunk0_foff - (long)sizeof(fd_solcap_fhdr_t), SEEK_CUR );
1020 0 : if( FD_UNLIKELY( err < 0L ) ) {
1021 0 : FD_LOG_ERR(( "fseek chunk0 failed (%d-%s)", errno, strerror( errno ) ));
1022 0 : }
1023 :
1024 : /* Setup txn_differ */
1025 0 : fd_solcap_txn_differ_t txn_differ;
1026 0 : txn_differ.file[0] = file_zero;
1027 0 : txn_differ.file[1] = file_one;
1028 0 : fd_solcap_chunk_iter_new( &txn_differ.iter[0], file_zero );
1029 0 : fd_solcap_chunk_iter_new( &txn_differ.iter[1], file_one );
1030 :
1031 : /* Iterate and diff throught the transactions */
1032 0 : fd_solcap_txn_differ_sync( &txn_differ );
1033 0 : }
1034 :
1035 : void
1036 0 : fd_solcap_one_file_transaction_diff( FILE * file, ulong start_slot, ulong end_slot ) {
1037 : /* Open and read the header */
1038 0 : fd_solcap_fhdr_t fhdr[1];
1039 0 : ulong n = fread( fhdr, sizeof(fd_solcap_fhdr_t), 1UL, file );
1040 0 : if( FD_UNLIKELY( n!=1UL ) ) {
1041 0 : FD_LOG_ERR(( "fread file header failed (%d-%s)", errno, strerror( errno ) ));
1042 0 : }
1043 :
1044 : /* Seek to the first chunk */
1045 0 : int err = fseek( file, (long)fhdr->chunk0_foff - (long)sizeof(fd_solcap_fhdr_t), SEEK_CUR );
1046 0 : if( FD_UNLIKELY( err<0L ) ) {
1047 0 : FD_LOG_ERR(( "fseek chunk0 failed (%d-%s)", errno, strerror( errno ) ));
1048 0 : }
1049 :
1050 : /* Iterate through the chunks diffing the trnasactions */
1051 0 : fd_solcap_chunk_iter_t iter[1];
1052 0 : fd_solcap_chunk_iter_new( iter, file );
1053 0 : while( !fd_solcap_chunk_iter_done( iter ) ) {
1054 0 : long chunk_gaddr = fd_solcap_chunk_iter_find( iter, FD_SOLCAP_V1_TRXN_MAGIC );
1055 0 : if( FD_UNLIKELY( chunk_gaddr<0L ) ) {
1056 0 : int err = fd_solcap_chunk_iter_err( iter );
1057 0 : if( err==0 ) break;
1058 0 : FD_LOG_ERR(( "fd_solcap_chunk_iter_next() failed (%d-%s)", err, strerror( err ) ));
1059 0 : }
1060 :
1061 0 : fd_solcap_chunk_t const * chunk = fd_solcap_chunk_iter_item( iter );
1062 0 : if( FD_UNLIKELY( !chunk ) ) FD_LOG_ERR(( "fd_solcap_chunk_item() failed" ));
1063 :
1064 : /* Read transaction meta */
1065 :
1066 0 : uchar meta_buf[ 128UL ];
1067 0 : if( FD_UNLIKELY( 0!=fseek( file, chunk_gaddr + (long)chunk->meta_coff, SEEK_SET ) ) ) {
1068 0 : FD_LOG_ERR(( "fseek transaction meta failed (%d-%s)", errno, strerror( errno ) ));
1069 0 : }
1070 0 : if( FD_UNLIKELY( chunk->meta_sz != fread( meta_buf, 1UL, chunk->meta_sz, file ) ) ) {
1071 0 : FD_LOG_ERR(( "fread transaction meta failed (%d-%s)", errno, strerror( errno ) ));
1072 0 : }
1073 :
1074 : /* Deserialize transaction meta */
1075 :
1076 0 : pb_istream_t stream = pb_istream_from_buffer( meta_buf, chunk->meta_sz );
1077 :
1078 0 : fd_solcap_Transaction meta;
1079 0 : if( FD_UNLIKELY( !pb_decode( &stream, fd_solcap_Transaction_fields, &meta ) ) ) {
1080 0 : FD_LOG_HEXDUMP_DEBUG(( "transaction meta", meta_buf, chunk->meta_sz ));
1081 0 : FD_LOG_ERR(( "pb_decode transaction meta failed (%s)", PB_GET_ERROR(&stream) ));
1082 0 : }
1083 :
1084 0 : if( meta.slot < start_slot || meta.slot > end_slot ) {
1085 0 : continue;
1086 0 : }
1087 :
1088 0 : fd_solcap_transaction_solana_diff( &meta, start_slot, end_slot );
1089 0 : }
1090 0 : }
1091 :
1092 : static void
1093 0 : usage( void ) {
1094 : fprintf( stderr,
1095 0 : "Usage: fd_solcap_diff [options] {FILE1} {FILE2}\n"
1096 0 : "\n"
1097 0 : "Imports a runtime capture file from JSON.\n"
1098 0 : "\n"
1099 0 : "Options:\n"
1100 0 : " --page-sz {gigantic|huge|normal} Page size\n"
1101 0 : " --page-cnt {count} Page count\n"
1102 0 : " --scratch-mb 1024 Scratch mem MiB\n"
1103 0 : " -v 1 Diff verbosity\n"
1104 0 : " --dump-dir {dir} Dump directory\n"
1105 0 : " --start-slot {slot} Start slot\n"
1106 0 : " --end-slot {slot} End slot\n"
1107 0 : "\n" );
1108 0 : }
1109 :
1110 : int
1111 : main( int argc,
1112 : char ** argv ) {
1113 : fd_boot( &argc, &argv );
1114 :
1115 : /* Command line handling */
1116 :
1117 : for( int i=1; i<argc; i++ ) {
1118 : if( 0==strcmp( argv[i], "--help" ) ) {
1119 : usage();
1120 : return 0;
1121 : }
1122 : }
1123 :
1124 : char const * _page_sz = fd_env_strip_cmdline_cstr ( &argc, &argv, "--page-sz", NULL, "gigantic" );
1125 : ulong page_cnt = fd_env_strip_cmdline_ulong( &argc, &argv, "--page-cnt", NULL, 2UL );
1126 : ulong scratch_mb = fd_env_strip_cmdline_ulong( &argc, &argv, "--scratch-mb", NULL, 1024UL );
1127 : int verbose = fd_env_strip_cmdline_int ( &argc, &argv, "-v", NULL, 1 );
1128 : char const * dump_dir = fd_env_strip_cmdline_cstr ( &argc, &argv, "--dump-dir", NULL, "dump" );
1129 : ulong start_slot = fd_env_strip_cmdline_ulong( &argc, &argv, "--start-slot", NULL, 0UL );
1130 : ulong end_slot = fd_env_strip_cmdline_ulong( &argc, &argv, "--end-slot", NULL, ULONG_MAX );
1131 :
1132 : ulong page_sz = fd_cstr_to_shmem_page_sz( _page_sz );
1133 : if( FD_UNLIKELY( !page_sz ) ) FD_LOG_ERR(( "unsupported --page-sz" ));
1134 :
1135 : char const * cap_path[2] = {0};
1136 : int caps_found = 0;
1137 :
1138 : for( int i=1; i<argc; i++ ) {
1139 : if( 0==strncmp( argv[i], "--", 2 ) ) continue;
1140 : if( caps_found>=2 ) { usage(); return 1; }
1141 : cap_path[ caps_found++ ] = argv[i];
1142 : }
1143 :
1144 : if( caps_found==1 ) { /* Support one file being passed in to see transaction diff */
1145 : cap_path[ caps_found++ ] = cap_path[ 0 ];
1146 : }
1147 : else if( caps_found!=2 ) {
1148 : fprintf( stderr, "ERROR: expected 2 arguments, got %d\n", argc-1 );
1149 : usage();
1150 : return 1;
1151 : }
1152 :
1153 : /* Acquire workspace */
1154 :
1155 : fd_wksp_t * wksp = fd_wksp_new_anonymous( page_sz, page_cnt, fd_log_cpu_id(), "wksp", 0UL );
1156 : if( FD_UNLIKELY( !wksp ) ) FD_LOG_ERR(( "fd_wksp_new_anonymous() failed" ));
1157 :
1158 : /* Create scratch allocator */
1159 :
1160 : ulong smax = scratch_mb << 20;
1161 : void * smem = fd_wksp_alloc_laddr( wksp, fd_scratch_smem_align(), smax, 1UL );
1162 : if( FD_UNLIKELY( !smem ) ) FD_LOG_ERR(( "Failed to alloc scratch mem" ));
1163 :
1164 : # define SCRATCH_DEPTH (4UL)
1165 : ulong fmem[ SCRATCH_DEPTH ] __attribute((aligned(FD_SCRATCH_FMEM_ALIGN)));
1166 :
1167 : fd_scratch_attach( smem, fmem, smax, SCRATCH_DEPTH );
1168 :
1169 : /* Open capture files for reading */
1170 :
1171 : FILE * cap_file[2] = {0};
1172 : cap_file[0] = fopen( cap_path[0], "rb" );
1173 : cap_file[1] = strcmp( cap_path[0], cap_path[1] ) ? fopen( cap_path[1], "rb" ) : cap_file[0];
1174 :
1175 : if ( FD_UNLIKELY( !cap_file[0] ) )
1176 : FD_LOG_ERR(( "fopen failed (%d-%s) on file=%s", errno, strerror( errno ), cap_path[0] ));
1177 : if ( FD_UNLIKELY( !cap_file[1] ) )
1178 : FD_LOG_ERR(( "fopen failed (%d-%s) on file=%s", errno, strerror( errno ), cap_path[1] ));
1179 :
1180 : /* Create dump dir */
1181 :
1182 : if( mkdir( dump_dir, 0777 )<0 && errno!=EEXIST )
1183 : FD_LOG_ERR(( "mkdir failed (%d-%s)", errno, strerror( errno ) ));
1184 : int dump_dir_fd = open( dump_dir, O_DIRECTORY );
1185 : if( FD_UNLIKELY( dump_dir_fd<0 ) )
1186 : FD_LOG_ERR(( "open(%s) failed (%d-%s)", dump_dir, errno, strerror( errno ) ));
1187 :
1188 : /* Handle the one file case before diffing for accounts/hashes */
1189 : if( cap_file[0] == cap_file[1] ) {
1190 : FD_LOG_NOTICE(( "Only one file was passed in. Will only print transaction diffs." ));
1191 : fd_solcap_one_file_transaction_diff( cap_file[0], start_slot, end_slot );
1192 :
1193 : /* Cleanup*/
1194 : close( dump_dir_fd );
1195 : fclose( cap_file[0] );
1196 : FD_TEST( fd_scratch_frame_used()==0UL );
1197 : fd_wksp_free_laddr( fd_scratch_detach( NULL ) );
1198 : fd_halt();
1199 : return 0;
1200 : }
1201 :
1202 : /* Create differ */
1203 :
1204 : fd_solcap_differ_t diff[1];
1205 :
1206 : /* Copy over up to last 16 chars */
1207 : char file_name_zero[SOLCAP_FILE_NAME_LEN + 1];
1208 : char file_name_one[SOLCAP_FILE_NAME_LEN + 1];
1209 : char * normalized_file_paths[2] = {file_name_zero, file_name_one};
1210 : normalize_filename( cap_path[0], normalized_file_paths[0], '+' );
1211 : normalize_filename( cap_path[1], normalized_file_paths[1], '-' );
1212 :
1213 : printf( "++%s\n", normalized_file_paths[0] );
1214 : printf( "--%s\n\n", normalized_file_paths[1] );
1215 :
1216 : if( FD_UNLIKELY( !fd_solcap_differ_new( diff, cap_file, (const char **)normalized_file_paths ) ) )
1217 : return 1;
1218 : diff->verbose = verbose;
1219 : diff->dump_dir = dump_dir;
1220 : diff->dump_dir_fd = dump_dir_fd;
1221 : int res = fd_solcap_differ_sync( diff, start_slot, end_slot );
1222 : if( res <0 ) FD_LOG_ERR(( "fd_solcap_differ_sync failed (%d-%s)",
1223 : -res, strerror( -res ) ));
1224 : if( res==0 ) FD_LOG_ERR(( "Captures don't share any slots" ));
1225 :
1226 : /* Diff each block for accounts and hashes */
1227 : int found_mismatch = 0;
1228 : for(;;) {
1229 : if( FD_UNLIKELY( fd_solcap_diff_bank( diff ) ) ) {
1230 : found_mismatch = 1;
1231 : break;
1232 : }
1233 : printf( "Slot %10lu: OK\n", diff->preimage[0].slot );
1234 : /* Advance to next slot. */
1235 : int res = fd_solcap_differ_sync( diff, start_slot, end_slot );
1236 : if( FD_UNLIKELY( res<0 ) )
1237 : FD_LOG_ERR(( "fd_solcap_differ_sync failed (%d-%s)",
1238 : -res, strerror( -res ) ));
1239 : if( res==0 ) break;
1240 : }
1241 :
1242 : /* Check both files for transaction and produce a diff if possible. If both
1243 : files contain transaction info, this will produce a diff between the two
1244 : files. If one of the files contains the solana transaction info, then we
1245 : will also print the diffs between the solana and firedancer execution. */
1246 : if ( verbose >= 4 ) {
1247 : printf( "\nTransaction diffs:\n" );
1248 : fd_solcap_transaction_diff( cap_file[0], cap_file[1] );
1249 : }
1250 :
1251 : /* Cleanup */
1252 :
1253 : close( dump_dir_fd );
1254 : fclose( cap_file[1] );
1255 : fclose( cap_file[0] );
1256 : FD_TEST( fd_scratch_frame_used()==0UL );
1257 : fd_wksp_free_laddr( fd_scratch_detach( NULL ) );
1258 : fd_halt();
1259 : return found_mismatch;
1260 : }
|
