The מתוכננת להפעיל את , היא עדכון הרשת העיקרי הבא של Ethereum אחרי Pectra, וזה מסמן צעד נוסף של מיקרוסופט ענק. Fusaka Hard פורק December 3, 2025 Fusaka Hard פורק אבטחה וחיסכון בביטוח לאומי (למשל, בטיחות בביטוח לאומי) (למשל, לא ניתן להוריד את כל ההגדרות המוצעות על-ידי המשתמש, אלא להוריד את כל ההגדרות המוצעות על-ידי המשתמש, או להוריד את ההגדרות המוצעות על-ידי המשתמש) (למשל, יש להגדיר את הגבלת ההחזקה של הגז) (למשל, מחירי המזון המוגדרים על-ידי המשתמשים ב-MODEXP) (למשל, יש להקפיד גם על שיפור המצב הכלכלי של הארגון, על מנת להגדיל את ההשפעה על המצב הכלכלי) (למשל, יש להקפיד על חיסכון במחירי החשמל (למשל, יש להקפיד על חיסכון במחירי החשמל) הגבלת גודל המכשיר (למשל, הגבלת גודל המכשיר) , הוספת קוד אופציונלי CLZ חדש עבור פעולות ביט מהירות יותר ( תגית: תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות תגיות קשורות • תאימות טובה יותר עם מפתחות האבטחה המודרניות של הצפנה והחומרה. EIP-7594 EIP-7823 EIP-7825 EIP-7883 EIP-7917 EIP-7918 EIP-7934 EIP-7939 EIP-7951 בדיוק כמו Pectra שילוב של "פראג" ו "Electra", Fusaka הוא שם משולב של ו זה מייצג את הקפיצה הבאה של Ethereum לעבר עתיד עשיר מאוד בקנה מידה, עשיר בנתונים, שבו רולפים של שכבה 2 יכולים לפעול זול יותר ומהיר יותר. Fulu (execution layer) Osaka (consensus layer) בבלוג הזה, נפרק את המאפיינים הבסיסיים של Fusaka hard fork, להסביר איך PeerDAS עובד בפועל, וללכת דרך הדרישות האמיתיות של הרשת עבור סטייקרים ביתיים, supernodes, ו node מלאים - נתוני devnet תומכים. Key Changes Introduced In Fusaka Hard Fork שינויים מרכזיים הוצגו ב-Fusaka Hard Fork : PeerDAS - Peer Data Availability Sampling EIP-7594 תגית: 7594 Ethereum צריך הצעה זו כי הרשת רוצה לספק זמינות יותר של נתונים למשתמשים ובמיוחד עבור רולפים, אבל עם הנוכחי עיצוב, כל צומת עדיין צריך להוריד יותר מדי נתונים blob רק כדי לבדוק כי זה בעצם פורסם. זה יוצר בעיה של מיקוד, כי אם כל הצמתים חייבים להוריד הכל, את רוחב הקשר ואת דרישות החומרה של הרשת לעלות, והרכזת יכול לסבול. כדי לתקן את זה, Ethereum צריך דרך עבור הצמתים כדי לאשר כי הנתונים זמינים מבלי להוריד את כל זה. Data Availability Sampling (DAS) פותר את זה על ידי מאפשרת הצמתים לבדוק רק חתיכות קטנות אקראיות של הנתונים. אבל Ethereum צריך גם שיטה DAS שמתאימה היטב עם הרשת הקודמת ולא מוסיפה חישובים כבדים כדי לחסום יצרנים. PeerDAS נוצר כדי לענות על הצר EIP-4844 PeerDAS הוא מערכת רשת המאפשרת לחלקים להוריד רק חתיכות קטנות של נתוני blob כדי לבדוק אם הנתונים המלאים פורסמו למעשה. במקום להוריד הכל, החלקים משתמשים ברשת השמועות הרגילה כדי לשתף נתונים, לגלות אילו עמיתים מחזיקים חלקים מסוימים, ולבקש רק את הדגימות הקטנות שהם צריכים. הרעיון העיקרי הוא כי על ידי הורדת רק חלקים קטנים, אקראיים של blob, החלקים עדיין יכולים להיות בטוחים שהblob כולו קיים. כדי להפוך את הדגימה לעבודה, PeerDAS מרחיב כל blob מ השתמשו בסוג מסוים של קידוח. – דומה לאופן שבו אתה יכול להשלים פאזל גם אם כמה חתיכות אבדו. הבלוב הופך ל”שורה” המכילה את הנתונים המקוריים בתוספת נתונים קודרים נוספים המאפשרים לו להתבצע מחדש מאוחר יותר. שורה זו מחולקת לחלקים קטנים רבים הנקראים תאים, אשר הם היחידות הקטנות ביותר שנבדקו הקשורות למחויבות KZG. כל השורות מאוחר יותר מאורגנות מחדש ל”עמודות”, שבהן כל עמודה מכילה את התאים באותו המיקום מכל שורה. כל עמודה מיועדת לרשת משותפת ספציפית. הצלחות אחראיות לאחסון של עמודים מסוימים בהתבסס על מזהה הצלחת שלהם ולדוגמה של כמה עמודים מכל מגרש עמיתי. אם הצלחה אוספת EIP-4844 Erasure coding is a technique that adds extra redundant data so that the original data can be recovered even if some pieces are missing בנוסף, ה- EIP מציג חוק חשוב: הגבלת זו חייבת להתבצע במהלך אימות עסקאות, שמועות, יצירת בלוקים ועיבוד בלוקים.זה עוזר להפחית מקרים קיצוניים שבהם עסקה יחידה מכסה את מערכת blob. no transaction can contain more than 6 blobs פרויד מוסיף משהו שנקרא הוכחה של תאים KZG מראה כי מחויבות KZG באמת מתאימה לתא מסוימת (חתיכה אחת קטנה) של blob.This מאפשר לקוטר להוריד רק את התאים שהוא רוצה לדוגמה, במקום את blob המלא, תוך שמירה על שלמות הנתונים. cell KZG proofs אבל יצירת כל הוכחות תאים אלה הוא יקר. יצרן בלוק יהיה צריך לחשב אותם שוב ושוב עבור בלוקים רבים, אשר הוא איטי מדי. כדי ליצור את כל הוכחות התאים מראש בזמן ולהכניס אותם לתוך מעיל העסקה. the blob transaction sender בגלל זה, השמועה של העסקה (PooledTransactions) משתמשת כעת באריזה משנה: rlp([tx_payload_body, wrapper_version, blobs, commitments, cell_proofs]) בתוך המערה החדשה, הוא רק רשימה המכילה כל הוכחה לכל תא של כל blob (לדוגמה: השדות האחרים - , , ו - הם בדיוק אותו הדבר כמו שהם היו ב EIP-4844.ההבדל הוא כי השדה הישן "הוכחות" יחיד מוחלף ומוחלף עם זה חדש שדה חדש, שנקרא הוסף כדי להראות איזה פורמט wrapper משמש. cell_proofs [cell_proof_0, cell_proof_1, ...] tx_payload_body blobs commitments cell_proofs wrapper_version The זהו ביטט אחד, ובהצעה זו הוא תמיד מוגדר • The שדה מכיל את כל ההוכחות לתאים עבור כל blob, כולל ההוכחות לתאים ההרחבה הנוספים שנוצרו במהלך קידוד מחיקה. למרות שהרשימה מכילה הוכחות לתאי ההרחבה, ה-blobs עצמם עדיין נשלחים בצורתם הרגילה (לא-הרחבה).ה-blob מכיל רק את מחציתו המקורית – הצומת המקבל יכול לחשב את מחצית ההרחבה בעצמו, כך שאין צורך לשלוח נתונים מיותרים. wrapper_version 1 cell_proofs CELLS_PER_EXT_BLOB באופן רשמי יותר, הוא ההוכחה עבור התא j-th של blob i-th לאחר ריצה , שמייצרת את התאים המקוריים והרחבים. cell_proofs[i * CELLS_PER_EXT_BLOB + j] compute_cells(blobs[i]) כאשר כונן מקבל את החבילה הזאת, הוא חייב לאמת את העסקה ולבדוק שהכל מסודר כראוי. מכיל בדיוק כל תרגום חייב להיעשות על-ידי המשתמש ( ). Finally, the node must check that each commitment actually matches the blob and its proofs. To do this, it computes the extension cells locally using ולאחר מכן בודק את כל ההוכחות של התאים – אימות במלאי מותר כדי להפוך את זה למהיר יותר. cell_proofs CELLS_PER_EXT_BLOB * number_of_blobs kzg_to_versioned_hash(commitments[i]) == tx_payload_body.blob_versioned_hashes[i] compute_cells דמיינו שבלוב מחולק ל עקבו אחרי coding coding ( הבלוג המקורי מכיל , and the receiving node will compute the missing המשלוח עצמו חייב להכיל את ב . Example 8 cells CELLS_PER_EXT_BLOB = 8 4 cells 4 extension cells all 8 proofs cell_proofs אז עבור 1 blob, transaction wrapper מכיל: blobs = [blob_0] (רק 4 תאים מקוריים) מחויבות = [ מחויבות 0 ] (proof for each of the 8 cells) cell_proofs = [proof_0, proof_1, …, proof_7] כאשר כונן מבצע דגימות, הוא עשוי לבקש רק תא 2 או תא 5, והוא יכול לאמת אותם באופן מיידי באמצעות ההוכחות המתאימות, מבלי להוריד את הבלוב המלא. PeerDAS מאפשרת ל-Ethereum להגדיל את זמינות הנתונים מבלי לגרום לחלקים לעבוד קשה יותר. בעתיד, זה עשוי אפילו לרדת , אשר יאפשר את Ethereum להגדיל יותר. המערכת פועלת היטב כי לכל צומת יש הרבה עמיתים. אז אם אחד השותפים לא נותן את הנתונים הנדרשים, הצומת יכול פשוט לבקש שותף אחר. זה יוצר redundancy טבעי משפר את האבטחה. נתונים יותר מהנדרש, אשר מחזק את הרשת עוד יותר – גם ללא שינויים בפרוטוקול. 1/8 of the total blob data 1/16 or 1/32 more מאחר שחוקרים כבר פועלים בחומרה חזקה יותר, PeerDAS נותן להם עומס שמירה של נתונים המתאים למספר הכולל של חוקרים. זה מבטיח כי קבוצה יציבה של גרביים זמינה תמיד לאחסון ולשתף יותר נתונים, מה שהופך את הרשת לאמינה יותר. בקצרה, אם יש 900,000 חוקרים, לכל חוקר עשוי להיות מוקדש חלק קטן מהנתונים הכוללים של blob כדי לאחסן ולשרת. PeerDAS uses במקום דגימה בשורה, כי זה הופך את הבנייה מחדש של הנתונים הרבה יותר קל.אם כפתורים דגימה שורות מלאות (בלוב שלמים), הם יצטרכו ליצור "בלוב הרחבה" נוספים שאינם קיימים באופן טבעי, אשר יאטם את יצרני הבלוק. לדמיין בלוב הוא רשת 4×4 של תאים. דגימת שורה פירושה לקחת את כל 4 התאים מתוך שורה אחת, אבל כמה שורות הרחבה עדיין לא מוכנים, כך שהיצרן של הבלוק היה צריך ליצור אותם במקום. דגימה עמודה פירושה לקחת תא אחד מכל שורה (עמודה). התאים הנוספים הדרושים לשיקום ניתן להכין מראש, כך שהצמיגים יכולים לאמת את הנתונים מבלי להאט את ייצור הבלוק. column sampling Example: עובד במלואו עם , כך שזה לא שובר שום דבר כבר על Ethereum.כל הבדיקות והכללים המפורטים נמצאים בהסכמה ובפרטים של ביצוע. EIP-7594 EIP-4844 הסיכון העיקרי לביטחון בכל מערכת DAS הוא התקפה של "החזקת נתונים", שבה יצרן בלוק מעמיד פנים כי הנתונים זמינים, אך למעשה מסתיר חלק מהם. PeerDAS מונע זאת באמצעות דגימה אקראית: הצמתים בודקים חלקים אקראיים של הנתונים.ככל שהצוותים נבדקים יותר, קשה יותר לתוקף לרמות. EIP אפילו מספק נוסחה לחשב את הסיכוי להצלחה של התקפה כזו, בהתבסס על המספר הכולל של הצמתים (n), דגימות הכוללות (m), ודגימות לכל הצמת (k). The table shows that the chances of a successful attack drop to a negligible level, which is why PeerDAS is considered secure against data-withholding attacks. For deeper analysis, you can refer to the linked . בלוג : Set upper bounds for MODEXP EIP-7823 תגיות7823 הצעה זו נדרשת משום שההכנה הנוכחית של MODEXP ב-Ethereum גרמה לטעויות רבות בהסכמה לאורך השנים. רוב הטעויות האלה התרחשו משום ש-MODEXP מאפשר גדלים גדולים מאוד ולא מציאותיים, מה שהופך את הנושאים הבלתי רגילים שהלקוחות צריכים להתמודד איתם. משום שכל צומת חייב לעבד את כל ההכנסות שהעסקה מספקת, שאין לו גבול עליון גורם ל-MODEXP להיות קשה יותר לבדוק, קל יותר לשבור, וסביר יותר להתנהג בצורה שונה בין לקוחות שונים. כניסות גדולות מאוד גם הופכות את הנוסחה של עלות הגז קשה להעריך, משום שקשה להעריך משהו כאשר גודלו יכול לגדול ללא גבול. בעיות אלה גם הופכות EIP-7823 מציג חוק פשוט: כל שלושת שדות האורך המשמשים MODEXP – הגודל של הבסיס, האקספוננט והמודול – חייבים להיות: , אשר הוא 1024 bytes. MODEXP כניסות בעקבות התבנית כפי שהוגדר ב , כך EIP זה רק מגביל את הערכים הארוך. אם כל אורך עולה על 1024 בייטים, המהדורה המוקדמת מפסיקה מיד, מחזירה שגיאה, ושרפה את כל הגז. לדוגמה, אם מישהו מנסה לספק BASE אשר הוא 2000 בייטים ארוך, השיחה תיכשל לפני כל עבודה מתרחשת. הגבולות האלה עדיין תומכים בכל המקרים של שימוש אמיתי. RSA אימות בדרך כלל משתמש בגדלים מפתח כגון 1024, 2048, או 4096 ביטים, כל היטב בתוך הגבול החדש. פעולות קווית אליפטית להשתמש בגדלים קטנים יותר, לעתים קרובות מתחת 384 ביטים, כך שהם גם לא מושפעים. 8192 bits or less <len(BASE)> <len(EXPONENT)> <len(MODULUS)> <BASE> <EXPONENT> <MODULUS> EIP-198 הגבלות חדשות אלה גם עוזרות עם שיפורים עתידיים.אם MODEXP נכתבת מחדש בקוד EVM באמצעות EVMMAX, מפתחים יכולים להוסיף דרכים אופטימיזציה עבור גדלים נפוצים כגון 256 סיביות, 381 סיביות, או 2048 סיביות, ולהשתמש בחזרה איטית יותר במקרים נדירים יותר.עם גדלים מקסימליים קבועים, מפתחים יכולים אפילו להוסיף טיפול מיוחד עבור ערכים מודול נפוצים מאוד. כדי לאשר שהשינוי הזה לא יפרק את העסקאות הקודמות, המחברים ניסו את כל השימוש ב- MODEXP מהבלוק 5,472,266 (20 באפריל 2018) ל- 21,550,926 (4 בינואר 2025). רוב השיחות האמיתיות השתמשו באורך קטן כמו 32 bytes, 128 bytes, או 256 bytes. הם היו מתנהגים באותו אופן תחת הגבולות החדשים, כיוון שהם כבר היו בלתי חוקיים.לכן, בעוד שה- EIP הוא מבחינה טכנית שינוי שבור, בפועל זה לא היה משנה את התוצאה של כל עסקה בעבר. 513 bytes 0x9e5faafc מנקודת מבט של אבטחה, הפחתת הגדלים המותרים לא יוצר סיכונים חדשים. במקום זאת, הוא מסיר מקרים קיצוניים מיותרים שגרמו בעבר לפגמים וחוסר עקביות ברחבי הלקוחות. על ידי הגבלת כניסות MODEXP לגדלים מציאותיים, EIP זה עושה את המערכת צפויה יותר, מפחית מקרים זוויתיים מוזרים ומוריד את הסיכוי שגיאות בין יישומים שונים. : Transaction Gas Limit Cap EIP-7825 דגם EIP-7825 Ethereum צריך את ההצעה הזו כי היום עסקה אחת יכולה להשתמש כמעט בכל הגבול הגז הבלוק. זה יוצר מספר בעיות: עסקה אחת יכולה לצרוך את רוב משאבי הבלוק ולגרום להאטה בסגנון DoS, עסקאות גדולות כבדות גז יכול להגדיל את המצב של Ethereum מהר מדי, ואת אימות בלוק הופך איטי יותר ויותר קשה עבור כוכבים לעקוב אחר. אם משתמש אחד מגיש עסקה ענקית המשתמשת כמעט את כל הגז (לדוגמה, עסקה שמשתמשת 38 מיליון גז ב 40 מיליון גז בלוק), אז עסקאות רגילות אחרות לא יכולות להתאים את הבלוק, וכל כוכב צריך לבלות זמן נוסף בדק את הבלוק הזה. EIP-7825 מציג חוק קשוח כי שום עסקה לא יכולה להשתמש יותר מ זה הופך למסגרת ברמה של פרוטוקול, כלומר זה חל בכל מקום: כאשר משתמש שולח עסקה, כאשר txpool בודק אותה, וכאשר מאשרים לכלול אותו בלוק. לדוגמה, גם אם הגבלת הגז הבלוק היא 40 מיליון, אף עסקה אחת אינה מורשה להשתמש מעל 16.7 מיליון גז. 16,777,216 gas (2²⁴) MAX_GAS_LIMIT_EXCEED MAX_GAS_LIMIT_EXCEED כדי להבין את זה טוב יותר, לדמיין בלוק יש מקום עבור 40 מיליון גז. ללא כיסוי זה, מישהו יכול לשלוח עסקה אחת שמשתמשת 35-40 מיליון גז. עסקה זו תהיה מונופוליזציה של הבלוק ולא להשאיר מקום לאחרים, דומה לאדם אחד לשכור אוטובוס שלם כך שאף אחד אחר לא יכול לטוס. ההצעה גם מוסיפה דרישות ספציפיות לאופן שבו הלקוחות מאשרים עסקאות. txpool חייב לסרב עסקה אם gasLimit שלה הוא מעל 16,777,216, כלומר עסקה כזו אף פעם לא נכנסת לקו. המספר הוא נבחר משום שהוא גבול כוח נקי של שניים, מה שהופך אותו קל יותר ליישם, והוא עדיין גדול מספיק כדי לטפל ברוב העסקאות בעולם האמיתי כגון פיתוח חוזה חכם, אינטראקציות DeFi מורכבות, או שיחות חוזה מרובות שלבים. 16,777,216 (2²⁴) This EIP also maintains compatibility with current gas mechanics. Most users will never notice the change because nearly all existing transactions already consume far less than 16 million gas. Validators and block builders can still create blocks that exceed 16.7 million total gas, as long as each individual transaction respects the new cap. The only transactions affected are extremely large ones that previously attempted to use more than the new limit. Those transactions must now be split into multiple smaller operations—similar to breaking a very large file upload into two smaller ones. This change is technically not backward-compatible for those rare extreme transactions, but the number of users affected is expected to be very small. במונחים של אבטחה, קופסת הגז עושה את Ethereum יותר עמיד להתקפות DoS המבוססות על גז, כי התוקפים לא יכולים לכפות את המאשרים להתמודד עם עסקאות גדולות ביותר יותר.זה גם עוזר לשמור על זמן אימות בלוק צפוי, כך שהקוביות יכולות להישאר בסנכרון בקלות רבה יותר. Overall, EIP-7825 is designed to strengthen the network against abuse, keep node requirements reasonable, improve fairness in block space usage, and ensure the chain remains fast and stable as gas limits continue to increase over time. : ModExp Gas Cost Increase EIP-7883 תגיות7883 The reason Ethereum needs this proposal is that the ModExp precompile (used for modular exponentiation) has been במצבים מסוימים, פעולות ModExp דורשות חישוב רב יותר ממה שהמשתמשים משלמים כרגע. כדי לתקן זאת, Ethereum צריך להתאים את נוסחת מחירים ModExp כך הגז המשמש משקף כראוי את העבודה האמיתית שנעשתה על ידי הלקוח, ולכן EIP-7883 מציג כללים חדשים הגדילו את העלות המינימלית, להעלות את העלות הכללית, ולהפוך את הפעולות עם כניסות גדולות (במיוחד אקספוננטים, בסיס, או מודול מעל 32 בייטים) יקרות יותר, כך המחיר של הגז תואם את החישוב האמיתי הנדרש. underpriced bottleneck הצעה זו משנה את אלגוריתם המחיר של ModExp שהוגדר במקור ב- EIP-2565 על ידי הגדלת העלות בכמה דרכים חשובות. הוא מעלה מ 200 ל 500, ואת הנוסחה הכללית כבר לא מחולקת על ידי 3, כלומר העלות הכוללת הופכת למעשה לדוגמה, אם שיחת ModExp הייתה עולה 1,200 גזים בעבר, כעת זה יעלה כ 3,600 גזים על פי הנוסחה החדשה. כדי להדגים זאת: אם אורך האקספוננט היה 40 בייטים, EIP-2565 היה מוסיף to the iteration count, while EIP-7883 now uses מחירים גבוהים פי שניים, והיום המחיר עולה. עלות ההרשמה עולה באופן משמעותי כאשר הערכים הללו עולה על 32 בייטים.לדוגמה, אם המודולוס הוא 64 בייטים, הכלל החדש חלה על מורכבות כפולה ( יחד, שינויים אלה מבטיחים כי פעולות קטנות ModExp לשלם תשלום מינימום הוגן, ופעולות גדולות, כבדות לסדר את העלות שלהם כראוי עם הגודל. minimum gas cost three times higher exponents larger than 32 bytes 8 × (40 − 32) = 64 16 × (40 − 32) = 128 minimum base/modulus size of 32 bytes 2 × words² ההצעה מגדירה פונקציית חישוב גז חדשה שמעדכנת את כללי המספר המורכבות והאיטריזציה. , where “words” is the number of 8-byte chunks. The iteration count is also updated so that exponents of 32 bytes or smaller use their bit length to determine complexity, but exponents larger than 32 bytes add a much larger penalty. This ensures that very large exponents, which are computationally expensive in practice, now have a much higher gas cost. Importantly, the minimum returned gas cost is enforced as 500 instead of the earlier 200, making even the simplest ModExp calls more realistically priced. 2 × words² המוטיבציה מאחורי העלאות המחירים האלה באה ממדיניות היקף המראה מצבים רבים שבהם Precompile ModExp היה מוערך באופן משמעותי. פעילויות טיפוסיות סביב , ופעולות גדולות מאוד או לא מאוזנות על ידי גורמים גדולים הרבה יותר - לפעמים יותר מאשר הכוונה היא לא לשנות את האופן שבו ModExp פועל, אלא להבטיח שגם במקרים המזיקים ביותר למשאביו הוא כבר לא מאיים על יציבות הרשת או מונע העלאות עתידיות לגבול הגז הבלוק. , אבל מחזור גז התרחש פעמים רבות בעבר ב Ethereum והוא מובן היטב. 150% 200% 80× backward-incompatible תוצאות הבדיקה מוכיחות עד כמה זה יכול להיות משמעותי. המחיר יהיה 500 גז (על 200) או שלוש פעמים את המחיר הקודם.אבל מקרים מסוימים של בדיקות כבדות רואים עלייה עצומה.לדוגמה, במבחן אחד "Exp-heavy", העלות קופצת מ 215 גז ל 16,624 גז - בערך במקרה אחר, המעורב בפעולה בסיסית כבדה, העלות הולכת מ- 1,026 ל- 94,448 גזים, אשר משקף את האופן שבו ההכפלה של המספרים הגדולים למעשה מתרחשת. 99.69% of historical ModExp calls 76× more במונחים של אבטחה, הצעה זו אינה יוצרת וקטורים חדשים לתקיפה או הופכת כל פעולה זולה יותר. במקום זאת, היא מתמקדת במניעת סיכון חשוב: פעולות ModExp במחיר נמוך עשויות לאפשר לתוקפים למלא בלוקים עם חישובים כבדים מאוד במחיר נמוך מאוד. Test Case EIP-2565 Pricing EIP-7883 Pricing Increase modexp_nagydani_1_square 200 500 150% modexp_nagydani_1_qube 200 500 150% modexp_nagydani_1_pow0x10001 341 2048 501% modexp_nagydani_2_square 200 512 156% modexp_nagydani_2_qube 200 512 156% modexp_nagydani_2_pow0x10001 1365 8192 501% modexp_nagydani_3_square 341 2048 501% modexp_nagydani_3_qube 341 2048 501% modexp_nagydani_3_pow0x10001 5461 32768 500% modexp_nagydani_4_square 1365 8192 501% modexp_nagydani_4_qube 1365 8192 501% modexp_nagydani_4_pow0x10001 21845 131072 500% modexp_nagydani_5_square 5461 32768 500% modexp_nagydani_5_qube 5461 32768 500% modexp_nagydani_5_pow0x10001 87381 524288 500% modexp_marius_1_even 2057 45296 2102% modexp_guido_1_even 2298 51136 2125% modexp_guido_2_even 2300 51152 2124% modexp_guido_3_even 5400 32400 500% modexp_guido_4_even 1026 94448 9105% modexp_marcin_1_base_heavy 200 1152 476% modexp_marcin_1_exp_heavy 215 16624 7632% modexp_marcin_1_balanced 200 1200 500% modexp_marcin_2_base_heavy 867 5202 500% modexp_marcin_2_exp_heavy 852 16368 1821% modexp_marcin_2_balanced 996 5978 500% modexp_marcin_3_base_heavy 677 2032 200% modexp_marcin_3_exp_heavy 765 4080 433% modexp_marcin_3_balanced 1360 4080 200% מונדיאל 1 / 1 / 1 200 500 150 אחוז תגית: מונדיאל 1 200 500 150 אחוז modexp_nagydani_1_pow0x10001 341 2048 501 אחוז מונדיאל - 2 ש"ח 200 512 156 אחוז תגית: אובמה אובמה 2 200 512 156% modexp_nagydani_2_pow0x10001 1365 8192 501% תגית: אובמה אובמה 3 341 2048 501% modexp_nagydani_3_qube 341 2048 501% modexp_nagydani_3_pow0x10001 5461 32768 500 אחוז modexp_nagydani_4_square 1365 8192 501% תגית: אובמה אובמה 4 1365 8192 501% modexp_nagydani_4_pow0x10001 21845 131072 500% modexp_nagydani_5_square 5461 32768 500 אחוז modexp_nagydani_5_qube 5461 32768 500 אחוז modexp_nagydani_5_pow0x10001 87381 524288 500% modexp_marius_1_אפילו 2057 45296 2102% modexp_guido_1_even 2298 51136 2125% תגית: מדריך 2 2300 51152 2124% modexp_guido_3_even 5400 32400 500% תגית: מדריך_4 1026 94448 9105 אחוז modexp_marcin_1_base_כבד 200 1152 476 אחוז modexp_marcin_1_exp_heavy 215 16624 7632 אחוז modexp_marcin_1_balanced 200 1200 500% modexp_marcin_2_base_heavy 867 5202 500% modexp_marcin_2_exp_heavy 852 16368 1821 אחוז modexp_marcin_2_balanced 996 5978 500 אחוז modexp_marcin_3_base_heavy 677 2032 200 אחוז modexp_marcin_3_exp_heavy 765 4080 433% modexp_marcin_3 שווה ערך 1360 4080 200 אחוז *source: https://eips.ethereum.org/EIPS/eip-7883#test-cases* : Determine proposer lookahead EIP-7917 EIP-7917 Ethereum needed this proposal because the network’s proposer schedule for the next epoch was not fully predictable. Even though the RANDAO seed for epoch ידועה בתקופה , רשימת המועמדים בפועל עדיין עשויה להשתנות עקב עדכוני איזון אפקטיבי (EB) המתרחשים בתוך התקופה . These EB changes can come from slashings, penalties, rewards above 1 ETH, validator consolidations, or new deposits—especially after EIP-7251 raised the maximum effective balance beyond 32 ETH. This uncertainty creates issues for systems that rely on knowing the next proposer in advance, such as based preconfirmation protocols, which need a stable and predictable schedule to operate smoothly. A validator could even try to “grind” or manipulate their effective balance to influence who becomes the proposer next epoch. Because of these problems, Ethereum needed a way to make the proposer schedule fully deterministic several epochs ahead so it cannot be changed by last-minute EB updates and can be easily accessed by the application layer. N+1 N N To implement this, the EIP introduces a deterministic proposer lookahead by pre-computing and storing the proposer schedule for the next MIN_SEED_LOOKAHEAD + 1 epochs at the start of every epoch. In simple terms, the beacon state now contains a list called that always covers two full epochs of proposers - 64 slots in total. For example, when epoch N begins, this list already includes the proposer for every slot in epoch N and epoch N+1. Then, when the network moves to epoch N+1, the list is shifted forward: the proposer entries for epoch N are removed, the entries for epoch N+1 move to the front, and new proposer entries for epoch N+2 are added at the end. This makes the schedule fixed, predictable, and easy for clients to read directly, instead of recomputing proposers every slot. proposer_lookahead כדי לשמור על זה מעודכן, הרשימה עוברת קדימה בכל גבול עידן: הנתונים עבור העידן הקודם נמחקים, ומגוון חדש של אינדיקטורים מציעים עבור העידן העתידי הבא מחושב ומוסכם.התהליך משתמש באותם זרעים וחוקי איזון אפקטיביים כמו קודם, אבל עכשיו לוח הזמנים מחושב מוקדם יותר, ומסיר את האפשרות של EB שינויים המשפיעים עליו לאחר הזרעים ידועים.הבלוק הראשון לאחר הפורק גם ממלא את טווח המבטא הזה כולו כך שכל העידנים העתידיים יש לוח הזמנים המקורי נכון. Imagine each epoch has 8 slots instead of 32 (just for simplicity). Without this EIP, during epoch 5, you know the seed for epoch 6, but the actual proposer for slot 2 of epoch 6 could still change if a validator gets slashed or earns enough rewards to change their effective balance inside epoch 5. With EIP-7917, at the of epoch 5, Ethereum pre-calculates all proposers for epoch 5, 6, and 7 and stores them in order inside . Now, even if balances change later in epoch 5, the proposer list for epoch 6 stays fixed and predictable. start proposer_lookahead This EIP fixes a long-standing oversight in the beacon chain design. It guarantees that once the RANDAO from earlier epochs becomes available, the validator selection for future epochs cannot be altered. This also prevents “effective balance grinding,” where a validator tries to adjust their balance after seeing the RANDAO to influence the next epoch’s proposer list. With deterministic lookahead, that entire attack vector is eliminated, making the security analysis much simpler. It also gives consensus clients early visibility into who will propose upcoming blocks, which helps implementations and allows the proposer schedule to be easily verified by the application layer via a Merkle proof from the beacon root. המחברים חשבו על אפשרויות חלופיות, כגון זיהוי משאבים אפקטיביים בתחילת עידן, אבל זה היה דורש אחסון נוסף ולא היה חושף את לוח הזמנים ל- EVM. הם גם בדקו את התאימות עם תכונות עתידיות כגון Single Secret Leader Election (SSLE). העיצוב הנוכחי נשאר תואם כי lookahead יכול יום אחד לאחסן מזהים מוצפנים של מועמדים, או אולי להיות מכוסה לחלוטין אם SSLE מסיר lookahead, מבלי לשבור כלום. לפני הצעה זו, הלקוחות רק חישבו את המציע עבור החריץ הנוכחי. עם EIP-7917, הם עכשיו לחשב את רשימת המועמדים עבור כל החריצים של העידן הבא בבת אחת במהלך כל מעבר עידן. זה מוסיף כמות קטנה של עבודה, אבל חישוב אינדיקטורים המועמדים הוא קל מאוד בעיקר כולל דגימה של רשימות אימות באמצעות הזרעים. EIP זה אינו משנה את אופן הפעולה של עיכוב RANDAO. הוא עדיין נובע מהRANDAO של התקופה . The only change is that effective balances are now aligned with the same delay, so validators cannot modify their EB after seeing the RANDAO result. This removes a potential manipulation strategy, even though no attack had been discovered yet. The deterministic lookahead therefore, strengthens security and prevents malicious alteration of proposer schedules. N N − MIN_SEED_LOOKAHEAD − 1 : Blob base fee bounded by execution cost EIP-7918 EIP-7918 Ethereum צריך הצעה זו מכיוון שהמערכת הנוכחית של דמי blob (מתוך ) breaks down when execution gas becomes the main cost for rollups. Right now, most rollups pay much more for execution gas (the cost of including their blob transaction in the block) than they pay for the actual blob fee. This creates a problem: even if Ethereum keeps lowering the blob base fee again and again, the rollup’s total cost does not really change, because the expensive part is still the execution gas. Because of this, the blob base fee keeps falling until it reaches the absolute minimum (1 wei), and the protocol can no longer use the blob fee to control demand. Then, when blob usage suddenly goes up, the blob fee needs many blocks to climb back to a normal level. This makes prices unstable and unpredictable for users. EIP-4844 For example, imagine a rollup wants to post its data: it pays about 25,000,000 gwei in execution gas (25 gwei per gas for roughly 1,000,000 gas), while the blob fee is only around 200 gwei. This means the total cost is roughly 25,000,200 gwei, where almost the entire cost comes from execution gas, not the blob fee. If Ethereum keeps lowering the blob fee—say from 200 gwei to 50 gwei, then to 10 gwei, and eventually down to 1 wei—the total cost barely changes at all, staying almost exactly 25,000,000 gwei. Because users don’t feel any difference, they don’t change their behavior, so the protocol keeps pushing blob fees down until they hit the minimum possible value. Then, when blob demand suddenly increases again, the blob base fee has to climb all the way up from 1 wei, causing sharp, unpredictable fee spikes. תיקנה זאת על ידי הקמת מחיר מינימלי "משמר" עבור דמי blob אשר תלוי בתשלום הבסיס של ביצוע, ומונעת מחירי blob ליפול נמוך באופן לא מציאותי ולשמור על מחיר blob הרבה יותר יציב ומדויק עבור רוולפים. תגית: EIP 7918 הרעיון הבסיסי של EIP-7918 הוא פשוט: המחיר של בלוב לא צריך להיות זול יותר מהמחיר של כמות מסוימת של גז ביצוע (הנקרא ב- EIP, קבוע זה מוגדר . The mechanism works through a small change inside the function. Usually, this function increases or decreases the blob base fee depending on whether blocks are using more or less blob gas than the target. With this proposal, if a blob becomes “too cheap” compared to execution gas, the function stops subtracting the target blob gas. This makes the excess blob gas grow faster, which prevents the blob base fee from falling further. As a result, the blob base fee now has a minimum value equal to . BLOB_BASE_COST 2¹³ calc_excess_blob_gas() BLOB_BASE_COST × base_fee_per_gas ÷ GAS_PER_BLOB כדי להבין מדוע זה נדרש, זה עוזר להסתכל על ביקוש blob. rollup דואג על המחיר הכולל שהוא משלם: עלות ביצוע פלוס עלות blob. אם עלות גז ביצוע הוא גבוה מאוד - למשל, 20 gwei - אז גם אם עלות blob יורד מ 2 gwei ל 0.2 gwei, עלות הכוללת בקושי משתנה. .” It creates a situation where the demand curve is almost vertical: lowering price does not increase demand. When this happens, the blob base fee mechanism becomes blind—it keeps lowering the price even though demand does not react. That is why the blob base fee often slides down to 1 wei. Then, when real demand increases later, the protocol needs an hour or more of nearly full blocks to raise the fee back up to a reasonable level. EIP-7918 fixes this by establishing a reserve price tied to execution gas so that blob fees remain meaningful even when execution costs dominate. fee inelasticity סיבה נוספת להוסיף את המחיר המשמעותי הזה היא כי הצמתים צריכים לעשות הרבה עבודה נוספת כדי לאמת את ההוכחות KZG עבור נתוני blob. , a node only had to verify one proof per blob, which was cheap. But with (PeerDAS), blobs are broken into many small pieces called cells, and every cell has its own proof. This makes verification much heavier. For example, the execution layer now has to batch-verify 128 proofs for every single blob before a transaction can even enter the mempool—this is about fifteen times more expensive than the normal KZG proof verification that smart contracts pay for. On top of that, full nodes, supernodes, and validators must verify even more proofs depending on how many columns they store or sample. A typical full node must verify proofs for all blobs in the mempool, plus eight sampled columns every slot, plus four columns it permanently custodies. All of this uses real CPU time, and it isn’t free for node operators. If blob fees drop too low, users would get this expensive compute work from the network essentially for free. By linking the blob reserve price to execution gas fees, EIP-7918 makes sure blob users always pay at least a fair minimum amount for the load they put on nodes. EIP-4844 תגית: 7594 In the long run, EIP-7918 also helps prepare Ethereum for the future. As technology improves, the cost of storing and sharing data naturally gets cheaper, and Ethereum is expected to allow more blob data over time. When blob capacity increases, blob fees (in ETH) should naturally go down. This proposal supports that because the reserve price is tied to execution gas prices, not a fixed number, so it can adjust as the network grows. As both blobspace and execution blockspace expand, their price relationship stays balanced. The only time the reserve price might become too high is in a very unlikely future where Ethereum increases blob capacity a lot but does not increase execution gas capacity. In that case, blob fees might end up higher than needed. But Ethereum is not planning to scale in that way—both blobspace and execution blockspace are expected to grow together. Because of this, the chosen value ( ) נחשב בטוח ומאוזן היטב. BLOB_BASE_COST = 2¹³ יש פרט אחד קטן להבין כאשר דמי ביצוע גז קופצים פתאום. מכיוון שהמחיר של הבסיס של blob תלוי בתשלום הבסיס של ביצוע, עלייה פתאומית בהוצאות ביצוע יכול להדחוף באופן זמני דמי blob למצב שבו דמי ביצוע מובילים אותם. לדוגמה, לדמיין גז ביצוע קופץ פתאום מ -20 gwei ל -60 gwei בלוק אחד. מכיוון שהמחיר של הבסיס של blob קשור למספר זה, דמי blob לא יכולים לרדת מתחת לרמה הגבוהה ביותר החדשה. דמי blob ימשיכו לעלות בדרך כלל אם משתמשים ב-blob, אבל הפרוטוקול לא יאפשר להם להוריד עד שהם יעלו מספיק כדי להתאים את עלות ביצוע הגבוהה יותר. המחברים גם ביצעו ניתוח אמפירי על-ידי יישום הכלל של המחיר המוגן לפעילות של blob אמיתית מ and במהלך תקופת ההוצאה לפועל (כמעט) ), the reserve threshold significantly increased the blob base fee compared to the old mechanism. During low-execution-fee periods (around על ידי השוואה של אלפי בלוקים, המחברים מראים כי המנגנון החדש יוצר מחירים יציבים יותר תוך שהוא עדיין מגיב באופן טבעי לדרישה. November 2024 March 2025 16 gwei average 1.3 gwei average In terms of security, the change does not introduce any risks. The blob base fee will always settle at or above the cost of units of execution gas. This is safe because the mechanism only raises the minimum fee, and setting a lower bound on pricing does not interfere with protocol correctness. It simply ensures healthy economics. BLOB_BASE_COST : RLP Execution Block Size Limit EIP-7934 תגיותEIP-7934 Before EIP-7934, Ethereum did יש גבול עליון קפדני לגבי גודל הבלוק של ביצוע RLP. בתיאוריה, בלוק יכול להיות גדול מאוד אם הוא מכיל הרבה עסקאות או נתונים מורכבים מאוד. ו . If a block was too large, it would take longer for nodes to download and verify it, which slowed block propagation and increased the chance of temporary blockchain forks. Worse, an attacker could deliberately create a very large block to overload nodes, causing delays or even knocking them offline — a classic denial-of-service scenario. At the same time, Ethereum’s consensus layer (CL) gossip protocol already refused to propagate any block over , meaning oversized execution blocks could fail to spread across the network, creating fragmentation or nodes disagreeing on the chain. Because of these risks, Ethereum needed a clear, protocol-level rule to prevent oversized blocks and keep the network stable and secure. not network instability DoS attack risks 10 MB EIP-7934 solves this by introducing a on the size of an RLP-encoded execution block. The maximum allowed block size ( ) מוגדר על ידי , but because beacon blocks also consume some space ( , Ethereum מוסיף a . This means the actual maximum RLP-encoded execution block size allowed is אם הבלוק המקודד גדול יותר מהגבול הזה, הבלוק נחשב and nodes must reject it. With this rule in place, block producers must check the encoded size of every block they build, and validators must verify this limit during block validation. This size cap applies of gas limits -meaning even if a block is “ ” it can still be rejected if its encoded size is too large. This ensures that both gas usage and real byte-size constraints are respected. protocol-level cap MAX_BLOCK_SIZE 10 MiB (10,485,760 bytes) SAFETY_MARGIN 2 MiB (2,097,152 bytes) MAX_RLP_BLOCK_SIZE = MAX_BLOCK_SIZE - SAFETY_MARGIN invalid independently under the gas limit, בחירת A כל דבר גדול יותר מ 10 MiB לא יועבר ברחבי הרשת בכל מקרה, ולכן EIP זה מביא את שכבת הביצוע לתאם עם הגבולות של שכבת ההסכמה. 10 MiB cap השינוי הזה הוא עם בלוקים גדולים יותר מהגבלת החדשה, כלומר, מכורים ואנשי אימות חייבים לעדכן את הלקוחות שלהם כדי לכבד את הכלל. עם זאת, מאז בלוקים גדולים מדי כבר היו בעייתיים ולא נורמליים בפעולה אמיתית, ההשפעה היא מינימלית. במונחים של אבטחה, EIP זה מחזק באופן משמעותי את Ethereum נגד התקפות DoS בגודל בלוק ממוקד על ידי הבטחת שאף משתתף לא יכול ליצור בלוקים שמכסים את הרשת. not backward-compatible : Count leading zeros (CLZ) opcode EIP-7939 תגית: EIP 7939 לפני EIP זה, Ethereum היה כדי לספור את מספר ה-zero-bits המובילים במספר 256 סיביות, התפתחים נאלצו ליישם את CLZ באופן ידני ב-Solidity באמצעות פעולות שינוי סיביות רבות ולהשוואות. , ו , which increased gas usage. For zero-knowledge proving systems, the cost was even higher — right-shifts are extremely expensive to prove, so operations like CLZ slowed down ZK circuits significantly. Since CLZ is a very common low-level function used in math libraries, compression algorithms, bitmaps, signature schemes, and many cryptographic or data-processing tasks, Ethereum needed a faster and cheaper way to compute it. no built-in opcode slow, expensive used a lot of bytecode EIP-7939 solves this by introducing a . This opcode takes a 256-bit value from the stack and returns the number of leading zero bits. If the input number is zero, the opcode returns , because a 256-bit zero has 256 leading zero bits. This matches how CLZ works in many CPU architectures like ARM and x86, where this operation is native. Adding CLZ makes many algorithms significantly cheaper: operations like , , , various math functions, byte-string comparisons, bitmap scanning, calldata compression/decompression, and post-quantum signature schemes all benefit from faster leading-zero detection. new opcode called CLZ (0x1e) 256 lnWad powWad LambertW דומה לזה של , and slightly raised from the old MUL price to avoid underpricing the opcode and causing DoS risks. Benchmarks show that CLZ uses roughly the same compute effort as ADD, and in the SP1 rv32im proving environment, CLZ is actually ה-EIP מסביר גם מדוע בחרו ב-CLZ במקום ב-ZK. : you can compute CTZ from CLZ using , but you reliably implement CLZ using CTZ, so CLZ is more fundamental. The gas cost for CLZ is set to 5 ADD cheaper to prove than ADD CTZ (count trailing zeros) x & -x cannot This EIP is fully backwards-compatible because it introduces a opcode ואינו משנה כל התנהגות קיימת. הוא מכסה גם מקרים של קצה בבירור: לדוגמה, opcode מחזיר 256 כאשר ההכנסה היא אפס, וכמה מקרים של בדיקה מראים מקורות כגון כל אפס, ערכים בוטים, ו-nonzero לחלוטין. מאז CLZ יש עלות גז צפויה ונמוכה, אין צמיחה של הזיכרון, ואין שינויים במצב, הוא בטוח מפני בעיות דחיית שירות. new Overall, EIP-7939 makes Ethereum faster, cheaper, and more developer-friendly by adding a simple, efficient primitive that modern CPUs already support — cutting gas, reducing bytecode size, and lowering ZK proving costs for many common operations. : Precompile for secp256r1 Curve Support EIP-7951 EIP-7951 לפני EIP זה, Ethereum עשה יש דרך בטוחה, מקורית לאמת חתימות דיגיטליות שנוצרו באמצעות . This curve is the standard used in modern devices like . Because of this missing support, apps and wallets could not easily use device-level hardware security for signing. There was an earlier attempt (RIP-7212), but it had related to point-at-infinity handling and incorrect signature comparison. These issues could cause incorrect verification or even risk consensus failures. not secp256r1 (P-256) curve Apple Secure Enclave, Android Keystore, HSMs, TEEs, and FIDO2/WebAuthn security keys two serious security vulnerabilities EIP-7951 fixes those security problems and introduces a safe, native precompile so Ethereum can finally support signatures from modern hardware securely and efficiently. EIP-7951 מוסיף חדש at address called , אשר מבצעת אימות חתימה של ECDSA באמצעות קווית secp256r1. זה עושה אימות חתימה מהיר וזול בהשוואה ליישם את האלגוריתם ישירות ב- Solidity. Precompile משתמש בפרמטרים הרשמיים של קווית המוגדרים על ידי NIST, כולל מודול שדה, שווית קווית, נקודת בסיס, ודרגת תת-קבוצת, מבטיח אבטחה קריפטוגרפית חזקה. נקודות וסקאלרים מקודדים בפורמט 32-אייט קפדני, וערך 64-אייט של כל אפס משמש לייצג את הנקודה באינסוף. —the hash, signature (r, s), and public key coordinates (qx, qy)—and it returns for success or for failure. precompiled contract 0x100 P256VERIFY 160 bytes of input 32 bytes of 1 empty output The EIP also defines strict . It checks that r and s are within valid ranges, that the public key lies on the curve, and that it is not the point at infinity. If anything is invalid, the precompile returns failure without reverting and consumes the same gas as a successful call. The verification algorithm follows standard ECDSA: it computes s⁻¹ mod n, rebuilds the signing point R’, rejects if R’ is infinity, and finally checks whether the x-coordinate of R’ matches r (mod n). This corrects the mistake in RIP-7212, which compared r’ directly instead of reducing it mod n. input validation rules The secp256r1 curve is fully defined by the following set of parameters: Base field modulus = p = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff Curve equation: y^2 = x^3 + ax + b (mod p) Curve coefficient a = 0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc Curve coefficient b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b Base point G: Gx = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 Gy = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 Subgroup order = n = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 Cofactor = h = 0x1 פרמטרים אלה סטנדרטיים על ידי NIST ב SP 800-1861. עלות הגז עבור הפעולה נקבעה , which is higher than the RIP-7212 version, but matches actual performance benchmarks for secp256r1 verification. Importantly, the interface remains fully compatible with Layer 2 networks that already deployed RIP-7212—same address, same input/output format—so existing smart contracts will continue to work with no changes. The only difference is the corrected behavior and higher gas cost. 6900 gas Input: P256VERIFY call excepts 160 Bytes as input that is interpreted as byte concatenation of: 32 bytes ----> message hash (h) 32 bytes ----> signature component (r) 32 bytes ----> signature component (s) 32 bytes ----> public key x-coordinate (qx) 32 bytes ----> public key y-coordinate (qy) Output: will be 32 bytes on successfull verification and 0 bytes on failure Input Validation: The precompile MUST perform the following validation checks and return `` (failure) if any check fails: 1. Input length: Input MUST be exactly 160 bytes 2. Signature component bounds: Both r and s MUST satisfy 0 < r < n and 0 < s < n 3. Public key bounds: Both qx and qy MUST satisfy 0 ≤ qx < p and 0 ≤ qy < p 4. Point validity: The point (qx, qy) MUST satisfy the curve equation qy^2 ≡ qx^3 + a*qx + b (mod p) 5. Point not at infinity: The point (qx, qy) MUST NOT be the point at infinity (represented as (0, 0)) מנקודת מבט של אבטחה, EIP משחזר את ההתנהגות הנכונה של ECDSA, מסיר חששות של malleability ברמה של precompile (השאיר בדיקות אופציונליות ליישומים), ומבהיר כי ביצוע בזמן קבוע אינו נדרש עבור precompile.The secp256r1 קווית מספק אבטחה 128 סיביות והוא אמין וניתן לנתח באופן נרחב, מה שהופך אותו בטוח עבור אימוץ Ethereum. בקיצור , , fix the security issues of the earlier proposal, and provide a reliable, standardized way to verify P-256 signatures across the entire ecosystem. EIP-7951 is needed to safely bring modern hardware-backed authentication to Ethereum הטבלה הבאה מסמלת אילו לקוחות Ethereum צריכים ליישם שינויים עבור כל Fusaka EIP. מציין כי EIP דורש עדכונים ללקוחות שכבת ההסכמה, בעוד סימן מראה כי השינוי משפיע על הלקוחות של שכבת ביצועים.כמה EIP דורשים עדכונים בשני שכבות, בעוד שאחרים ספציפיים רק לאחת מהן. Consensus Client Execution Client EIP Number EIP Name Consensus Client Execution Client EIP-7594 PeerDAS - Peer Data Availability Sampling ✅ ✅ EIP-7823 Set upper bounds for MODEXP ✅ EIP-7825 Transaction Gas Limit Cap ✅ EIP-7883 ModExp Gas Cost Increase ✅ EIP-7917 Deterministic proposer lookahead ✅ EIP-7918 Blob base fee bounded by execution cost ✅ EIP-7934 RLP Execution Block Size Limit ✅ EIP-7939 Count leading zeros (CLZ) opcode ✅ EIP-7951 Precompile for secp256r1 Curve Support ✅ תגית: 7594 PeerDAS - Peer Data Availability Sampling ✅ ✅ EIP-7823 הגדרת גבולות עליונים עבור MODEXP ✅ דגם EIP-7825 מגבלת גז Cap ✅ EIP-7883 העלאת עלויות הגז של ModExp ✅ תגית: EIP 7917 תגית: lookahead ✅ EIP-7918 תשלום בסיס Blob מוגבל על ידי עלות ביצוע ✅ EIP-7934 RLP Execution Block Size Limit ✅ תגית: EIP 7939 Count leading zeros (CLZ) opcode ✅ EIP-7951 Precompile for secp256r1 Curve Support ✅ In summary, these are the key EIPs included in the Fusaka hard fork. While several improvements touch both consensus and execution clients—ranging from gas adjustments and opcode updates to new precompiles—the , which introduces peer-to-peer data availability sampling, enabling more efficient and decentralized handling of blob data across the network. major change of this upgrade is PeerDAS
