🥇Utreexo: ಅನೇಕ UTXO ಬಿಟ್‌ಕಾಯಿನ್ ಅನ್ನು ಸಂಕುಚಿತಗೊಳಿಸುವುದು

ಹಲೋ, ಹಬ್ರ್!

ಬಿಟ್‌ಕಾಯಿನ್ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ, ಎಲ್ಲಾ ನೋಡ್‌ಗಳು, ಒಮ್ಮತದ ಮೂಲಕ, UTXO ಗಳ ಗುಂಪನ್ನು ಒಪ್ಪಿಕೊಳ್ಳುತ್ತವೆ: ಖರ್ಚು ಮಾಡಲು ಎಷ್ಟು ನಾಣ್ಯಗಳು ಲಭ್ಯವಿದೆ, ಯಾರಿಗೆ ನಿಖರವಾಗಿ ಮತ್ತು ಯಾವ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ. UTXO ಸೆಟ್ ಎನ್ನುವುದು ವ್ಯಾಲಿಡೇಟರ್ ನೋಡ್‌ಗೆ ಅಗತ್ಯವಿರುವ ಕನಿಷ್ಠ ಡೇಟಾ ಸೆಟ್ ಆಗಿದೆ, ಅದು ಇಲ್ಲದೆ ಒಳಬರುವ ವಹಿವಾಟುಗಳ ಸಿಂಧುತ್ವವನ್ನು ಮತ್ತು ಅವುಗಳನ್ನು ಹೊಂದಿರುವ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ನೋಡ್‌ಗೆ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

ಈ ನಿಟ್ಟಿನಲ್ಲಿ, ಈ ಸೆಟ್‌ನ ಸಂಗ್ರಹವಾಗಿರುವ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು, ಭದ್ರತಾ ಖಾತರಿಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳದೆ ಅದನ್ನು ಸಂಕುಚಿತಗೊಳಿಸಲು ಸಾಧ್ಯವಿರುವ ಎಲ್ಲ ರೀತಿಯಲ್ಲಿ ಪ್ರಯತ್ನಗಳನ್ನು ಮಾಡಲಾಗುತ್ತಿದೆ. ಸಂಗ್ರಹಿಸಿದ ಡೇಟಾದ ಪರಿಮಾಣವು ಚಿಕ್ಕದಾಗಿದೆ, ವ್ಯಾಲಿಡೇಟರ್ ನೋಡ್‌ನ ಡಿಸ್ಕ್ ಸ್ಥಳಾವಕಾಶದ ಅವಶ್ಯಕತೆಗಳು ಕಡಿಮೆಯಾಗುತ್ತವೆ, ಇದು ವ್ಯಾಲಿಡೇಟರ್ ನೋಡ್ ಅನ್ನು ಅಗ್ಗವಾಗಿಸುತ್ತದೆ, ಇದು ನಿಮಗೆ ನೆಟ್‌ವರ್ಕ್ ಅನ್ನು ವಿಸ್ತರಿಸಲು ಮತ್ತು ಆ ಮೂಲಕ ನೆಟ್‌ವರ್ಕ್‌ನ ಸ್ಥಿರತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಈ ಪೋಸ್ಟ್‌ನಲ್ಲಿ ನಾವು ಸಹ-ಲೇಖಕರಿಂದ ಇತ್ತೀಚಿನ ಪ್ರಸ್ತಾಪದ ರಸ್ಟ್ ಮೂಲಮಾದರಿಯನ್ನು ಪೋಸ್ಟ್ ಮಾಡುತ್ತೇವೆ ಲೈಟ್ನಿಂಗ್ ನೆಟ್ವರ್ಕ್ ಪೇಪರ್, ಥಡ್ಡಿಯಸ್ ಡ್ರೈಜಾ - Utreexo: ಬಿಟ್‌ಕಾಯಿನ್ UTXO ಸೆಟ್‌ಗಾಗಿ ಹೊಂದುವಂತೆ ಡೈನಾಮಿಕ್ ಹ್ಯಾಶ್-ಆಧಾರಿತ ಸಂಚಯಕ, ಇದು ವ್ಯಾಲಿಡೇಟರ್ ನೋಡ್‌ಗಳಿಗೆ ಡಿಸ್ಕ್ ಜಾಗದ ಅವಶ್ಯಕತೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ.

ಸಮಸ್ಯೆ ಏನು?

ಬಿಟ್‌ಕಾಯಿನ್‌ನ ದೀರ್ಘಕಾಲಿಕ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಅದರ ಸ್ಕೇಲೆಬಿಲಿಟಿ. "ನಿಮ್ಮ ಸ್ವಂತ ಬ್ಯಾಂಕ್" ಕಲ್ಪನೆಯು ನೆಟ್‌ವರ್ಕ್ ಭಾಗವಹಿಸುವವರು ಬಳಕೆಗೆ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ನಿಧಿಗಳ ದಾಖಲೆಗಳನ್ನು ಇಟ್ಟುಕೊಳ್ಳುವ ಅಗತ್ಯವಿದೆ. ಬಿಟ್‌ಕಾಯಿನ್‌ನಲ್ಲಿ, ಲಭ್ಯವಿರುವ ಹಣವನ್ನು ಖರ್ಚು ಮಾಡದ ಉತ್ಪನ್ನಗಳ ಒಂದು ಸೆಟ್ ಆಗಿ ವ್ಯಕ್ತಪಡಿಸಲಾಗುತ್ತದೆ - UTXO- ಸೆಟ್. ಇದು ನಿರ್ದಿಷ್ಟವಾಗಿ ಅರ್ಥಗರ್ಭಿತ ಪ್ರಾತಿನಿಧ್ಯವಲ್ಲದಿದ್ದರೂ, ಪ್ರತಿ "ವಾಲೆಟ್" ಒಂದು ಪ್ರತ್ಯೇಕ ನಮೂದಾಗಿ "ಸಮತೋಲನ" ಹೊಂದಿರುವ ಪ್ರಾತಿನಿಧ್ಯದ ಮೇಲೆ ಅನುಷ್ಠಾನದ ಕಾರ್ಯಕ್ಷಮತೆಯ ದೃಷ್ಟಿಯಿಂದ ಇದು ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ ಮತ್ತು ಗೌಪ್ಯತೆಯನ್ನು ಸೇರಿಸುತ್ತದೆ (ಉದಾ. CoinJoin).

ವಹಿವಾಟುಗಳ ಇತಿಹಾಸ (ಬ್ಲಾಕ್‌ಚೈನ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ) ಮತ್ತು ಸಿಸ್ಟಮ್‌ನ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಬಿಟ್‌ಕಾಯಿನ್ ವಹಿವಾಟಿನ ಇತಿಹಾಸವು ಪ್ರಸ್ತುತ ಸುಮಾರು 200 GB ಡಿಸ್ಕ್ ಜಾಗವನ್ನು ಆಕ್ರಮಿಸಿಕೊಂಡಿದೆ ಮತ್ತು ಬೆಳೆಯುತ್ತಲೇ ಇದೆ. ಆದಾಗ್ಯೂ, ಸಿಸ್ಟಮ್ ಸ್ಥಿತಿಯು 4 GB ಯ ಕ್ರಮದಲ್ಲಿ ತುಂಬಾ ಚಿಕ್ಕದಾಗಿದೆ ಮತ್ತು ಯಾರಾದರೂ ಪ್ರಸ್ತುತ ನಾಣ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ ಎಂಬ ಅಂಶವನ್ನು ಮಾತ್ರ ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಈ ಡೇಟಾದ ಪ್ರಮಾಣವು ಕಾಲಾನಂತರದಲ್ಲಿ ಹೆಚ್ಚಾಗುತ್ತದೆ, ಆದರೆ ಹೆಚ್ಚು ನಿಧಾನಗತಿಯಲ್ಲಿ ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಕಡಿಮೆಯಾಗುತ್ತದೆ (ಸಿಡಿಪಿವಿ ನೋಡಿ).

ಖಾಸಗಿ ಕೀಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಯಾವುದೇ ಕನಿಷ್ಠ ಸ್ಥಿತಿಯನ್ನು (UTXO-ಸೆಟ್) ಸಂಗ್ರಹಿಸುವ ಸಾಮರ್ಥ್ಯಕ್ಕಾಗಿ ಲೈಟ್ ಕ್ಲೈಂಟ್‌ಗಳು (SPV ಗಳು) ವ್ಯಾಪಾರ ಭದ್ರತೆ ಖಾತರಿಗಳು.

UTXO ಮತ್ತು UTXO-ಸೆಟ್

UTXO (ಅನ್‌ಸ್ಪೆಂಟ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಔಟ್‌ಪುಟ್) ಎಂಬುದು ಖರ್ಚು ಮಾಡದ ವಹಿವಾಟು ಔಟ್‌ಪುಟ್ ಆಗಿದೆ, ವಹಿವಾಟಿನಲ್ಲಿ ವರ್ಗಾವಣೆಯಾದ ಪ್ರತಿ ಸತೋಶಿಯ ಪ್ರಯಾಣದ ಅಂತಿಮ ಹಂತವಾಗಿದೆ. ಖರ್ಚು ಮಾಡದ ಔಟ್‌ಪುಟ್‌ಗಳು ಹೊಸ ವಹಿವಾಟುಗಳ ಒಳಹರಿವು ಆಗುತ್ತವೆ ಮತ್ತು ಹೀಗೆ ಖರ್ಚು ಮಾಡಲಾಗುತ್ತದೆ (ಖರ್ಚು) ಮತ್ತು UTXO-ಸೆಟ್‌ನಿಂದ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ.

ಹೊಸ UTXO ಗಳನ್ನು ಯಾವಾಗಲೂ ವಹಿವಾಟುಗಳಿಂದ ರಚಿಸಲಾಗುತ್ತದೆ:

ಇನ್‌ಪುಟ್‌ಗಳಿಲ್ಲದ coinbase ವಹಿವಾಟುಗಳು: ಗಣಿಗಾರರು ನಾಣ್ಯಗಳನ್ನು ನೀಡಿದಾಗ ಹೊಸ UTXOಗಳನ್ನು ರಚಿಸಿ
ನಿಯಮಿತ ವಹಿವಾಟುಗಳು: ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ UTXO ಗಳ ನಿರ್ದಿಷ್ಟ ಸೆಟ್ ಅನ್ನು ಖರ್ಚು ಮಾಡುವಾಗ ಹೊಸ UTXO ಗಳನ್ನು ರಚಿಸಿ

UTXO ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆ:

ವ್ಯಾಲೆಟ್‌ಗಳು ಈ ವ್ಯಾಲೆಟ್‌ಗೆ ಲಭ್ಯವಿರುವ UTXO ಮೊತ್ತದ ಆಧಾರದ ಮೇಲೆ ಖರ್ಚು ಮಾಡಲು ಲಭ್ಯವಿರುವ ನಾಣ್ಯಗಳ ಸಂಖ್ಯೆಯನ್ನು (ಸಮತೋಲನ) ಎಣಿಕೆ ಮಾಡುತ್ತವೆ.

ಪ್ರತಿ ವ್ಯಾಲಿಡೇಟರ್ ನೋಡ್, ಡಬಲ್ ಖರ್ಚು ಪ್ರಯತ್ನಗಳನ್ನು ತಡೆಯಲು, ಸೆಟ್ ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಬೇಕು всех ಪರಿಶೀಲಿಸುವಾಗ UTXO ಪ್ರತಿಯೊಂದೂ ವ್ಯವಹಾರಗಳು ಪ್ರತಿಯೊಂದರಲ್ಲೂ ಬ್ಲಾಕ್.

ನೋಡ್ ತರ್ಕವನ್ನು ಹೊಂದಿರಬೇಕು:

UTXO-ಸೆಟ್‌ಗೆ ಸೇರ್ಪಡೆಗಳು
UTXO-ಸೆಟ್‌ನಿಂದ ಅಳಿಸುವಿಕೆಗಳು
ಒಂದು ಸೆಟ್‌ನಲ್ಲಿ ಒಂದೇ UTXO ಇರುವಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ

ಒಂದು ಸೆಟ್ ಬಗ್ಗೆ ಸಂಗ್ರಹವಾಗಿರುವ ಮಾಹಿತಿಯ ಅವಶ್ಯಕತೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮಾರ್ಗಗಳಿವೆ, ಅಂಶಗಳನ್ನು ಸೇರಿಸುವ ಮತ್ತು ತೆಗೆದುಹಾಕುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಉಳಿಸಿಕೊಂಡು, ಬಳಸಿಕೊಂಡು ಒಂದು ಸೆಟ್‌ನಲ್ಲಿನ ಅಂಶದ ಅಸ್ತಿತ್ವವನ್ನು ಪರಿಶೀಲಿಸಿ ಮತ್ತು ಸಾಬೀತುಪಡಿಸಿ ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕ್ ಸಂಚಯಕಗಳು.

UTXO ಗಾಗಿ ಬ್ಯಾಟರಿಗಳು

ಬಹು UTXO ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬ್ಯಾಟರಿಗಳನ್ನು ಬಳಸುವ ಕಲ್ಪನೆ ಚರ್ಚಿಸಲಾಯಿತು ಮೊದಲು.

UTXO-ಸೆಟ್ ಅನ್ನು ಫ್ಲೈನಲ್ಲಿ ನಿರ್ಮಿಸಲಾಗಿದೆ, ಆರಂಭಿಕ ಬ್ಲಾಕ್ ಡೌನ್‌ಲೋಡ್ (IBD) ಸಮಯದಲ್ಲಿ, ಪೂರ್ಣ ಮತ್ತು ಶಾಶ್ವತವಾಗಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ನೆಟ್‌ವರ್ಕ್‌ನ ಪ್ರತಿಯೊಂದು ಹೊಸ ಮತ್ತು ಸರಿಯಾದ ಬ್ಲಾಕ್‌ನಿಂದ ವಹಿವಾಟುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದ ನಂತರ ಅದರ ವಿಷಯಗಳು ಬದಲಾಗುತ್ತವೆ. ಈ ಪ್ರಕ್ರಿಯೆಗೆ ಸರಿಸುಮಾರು 200 GB ಬ್ಲಾಕ್ ಡೇಟಾವನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವ ಅಗತ್ಯವಿದೆ ಮತ್ತು ನೂರಾರು ಮಿಲಿಯನ್ ಡಿಜಿಟಲ್ ಸಿಗ್ನೇಚರ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಅಗತ್ಯವಿದೆ. IBD ಪ್ರಕ್ರಿಯೆಯು ಪೂರ್ಣಗೊಂಡ ನಂತರ, UTXO-ಸೆಟ್ ಸುಮಾರು 4 GB ಯನ್ನು ಆಕ್ರಮಿಸುತ್ತದೆ ಎಂಬುದು ಬಾಟಮ್ ಲೈನ್.

ಆದಾಗ್ಯೂ, ಸಂಚಯಕಗಳೊಂದಿಗೆ, ನಿಧಿಗಳಿಗೆ ಒಮ್ಮತದ ನಿಯಮಗಳನ್ನು ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕ್ ಪುರಾವೆಗಳ ಪರಿಶೀಲನೆ ಮತ್ತು ಉತ್ಪಾದನೆಗೆ ಕಡಿಮೆಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಲಭ್ಯವಿರುವ ನಿಧಿಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವ ಹೊರೆಯು ಅವರ ಅಸ್ತಿತ್ವ ಮತ್ತು ಮಾಲೀಕತ್ವದ ಪುರಾವೆಗಳನ್ನು ಒದಗಿಸುವ ಆ ನಿಧಿಗಳ ಮಾಲೀಕರಿಗೆ ವರ್ಗಾಯಿಸಲ್ಪಡುತ್ತದೆ.

ಸಂಚಯಕವನ್ನು ಒಂದು ಗುಂಪಿನ ಕಾಂಪ್ಯಾಕ್ಟ್ ಪ್ರಾತಿನಿಧ್ಯ ಎಂದು ಕರೆಯಬಹುದು. ಸಂಗ್ರಹಿಸಲಾದ ಪ್ರಾತಿನಿಧ್ಯದ ಗಾತ್ರವು ಸ್ಥಿರವಾಗಿರಬೇಕು , ಅಥವಾ ಸೆಟ್‌ನ ಕಾರ್ಡಿನಾಲಿಟಿ ಮತ್ತು ಅಂಶದ ಗಾತ್ರಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ ಉಪರೇಖೀಯವಾಗಿ ಹೆಚ್ಚಿಸಿ, ಉದಾಹರಣೆಗೆ , ಇಲ್ಲಿ n ಎಂಬುದು ಸಂಗ್ರಹಿಸಿದ ಗುಂಪಿನ ಕಾರ್ಡಿನಾಲಿಟಿ.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸಂಚಯಕವು ಒಂದು ಅಂಶವನ್ನು ಸೆಟ್‌ನಲ್ಲಿ (ಸೇರ್ಪಡೆ ಪುರಾವೆ) ಸೇರಿಸುವ ಪುರಾವೆಯನ್ನು ರಚಿಸಲು ಅನುಮತಿಸಬೇಕು ಮತ್ತು ಈ ಪುರಾವೆಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರಿಶೀಲಿಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ ಮಾಡಬೇಕು.

ಬ್ಯಾಟರಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಡೈನಾಮಿಕ್ ಒಂದು ಸೆಟ್‌ನಿಂದ ಅಂಶಗಳನ್ನು ಸೇರಿಸಲು ಮತ್ತು ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ನಿಮಗೆ ಅನುಮತಿಸಿದರೆ.

ಅಂತಹ ಬ್ಯಾಟರಿಯ ಉದಾಹರಣೆಯಾಗಿದೆ ಡಿಸೆಂಬರ್ 2018 ರಲ್ಲಿ Boneh, Bunz, Fisch ಪ್ರಸ್ತಾಪಿಸಿದ RSA ಸಂಚಯಕ. ಅಂತಹ ಸಂಚಯಕವು ಸಂಗ್ರಹವಾಗಿರುವ ಪ್ರಾತಿನಿಧ್ಯದ ಸ್ಥಿರ ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ಉಪಸ್ಥಿತಿಯ ಅಗತ್ಯವಿರುತ್ತದೆ ರಹಸ್ಯವನ್ನು ಹಂಚಿಕೊಂಡರು (ವಿಶ್ವಾಸಾರ್ಹ ಸೆಟಪ್). ಈ ಅವಶ್ಯಕತೆಯು ಬಿಟ್‌ಕಾಯಿನ್‌ನಂತಹ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲದ ನೆಟ್‌ವರ್ಕ್‌ಗಳಿಗೆ ಅಂತಹ ಸಂಚಯಕದ ಅನ್ವಯವನ್ನು ನಿರಾಕರಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ರಹಸ್ಯ ಉತ್ಪಾದನೆಯ ಸಮಯದಲ್ಲಿ ಡೇಟಾ ಸೋರಿಕೆಯು ಆಕ್ರಮಣಕಾರರಿಗೆ UTXO ಅಸ್ತಿತ್ವದ ಸುಳ್ಳು ಪುರಾವೆಗಳನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಅಂತಹ ಸಂಚಯಕವನ್ನು ಆಧರಿಸಿ UTXO-ಸೆಟ್‌ನೊಂದಿಗೆ ನೋಡ್‌ಗಳನ್ನು ಮೋಸಗೊಳಿಸುತ್ತದೆ.

Utreexo

Thaddeus Dryja ಪ್ರಸ್ತಾಪಿಸಿದ Utreexo ವಿನ್ಯಾಸವು ರಚಿಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ ಮಾಡುತ್ತದೆ ಕ್ರಿಯಾತ್ಮಕ ಶೇಖರಣೆ ಇಲ್ಲದೆ ವಿಶ್ವಾಸಾರ್ಹ-ಸೆಟಪ್.

Utreexo ಪರಿಪೂರ್ಣ ಬೈನರಿ ಅರಣ್ಯವಾಗಿದೆ ಮರ್ಕಲ್ ಮರಗಳು ಮತ್ತು ಪ್ರಸ್ತುತಪಡಿಸಿದ ವಿಚಾರಗಳ ಬೆಳವಣಿಗೆಯಾಗಿದೆ ವಿತರಿಸಿದ pki ಗಾಗಿ ಸಮರ್ಥ ಅಸಮಕಾಲಿಕ ಸಂಚಯಕಗಳು, ಒಂದು ಸೆಟ್‌ನಿಂದ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಸೇರಿಸುವುದು.

ಬ್ಯಾಟರಿ ತಾರ್ಕಿಕ ರಚನೆ

ಬ್ಯಾಟರಿ ಕೋಶಗಳನ್ನು ಆದರ್ಶ ಬೈನರಿ ಮರಗಳ ಕಾಡಿನಲ್ಲಿ ಜೋಡಿಸಲಾಗಿದೆ. ಮರಗಳನ್ನು ಎತ್ತರದಿಂದ ಆದೇಶಿಸಲಾಗುತ್ತದೆ. ಈ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಅತ್ಯಂತ ದೃಷ್ಟಿಗೋಚರವಾಗಿ ಆಯ್ಕೆಮಾಡಲಾಗಿದೆ ಮತ್ತು ಬ್ಯಾಟರಿಯಲ್ಲಿನ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಮಯದಲ್ಲಿ ಮರಗಳ ವಿಲೀನವನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಕಾಡಿನಲ್ಲಿರುವ ಎಲ್ಲಾ ಮರಗಳು ಆದರ್ಶಪ್ರಾಯವಾಗಿರುವುದರಿಂದ, ಯಾವುದೇ ನೈಸರ್ಗಿಕ ಸಂಖ್ಯೆಯನ್ನು ಎರಡು ಶಕ್ತಿಗಳ ಮೊತ್ತವಾಗಿ ಪ್ರತಿನಿಧಿಸುವಂತೆಯೇ ಅವುಗಳ ಎತ್ತರವನ್ನು ಎರಡು ಶಕ್ತಿಯಾಗಿ ವ್ಯಕ್ತಪಡಿಸಲಾಗುತ್ತದೆ ಎಂದು ಲೇಖಕರು ಗಮನಿಸುತ್ತಾರೆ. ಅಂತೆಯೇ, ಯಾವುದೇ ಎಲೆಗಳ ಗುಂಪನ್ನು ಬೈನರಿ ಮರಗಳಾಗಿ ವರ್ಗೀಕರಿಸಬಹುದು, ಮತ್ತು ಎಲ್ಲಾ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಹೊಸ ಅಂಶವನ್ನು ಸೇರಿಸಲು ಜ್ಞಾನದ ಅಗತ್ಯವಿರುತ್ತದೆ ಸಂಗ್ರಹಿಸಿದ ಮರಗಳ ಮೂಲ ನೋಡ್ಗಳ ಬಗ್ಗೆ ಮಾತ್ರ.

ಹೀಗಾಗಿ, Utreexo ಸಂಚಯಕದ ಸಂಗ್ರಹವಾದ ಪ್ರಾತಿನಿಧ್ಯವು ರೂಟ್ ನೋಡ್‌ಗಳ ಪಟ್ಟಿಯಾಗಿದೆ (ಮರ್ಕಲ್ ರೂಟ್), ಮತ್ತು ಮರಗಳ ಸಂಪೂರ್ಣ ಅರಣ್ಯವಲ್ಲ.

ಮೂಲ ಅಂಶಗಳ ಪಟ್ಟಿಯನ್ನು ಪ್ರತಿನಿಧಿಸೋಣ Vec<Option<Hash>>. ಐಚ್ಛಿಕ ಪ್ರಕಾರ Option<Hash> ಮೂಲ ಅಂಶವು ಕಾಣೆಯಾಗಿರಬಹುದು ಎಂದು ಸೂಚಿಸುತ್ತದೆ, ಅಂದರೆ ಸಂಚಯಕದಲ್ಲಿ ಸೂಕ್ತವಾದ ಎತ್ತರವನ್ನು ಹೊಂದಿರುವ ಯಾವುದೇ ಮರವಿಲ್ಲ.

/// SHA-256 хеш
#[derive(Copy, Clone, Hash, Eq, PartialEq)]
pub struct Hash(pub [u8; 32]);

#[derive(Debug, Clone)]
pub struct Utreexo {
    pub roots: Vec<Option<Hash>>,
}

impl Utreexo {
    pub fn new(capacity: usize) -> Self {
        Utreexo {
            roots: vec![None; capacity],
        }
    }
}

ಅಂಶಗಳನ್ನು ಸೇರಿಸಲಾಗುತ್ತಿದೆ

ಮೊದಲಿಗೆ, ಕಾರ್ಯವನ್ನು ವಿವರಿಸೋಣ parent(), ಇದು ಎರಡು ಕೊಟ್ಟಿರುವ ಅಂಶಗಳಿಗೆ ಪೋಷಕ ನೋಡ್ ಅನ್ನು ಗುರುತಿಸುತ್ತದೆ.

ಪೋಷಕ () ಕಾರ್ಯ

ನಾವು ಮರ್ಕಲ್ ಟ್ರೀಗಳನ್ನು ಬಳಸುತ್ತಿರುವುದರಿಂದ, ಎರಡು ನೋಡ್‌ಗಳ ಪೋಷಕ ಒಂದು ನೋಡ್ ಆಗಿದ್ದು ಅದು ಚೈಲ್ಡ್ ನೋಡ್‌ಗಳ ಹ್ಯಾಶ್‌ಗಳ ಸಂಯೋಜನೆಯ ಹ್ಯಾಶ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ:

fn hash(bytes: &[u8]) -> Hash {
    let mut sha = Sha256::new();
    sha.input(bytes);
    let res = sha.result();
    let mut res_bytes = [0u8; 32];
    res_bytes.copy_from_slice(res.as_slice());

    Hash(res_bytes)
}

fn parent(left: &Hash, right: &Hash) -> Hash {
    let concat = left
        .0
        .into_iter()
        .chain(right.0.into_iter())
        .map(|b| *b)
        .collect::<Vec<_>>();

    hash(&concat[..])
}

ಚಾರ್ಲ್ಸ್ ಬೌಲಾಗೆಟ್, ಪಿಯರೆ-ಅಲೈನ್ ಫೌಕ್, ಆದಿ ಶಮೀರ್ ಮತ್ತು ಸೆಬಾಸ್ಟಿಯನ್ ಝಿಮ್ಮರ್ ವಿವರಿಸಿದ ದಾಳಿಯನ್ನು ತಡೆಗಟ್ಟಲು ಲೇಖಕರು ಗಮನಿಸುತ್ತಾರೆ.
ಡಿಥರ್ಡ್ ಹ್ಯಾಶ್ ಫಂಕ್ಷನ್‌ಗಳ ಮೇಲಿನ ಎರಡನೇ ಪ್ರಿಮೇಜ್ ದಾಳಿಗಳು, ಎರಡು ಹ್ಯಾಶ್‌ಗಳ ಜೊತೆಗೆ, ಮರದ ಒಳಗಿನ ಎತ್ತರವನ್ನು ಸಹ ಸಂಯೋಜನೆಗೆ ಸೇರಿಸಬೇಕು.

ನೀವು ಸಂಚಯಕಕ್ಕೆ ಅಂಶಗಳನ್ನು ಸೇರಿಸಿದಾಗ, ಯಾವ ಮೂಲ ಅಂಶಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನೀವು ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ನೀವು ಸೇರಿಸುವ ಪ್ರತಿಯೊಂದು ಅಂಶಕ್ಕೆ ಮೂಲ ಅಂಶಗಳನ್ನು ಬದಲಾಯಿಸುವ ಮಾರ್ಗವನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ಈ ಅಂಶಗಳ ಉಪಸ್ಥಿತಿಯ ಪುರಾವೆಯನ್ನು ನೀವು ನಂತರ ರಚಿಸಬಹುದು.

ನೀವು ಸೇರಿಸಿದಾಗ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಿ

ಮಾಡಿದ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು, ರಚನೆಯನ್ನು ಘೋಷಿಸೋಣ Update, ಇದು ನೋಡ್ ಬದಲಾವಣೆಗಳ ಬಗ್ಗೆ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

#[derive(Debug)]
pub struct Update<'a> {
    pub utreexo: &'a mut Utreexo,
    // ProofStep хранит "соседа" элемента и его положение
    pub updated: HashMap<Hash, ProofStep>,
}

ಬ್ಯಾಟರಿಗೆ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸಲು, ನಿಮಗೆ ಅಗತ್ಯವಿದೆ:

ಮೂಲ ಅಂಶಗಳ ಬುಟ್ಟಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಿ new_roots ಮತ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮೂಲ ಅಂಶಗಳನ್ನು ಅಲ್ಲಿ ಇರಿಸಿ, ಪ್ರತಿ ಬಕೆಟ್‌ಗೆ ಒಂದರಂತೆ:

ಕೋಡ್

let mut new_roots = Vec::new();

for root in self.roots.iter() {
    let mut vec = Vec::<Hash>::new();
    if let Some(hash) = root {
        vec.push(*hash);
    }

    new_roots.push(vec);
}

ಸೇರಿಸಬೇಕಾದ ಅಂಶಗಳನ್ನು ಸೇರಿಸಿ (ಅರೇ insertions) ಮೊದಲ ಕಾರ್ಟ್ಗೆ new_roots[0]:

ಕೋಡ್

new_roots[0].extend_from_slice(insertions);

ಮೊದಲ ಬುಟ್ಟಿಗೆ ಸೇರಿಸಲಾದ ಐಟಂಗಳನ್ನು ಉಳಿದವುಗಳೊಂದಿಗೆ ಒಟ್ಟುಗೂಡಿಸಿ:
- ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಐಟಂಗಳನ್ನು ಹೊಂದಿರುವ ಎಲ್ಲಾ ಕಾರ್ಟ್‌ಗಳಿಗೆ:
  1. ಬ್ಯಾಸ್ಕೆಟ್ನ ತುದಿಯಿಂದ ಎರಡು ಅಂಶಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ, ಅವರ ಪೋಷಕರನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ, ಎರಡೂ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕಿ
  2. ಲೆಕ್ಕಾಚಾರದ ಪೋಷಕರನ್ನು ಮುಂದಿನ ಕಾರ್ಟ್‌ಗೆ ಸೇರಿಸಿ

ಕೋಡ್

for i in 0..new_roots.len() {
    while new_roots[i].len() > 1 {
        // Объединяем два элемента в один и удаляем их
        let a = new_roots[i][new_roots[i].len() - 2];
        let b = new_roots[i][new_roots[i].len() - 1];
        new_roots[i].pop();
        new_roots[i].pop();
        let hash = self.parent(&a, &b);

        // Наращиваем количество корзин если требуется
        if new_roots.len() <= i + 1 {
            new_roots.push(vec![]);
        }

        // Помещаем элемент в следующую корзину
        new_roots[i + 1].push(hash);

        // Не забываем отслеживать изменения;
        // это пригодится для генерации доказательства добавления элементов
        updated.insert(a, ProofStep { hash: b, is_left: false });
        updated.insert(b, ProofStep {hash: a, is_left: true });
    }
}

ಮೂಲ ಅಂಶಗಳನ್ನು ಬಿನ್‌ಗಳಿಂದ ಪರಿಣಾಮವಾಗಿ ಸಂಚಯಕ ರಚನೆಗೆ ಸರಿಸಿ

ಕೋಡ್

for (i, bucket) in new_roots.into_iter().enumerate() {
    // Наращиваем аккумулятор если требуется
    if self.roots.len() <= i {
        self.roots.push(None);
    }

    if bucket.is_empty() {
        self.roots[i] = None;
    } else {
        self.roots[i] = Some(bucket[0]);
    }
}

ಸೇರಿಸಿದ ಅಂಶಗಳಿಗೆ ಪುರಾವೆಯನ್ನು ರಚಿಸುವುದು

ಬ್ಯಾಟರಿಯಲ್ಲಿ ಸೆಲ್ ಸೇರ್ಪಡೆಯ ಪುರಾವೆ (Proof) ಸರಪಳಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ಮರ್ಕಲ್ ಪಾತ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ProofStep. ಮಾರ್ಗವು ಎಲ್ಲಿಯೂ ಹೋಗದಿದ್ದರೆ, ಪುರಾವೆಯು ತಪ್ಪಾಗಿದೆ.

/// Единичный шаг на пути к элементу в дереве Меркла.
#[derive(Debug, Copy, Clone)]
pub struct ProofStep {
    pub hash: Hash,
    pub is_left: bool,
}

/// Доказательство включения элемента. Содержит сам элемент и путь к нему.
#[derive(Debug, Clone)]
pub struct Proof {
    pub steps: Vec<ProofStep>,
    pub leaf: Hash,
}

ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸುವಾಗ ಹಿಂದೆ ಪಡೆದ ಮಾಹಿತಿಯನ್ನು ಬಳಸುವುದು (ರಚನೆ Update), ಬ್ಯಾಟರಿಗೆ ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸಲಾಗಿದೆ ಎಂಬುದಕ್ಕೆ ನೀವು ಪುರಾವೆಯನ್ನು ರಚಿಸಬಹುದು. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಮಾಡಿದ ಬದಲಾವಣೆಗಳ ಕೋಷ್ಟಕದ ಮೂಲಕ ಹೋಗುತ್ತೇವೆ ಮತ್ತು ಮರ್ಕೆಲ್ನ ಹಾದಿಗೆ ಪ್ರತಿ ಹಂತವನ್ನು ಸೇರಿಸುತ್ತೇವೆ, ಅದು ತರುವಾಯ ಪುರಾವೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:

ಕೋಡ್

impl<'a> Update<'a> {
    pub fn prove(&self, leaf: &Hash) -> Proof {
        let mut proof = Proof {
            steps: vec![],
            leaf: *leaf,
        };

        let mut item = *leaf;
        while let Some(s) = self.updated.get(&item) {
            proof.steps.push(*s);
            item = parent(&item, &s);
        }

        proof
    }
}

ಪುರಾವೆ ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆ

ಒಂದು ಅಂಶಕ್ಕಾಗಿ ಪುರಾವೆಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ

ಒಂದು ಅಂಶದ ಸೇರ್ಪಡೆ ಪುರಾವೆಯನ್ನು ಪರಿಶೀಲಿಸುವುದರಿಂದ ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮೂಲ ಅಂಶಕ್ಕೆ ಕಾರಣವಾಗುವವರೆಗೆ ಮರ್ಕಲ್ ಮಾರ್ಗವನ್ನು ಅನುಸರಿಸುತ್ತದೆ:

pub fn verify(&self, proof: &Proof) -> bool {
    let n = proof.steps.len();
    if n >= self.roots.len() {
        return false;
    }

    let expected = self.roots[n];
    if let Some(expected) = expected {
        let mut current_parent = proof.leaf;
        for s in proof.steps.iter() {
            current_parent = if s.is_left {
                parent(&s.hash, &current_parent)
            } else {
                parent(&current_parent, &s.hash)
            };
        }

        current_parent == expected
    } else {
        false
    }
}

ದೃಷ್ಟಿಗೋಚರವಾಗಿ:

A ಗಾಗಿ ಪುರಾವೆಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಪ್ರಕ್ರಿಯೆ

ವಸ್ತುಗಳನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತಿದೆ

ಬ್ಯಾಟರಿಯಿಂದ ಸೆಲ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲು, ಸೆಲ್ ಇದೆ ಎಂಬುದಕ್ಕೆ ನೀವು ಮಾನ್ಯವಾದ ಪುರಾವೆಗಳನ್ನು ಒದಗಿಸಬೇಕು. ಪುರಾವೆಯಿಂದ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು, ಕೊಟ್ಟಿರುವ ಪುರಾವೆಯು ಇನ್ನು ಮುಂದೆ ನಿಜವಾಗದ ಸಂಚಯಕದ ಹೊಸ ಮೂಲ ಅಂಶಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಸಾಧ್ಯವಿದೆ.

ಅಲ್ಗಾರಿದಮ್ ಹೀಗಿದೆ:

ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಾವು ಬುಟ್ಟಿ ಸೂಚ್ಯಂಕದಿಂದ ಎರಡು ಶಕ್ತಿಗೆ ಸಮಾನವಾದ ಎತ್ತರದೊಂದಿಗೆ ಮರ್ಕಲ್ ಮರಗಳಿಗೆ ಅನುಗುಣವಾದ ಖಾಲಿ ಬುಟ್ಟಿಗಳ ಗುಂಪನ್ನು ಆಯೋಜಿಸುತ್ತೇವೆ.
ನಾವು ಬುಟ್ಟಿಗಳಲ್ಲಿ ಮರ್ಕೆಲ್ ಪಥದ ಹಂತಗಳಿಂದ ಅಂಶಗಳನ್ನು ಸೇರಿಸುತ್ತೇವೆ; ಬ್ಯಾಸ್ಕೆಟ್ ಸೂಚ್ಯಂಕವು ಪ್ರಸ್ತುತ ಹಂತದ ಸಂಖ್ಯೆಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ
ಪುರಾವೆಯಿಂದ ಮಾರ್ಗವು ಮುನ್ನಡೆಸುವ ಮೂಲ ಅಂಶವನ್ನು ನಾವು ತೆಗೆದುಹಾಕುತ್ತೇವೆ
ಸೇರಿಸುವುದರೊಂದಿಗೆ, ಬುಟ್ಟಿಗಳಿಂದ ಅಂಶಗಳನ್ನು ಜೋಡಿಯಾಗಿ ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಮತ್ತು ಒಕ್ಕೂಟದ ಫಲಿತಾಂಶವನ್ನು ಮುಂದಿನ ಬುಟ್ಟಿಗೆ ಸರಿಸುವ ಮೂಲಕ ನಾವು ಹೊಸ ಮೂಲ ಅಂಶಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತೇವೆ

ಕೋಡ್

fn delete(&self, proof: &Proof, new_roots: &mut Vec<Vec<Hash>>) -> Result<(), ()> {
    if self.roots.len() < proof.steps.len() || self.roots.get(proof.steps.len()).is_none() {
        return Err(());
    }

    let mut height = 0;
    let mut hash = proof.leaf;
    let mut s;

    loop {
        if height < new_roots.len() {
            let (index, ok) = self.find_root(&hash, &new_roots[height]);
            if ok {
                // Remove hash from new_roots
                new_roots[height].remove(index);

                loop {
                    if height >= proof.steps.len() {
                        if !self.roots[height]
                            .and_then(|h| Some(h == hash))
                            .unwrap_or(false)
                        {
                            return Err(());
                        }

                        return Ok(());
                    }

                    s = proof.steps[height];
                    hash = self.parent(&hash, &s);
                    height += 1;
                }
            }
        }

        if height >= proof.steps.len() {
            return Err(());
        }

        while height > new_roots.len() {
            new_roots.push(vec![]);
        }

        s = proof.steps[height];
        new_roots[height].push(s.hash);
        hash = self.parent(&hash, &s);
        height += 1;
    }
}

"ಎ" ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕುವ ಪ್ರಕ್ರಿಯೆ:

ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಏಕೀಕರಣ

ಪ್ರಸ್ತಾವಿತ ಸಂಚಯಕವನ್ನು ಬಳಸಿಕೊಂಡು, ನೋಡ್‌ಗಳು UTXO-ಸೆಟ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಾಗುವಾಗ ಎಲ್ಲಾ UTXOಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು DB ಅನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಪುರಾವೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಸಮಸ್ಯೆ ಉದ್ಭವಿಸುತ್ತದೆ.

UTXO ಸಂಚಯಕವನ್ನು ಬಳಸುವ ವ್ಯಾಲಿಡೇಟರ್ ನೋಡ್ ಅನ್ನು ಕರೆಯೋಣ ಕಾಂಪ್ಯಾಕ್ಟ್ (ಕಾಂಪ್ಯಾಕ್ಟ್-ಸ್ಟೇಟ್ ನೋಡ್), ಮತ್ತು ಸಂಚಯಕ ಇಲ್ಲದ ವ್ಯಾಲಿಡೇಟರ್ ಆಗಿದೆ ಪೂರ್ಣಗೊಂಡಿದೆ (ಪೂರ್ಣ ನೋಡ್). ಎರಡು ವರ್ಗದ ನೋಡ್‌ಗಳ ಅಸ್ತಿತ್ವವು ಅವುಗಳನ್ನು ಒಂದೇ ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಸಂಯೋಜಿಸಲು ಸಮಸ್ಯೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಕಾಂಪ್ಯಾಕ್ಟ್ ನೋಡ್‌ಗಳಿಗೆ UTXO ಗಳ ಅಸ್ತಿತ್ವದ ಪುರಾವೆ ಅಗತ್ಯವಿರುತ್ತದೆ, ಇವುಗಳನ್ನು ವಹಿವಾಟುಗಳಲ್ಲಿ ಖರ್ಚು ಮಾಡಲಾಗುತ್ತದೆ, ಆದರೆ ಪೂರ್ಣ ನೋಡ್‌ಗಳು ಹಾಗೆ ಮಾಡುವುದಿಲ್ಲ. ಎಲ್ಲಾ ನೆಟ್‌ವರ್ಕ್ ನೋಡ್‌ಗಳು ಏಕಕಾಲದಲ್ಲಿ ಮತ್ತು ಸಮನ್ವಯವಾಗಿ Utreexo ಅನ್ನು ಬಳಸಲು ಬದಲಾಯಿಸದಿದ್ದರೆ, ಕಾಂಪ್ಯಾಕ್ಟ್ ನೋಡ್‌ಗಳು ಹಿಂದೆ ಉಳಿಯುತ್ತವೆ ಮತ್ತು ಬಿಟ್‌ಕಾಯಿನ್ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಕಾಂಪ್ಯಾಕ್ಟ್ ನೋಡ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು, ಹೆಚ್ಚುವರಿ ವರ್ಗದ ನೋಡ್‌ಗಳನ್ನು ಪರಿಚಯಿಸಲು ಪ್ರಸ್ತಾಪಿಸಲಾಗಿದೆ - ಸೇತುವೆಗಳು. ಬ್ರಿಡ್ಜ್ ನೋಡ್ ಎನ್ನುವುದು ಸಂಪೂರ್ಣ ನೋಡ್ ಆಗಿದ್ದು ಅದು Utreexo ಬ್ಯಾಟರಿ ಮತ್ತು ಪವರ್-ಆನ್ ಪುರಾವೆಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ всех UTXO-ಸೆಟ್‌ನಿಂದ UTXO. ಬ್ರಿಡ್ಜ್‌ಗಳು ಹೊಸ ಹ್ಯಾಶ್‌ಗಳನ್ನು ಲೆಕ್ಕ ಹಾಕುತ್ತವೆ ಮತ್ತು ವಹಿವಾಟಿನ ಹೊಸ ಬ್ಲಾಕ್‌ಗಳು ಬಂದಂತೆ ಸಂಚಯಕ ಮತ್ತು ಪುರಾವೆಗಳನ್ನು ನವೀಕರಿಸುತ್ತವೆ. ಸಂಚಯಕ ಮತ್ತು ಪುರಾವೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ನವೀಕರಿಸುವುದು ಅಂತಹ ನೋಡ್‌ಗಳ ಮೇಲೆ ಹೆಚ್ಚುವರಿ ಕಂಪ್ಯೂಟೇಶನಲ್ ಲೋಡ್ ಅನ್ನು ವಿಧಿಸುವುದಿಲ್ಲ. ಸೇತುವೆಗಳು ಡಿಸ್ಕ್ ಜಾಗವನ್ನು ತ್ಯಾಗ ಮಾಡುತ್ತವೆ: ವಿಷಯಗಳನ್ನು ವ್ಯವಸ್ಥಿತವಾಗಿ ಇರಿಸಿಕೊಳ್ಳಬೇಕು ಗೆ ಹೋಲಿಸಿದರೆ ಹ್ಯಾಶ್‌ಗಳು ಕಾಂಪ್ಯಾಕ್ಟ್ ನೋಡ್‌ಗಳಿಗಾಗಿ ಹ್ಯಾಶ್‌ಗಳು, ಇಲ್ಲಿ n ಯು UTXO ಸೆಟ್‌ನ ಶಕ್ತಿಯಾಗಿದೆ.

ನೆಟ್ವರ್ಕ್ ಆರ್ಕಿಟೆಕ್ಚರ್

ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನೋಡ್‌ಗಳ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಬದಲಾಯಿಸದೆಯೇ ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಕಾಂಪ್ಯಾಕ್ಟ್ ನೋಡ್‌ಗಳನ್ನು ಕ್ರಮೇಣ ಸೇರಿಸಲು ಸೇತುವೆಗಳು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ಪೂರ್ಣ ನೋಡ್‌ಗಳು ಮೊದಲಿನಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ವಹಿವಾಟುಗಳು ಮತ್ತು ಬ್ಲಾಕ್‌ಗಳನ್ನು ತಮ್ಮಲ್ಲಿಯೇ ವಿತರಿಸುತ್ತವೆ. ಬ್ರಿಡ್ಜ್ ನೋಡ್‌ಗಳು ಪೂರ್ಣ ನೋಡ್‌ಗಳಾಗಿವೆ, ಅವುಗಳು ಹೆಚ್ಚುವರಿಯಾಗಿ Utreexo ಬ್ಯಾಟರಿ ಡೇಟಾ ಮತ್ತು ಸೇರ್ಪಡೆ ಪುರಾವೆಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತವೆ всех ಸದ್ಯಕ್ಕೆ UTXO. ಬ್ರಿಡ್ಜ್ ನೋಡ್ ತನ್ನನ್ನು ತಾನೇ ಜಾಹೀರಾತು ಮಾಡುವುದಿಲ್ಲ, ಎಲ್ಲಾ ಪೂರ್ಣ ನೋಡ್‌ಗಳಿಗೆ ಪೂರ್ಣ ನೋಡ್ ಮತ್ತು ಎಲ್ಲಾ ಕಾಂಪ್ಯಾಕ್ಟ್ ನೋಡ್‌ಗಳಿಗೆ ಕಾಂಪ್ಯಾಕ್ಟ್ ನೋಡ್ ಎಂದು ನಟಿಸುತ್ತದೆ. ಸೇತುವೆಗಳು ಎರಡೂ ನೆಟ್‌ವರ್ಕ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸಂಪರ್ಕಿಸಿದರೂ, ಅವುಗಳು ವಾಸ್ತವವಾಗಿ ಅವುಗಳನ್ನು ಒಂದೇ ದಿಕ್ಕಿನಲ್ಲಿ ಸಂಪರ್ಕಿಸುವ ಅಗತ್ಯವಿದೆ: ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪೂರ್ಣ ನೋಡ್‌ಗಳಿಂದ ಕಾಂಪ್ಯಾಕ್ಟ್ ನೋಡ್‌ಗಳಿಗೆ. ವಹಿವಾಟಿನ ಸ್ವರೂಪವನ್ನು ಬದಲಾಯಿಸುವ ಅಗತ್ಯವಿಲ್ಲದ ಕಾರಣ ಇದು ಸಾಧ್ಯ, ಮತ್ತು ಕಾಂಪ್ಯಾಕ್ಟ್ ನೋಡ್‌ಗಳಿಗೆ UTXO ಪುರಾವೆಗಳನ್ನು ತ್ಯಜಿಸಬಹುದು, ಆದ್ದರಿಂದ ಯಾವುದೇ ಕಾಂಪ್ಯಾಕ್ಟ್ ನೋಡ್ ಬ್ರಿಡ್ಜ್ ನೋಡ್‌ಗಳ ಭಾಗವಹಿಸುವಿಕೆ ಇಲ್ಲದೆ ಎಲ್ಲಾ ನೆಟ್‌ವರ್ಕ್ ಭಾಗವಹಿಸುವವರಿಗೆ ವಹಿವಾಟುಗಳನ್ನು ಪ್ರಸಾರ ಮಾಡಬಹುದು.

ತೀರ್ಮಾನಕ್ಕೆ

ನಾವು Utreexo ಬ್ಯಾಟರಿಯನ್ನು ನೋಡಿದ್ದೇವೆ ಮತ್ತು ಅದರ ಮೂಲಮಾದರಿಯನ್ನು ರಸ್ಟ್‌ನಲ್ಲಿ ಅಳವಡಿಸಿದ್ದೇವೆ. ಬ್ಯಾಟರಿ ಆಧಾರಿತ ನೋಡ್‌ಗಳ ಏಕೀಕರಣವನ್ನು ಅನುಮತಿಸುವ ನೆಟ್‌ವರ್ಕ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ. ಕಾಂಪ್ಯಾಕ್ಟ್ ಕ್ಯಾಚ್‌ಗಳ ಪ್ರಯೋಜನವು ಶೇಖರಿಸಿದ ಡೇಟಾದ ಗಾತ್ರವಾಗಿದೆ, ಇದು ಯುಟಿಎಕ್ಸ್‌ಒಗಳ ಸೆಟ್‌ನ ಶಕ್ತಿಯ ಮೇಲೆ ಲಾಗರಿಥಮಿಕ್ ಆಗಿ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ, ಇದು ಡಿಸ್ಕ್ ಸ್ಥಳ ಮತ್ತು ಅಂತಹ ನೋಡ್‌ಗಳಿಗೆ ಶೇಖರಣಾ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅವಶ್ಯಕತೆಗಳನ್ನು ಬಹಳವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಅನನುಕೂಲವೆಂದರೆ ಪುರಾವೆಗಳನ್ನು ರವಾನಿಸಲು ಹೆಚ್ಚುವರಿ ನೋಡ್ ಟ್ರಾಫಿಕ್, ಆದರೆ ಸಾಕ್ಷ್ಯದ ಒಟ್ಟುಗೂಡಿಸುವ ತಂತ್ರಗಳು (ಒಂದು ಪುರಾವೆಯು ಹಲವಾರು ಅಂಶಗಳ ಅಸ್ತಿತ್ವವನ್ನು ಸಾಬೀತುಪಡಿಸಿದಾಗ) ಮತ್ತು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವಿಕೆಯು ದಟ್ಟಣೆಯನ್ನು ಸ್ವೀಕಾರಾರ್ಹ ಮಿತಿಗಳಲ್ಲಿ ಇರಿಸಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಉಲ್ಲೇಖಗಳು:

ಮೂಲ: www.habr.com

Utreexo: ಅನೇಕ UTXO ಬಿಟ್‌ಕಾಯಿನ್ ಅನ್ನು ಸಂಕುಚಿತಗೊಳಿಸುವುದು

ಸಮಸ್ಯೆ ಏನು?

UTXO ಮತ್ತು UTXO-ಸೆಟ್

UTXO ಗಾಗಿ ಬ್ಯಾಟರಿಗಳು

Utreexo

ಬ್ಯಾಟರಿ ತಾರ್ಕಿಕ ರಚನೆ

ಅಂಶಗಳನ್ನು ಸೇರಿಸಲಾಗುತ್ತಿದೆ

ಸೇರಿಸಿದ ಅಂಶಗಳಿಗೆ ಪುರಾವೆಯನ್ನು ರಚಿಸುವುದು

ಒಂದು ಅಂಶಕ್ಕಾಗಿ ಪುರಾವೆಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ

ವಸ್ತುಗಳನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತಿದೆ

ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಏಕೀಕರಣ

ನೆಟ್ವರ್ಕ್ ಆರ್ಕಿಟೆಕ್ಚರ್

ತೀರ್ಮಾನಕ್ಕೆ

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ Отменить ответ