Solidity Online

לכתוב, להריץ ולשתף קטעי קוד - בלי שום התקנה.

Contract.sol

לחצו על הרצה כדי לראות כאן את הפלט.

ארגומנטיםערכים שמועברים לפונקציה main(...) של החוזה שלכם. ה-runner מקודד אותם ב-ABI לפי סוגי הפרמטרים.

אין ארגומנטים. לחצו על "להוסיף ארגומנט" כדי להעביר אחד.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "forge-std/console.sol";

contract Counter {
    uint256 public count;
    event Counted(uint256 value);

    function main() external {
        count = 42;
        emit Counted(42);
        console.log("count set to:", count);
    }
}

נסו Solidity בדפדפן

Solidity היא השפה של החוזים החכמים ב-Ethereum. היא רצה על ה-EVM, אותה מכונה וירטואלית שמאבטחת מאות מיליארדי דולרים ב-mainnet ומפעילה את רוב רשתות ה-L2. העורך הזה נותן לכם עורך Monaco שמחובר ל-solc ול-EVM של geth בסביבה מבודדת, כך שאפשר לכתוב חוזה, ללחוץ על הרצה ולראות בדיוק מה היה קורה on-chain: פלט של console.log, events שנפלטו והמצב הסופי של משתני ה-storage שלכם, בלי לפרוס שום דבר, בלי לשלם gas ובלי לגעת בארנק.

Solidity יוצאת דופן בכמה דברים שכדאי לשים לב אליהם בהתחלה. storage הוא קבוע כברירת מחדל: כל מה שמושם למשתנה state נשמר; כל מה שבתוך פונקציה נעלם כשהקריאה מסתיימת. events הם הדרך שבה חוזים מתקשרים עם העולם החיצון (ה-frontend שלכם, ה-indexer שלכם, The Graph): הם עולים gas, נכתבים ללוגים של הטרנזקציה, ואפשר לסנן אותם לפי פרמטרים מסוג indexed. וכל פונקציה חיצונית מקבלת את הקלט שלה דרך קידוד ABI, לא דרך stdin, ולכן העורך מציע חלונית Args עם טיפוסים שמתחברת ישירות לפרמטרים של main(...) שלכם.

במה עורך ה-Solidity הזה טוב במיוחד

הרצה אמיתית של solc ו-EVM, לא סימולציה של transpiler. console.log משתמש ב-forge-std, ונתיבי ה-emit וה-storage עוברים דרך הסמנטיקה האמיתית של ה-EVM: opcodes, gas, הכול.
לשונית Events מציגה כל emit מההרצה, עם פרמטרים מסוג indexed שמסומנים בנפרד, כך שאפשר לראות בדיוק מה frontend או subgraph היו מקבלים.
לשונית Storage מציגה את הערך הסופי של כל משתנה state שהחוזה נגע בו, כולל רשומות של mapping (למשל balances[0xabc...]). משתנים שלא כתבתם אליהם לא מופיעים.
חלונית Args עם טיפוסים מעבירה ערכים ל-main(uint256 n, string memory name, ...) עם פרמטרים. המריץ מקודד אותם ב-ABI לפי החתימה של הפונקציה שלכם, כך ש-42 הופך ל-uint256 ו-"hello" הופך ל-string.

מה אפשר לבנות בעורך ה-Solidity האונליין

חוזי מונה עם הגדלה והקטנה כדי ללמוד איך משתני state נשמרים בין קריאות: כתבו ל-count, הריצו, וצפו בו מופיע בלשונית Storage.
תבניות של העברת טוקנים: פלטו Transfer(from indexed, to indexed, value) וראו איך שדות indexed ושדות רגילים מוצגים אחרת בלשונית Events, בדיוק כמו שהם מופיעים ב-log topics אמיתיים של ה-EVM.
מקרי כשל עם require / revert: כתבו תנאי הגנה שנכשל על קלט שגוי וראו את הודעת ה-revert מופיעה ב-stdout, במקום לשרוף gas על טרנזקציה שנכשלה ב-mainnet.

שאלות נפוצות על Solidity

מה זה Solidity?

Solidity היא שפת החוזים החכמים הנפוצה ביותר עבור Ethereum ורשתות תואמות EVM (Polygon, Arbitrum, Optimism, Base וכו'). היא מתקמפלת ל-bytecode של EVM, סט פקודות של מכונת מחסנית שכל צומת ברשת מריץ. מבחינת תחביר היא שואלת מ-JavaScript ומ-C++, אבל הסמנטיקה שונה מאוד: storage יקר וקבוע, כל קריאה נמדדת ב-gas, ואין async. העורך נותן לכם EVM מבודד כדי שתוכלו לתרגל את השפה בלי לגעת ברשת אמיתית.

צריך ארנק או ETH של testnet כדי להשתמש בזה?

לא. העורך מריץ את החוזה שלכם בתוך EVM בצד השרת (אותו מנוע ש-geth מגיע איתו) בקונטיינר מבודד לכל בקשה. אין טרנזקציה on-chain, אין gas שמשולם ב-ETH אמיתי ואין חתימת ארנק. כשלוחצים על הרצה, המריץ פורס את החוזה לרשת חדשה בזיכרון, קורא לפונקציה main(...) שלכם עם הארגומנטים שסיפקתם, ומציג את stdout, ה-events וה-storage מהקריאה הזו. הכול נמחק אחרי ההרצה.

איך מעבירים קלט לחוזה?

תנו לחוזה פונקציה בשם main(...) עם הפרמטרים המוגדרים שתרצו: function main(uint256 n) external או function main(string memory name, uint256 age, bool active) external view. אחר כך הוסיפו את הערכים בחלונית Args שמתחת לעורך. המריץ בודק את החתימה של הפונקציה ומקודד את המחרוזות שלכם ב-ABI לטיפוסים הנכונים, בדיוק כמו ש-cast call עושה בשורת הפקודה. לארגומנט מסוג address, הקלידו 0x...; ל-bool, הקלידו true או false; ל-uint, הקלידו את הערך העשרוני.

מה ההבדל בין הלשוניות Output, Events ו-Storage?

Output מציגה את כל מה שכתבתם ל-stdout דרך console.log(...) מ-forge-std/console.sol, וגם כל הודעת שגיאה של revert / require. Events מציגה כל event שהחוזה פלט במהלך ההרצה, לפי הסדר, עם הערך של כל פרמטר (ותווית קטנה "indexed" לפרמטרים מסוג indexed: אלה נכנסים ל-log topics של ה-EVM ואפשר לסנן אותם בכלים כמו The Graph). Storage מציגה את הערך שאחרי ההרצה של כל משתנה state שנכתב, כולל רשומות בודדות של mapping; משתנים שלא נגעתם בהם לא מופיעים ברשימה.

למה בחלק ממדריכי ה-Solidity שקראתי אין main()?

ברשת אמיתית, לחוזי Solidity אין נקודת כניסה אחת: לקוחות קוראים לכל פונקציה ציבורית שהם רוצים, שמזוהה לפי ה-selector בן 4 הבתים שלה. העורך משתמש ב-main() כמוסכמה, כדי שיהיה דבר ברור להריץ ומקום לשים בו ארגומנטים. מחוץ לעורך, החוזה שלכם בדרך כלל יחשוף כמה פונקציות (mint, transfer, withdraw, ...), וה-frontend שלכם או כלי כמו cast / ethers / viem בוחרים לאיזו מהן לקרוא.

כלים שימושיים ל-Solidity

כלים חינמיים בדפדפן שמשתלבים היטב עם עורך ה-Solidity אונליין - כולם חלק מ-Coddy.

דף עזר Solidity השוואת פלטפורמות לימוד תכנות