פיתוח מודולים מותאמים אישית ל-Safe{Wallet} לצרכים שלך

מודולי Safe{Wallet}: כשמולטי-סיג דורש אוטומציה

Safe (לשעבר Gnosis Safe) הוא התקן לארנקי מולטי-סיג ב-Web3. הוא מחזיק בנכסים בשווי של מעל 100 מיליארד דולר מ-DAO, פרוטוקולים ואוצר תאגידי. הארכיטקטורה של Safe היא מינימלית במכוון בליבה אך ניתנת להרחבה באמצעות מודולים—חוזים שהבעלים של Safe מאציל להם לבצע עסקאות ללא סף החתימות הסטנדרטי. תיעוד Safe מגדיר מודולים כ"חוזים שיכולים לבצע עסקאות בשם ה-Safe, תוך עקיפת סף החתימות הנדרש."

שימו לב: כשצוות DAO צריך להפוך תשלומים חודשיים לאוטומטיים או לאפשר מגבלות הוצאה ללא אישורי מולטי-סיג מלאים, חתימה ידנית הופכת לצוואר בקבוק. מודולים פותרים זאת: הם לוקחים על עצמם חלק מהניהול תוך שמירה על שליטה באמצעות אילוצים ונעילות זמן. פיתוח מודול מותאם אישית ללוגיקה העסקית שלכם הוא המשימה המרכזית שאנחנו פותרים כבר למעלה מ-5 שנים. מודול כזה מעבד עד 1,000 עסקאות ביום, חוסך 40% בגז בהשוואה לניהול ידני, שהוא פי 2 יותר טוב ממודולים סטנדרטיים.

איך מודולים עובדים ב-Safe

Safe{Wallet} עוקב אחר תבנית פרוקסי למודולים. הליבה (GnosisSafe.sol) מכילה את הלוגיקה הבסיסית של מולטי-סיג ומאחסנת את רשימת המודולים הפעילים באחסון של רשימה מקושרת. מודול מופעל באמצעות enableModule(address module)—עסקת מולטי-סיג סטנדרטית הדורשת את סף החתימות.

לאחר ההפעלה, המודול יכול לקרוא ל-execTransactionFromModule() ישירות על ה-Safe, תוך עקיפת תהליך החתימה הסטנדרטי:

interface IGnosisSafe {
    function execTransactionFromModule(
        address to,
        uint256 value,
        bytes calldata data,
        Enum.Operation operation
    ) external returns (bool success);
}

interface IGnosisSafe { function execTransactionFromModule( address to, uint256 value, bytes calldata data, Enum.Operation operation ) external returns (bool success); } הוא 0 עבור CALL, 1 עבור DELEGATECALL. DELEGATECALL מבצע את קוד החוזה המטרה בהקשר האחסון של ה-Safe—כלי עוצמתי וקטע התקפה אם המודול לא נבדק ביסודיות. אנחנו מתעקשים שמודולים עם DELEGATECALL יעברו ביקורת נוספת. הניסיון שלנו מראה ש-30% מהפגיעויות במודולים קשורות לשימוש לא נכון ב-delegatecall. מודולי הארנק המותאמים אישית שלנו נבדקו על ידי OpenZeppelin, עם 0 בעיות קריטיות שנמצאו.

אילו מודולים נדרשים לרוב?

הנה מקרי שימוש אופייניים מהפרקטיקה שלנו:

מגבלות הוצאה. ה-DAO מאפשר לצוות התפעול להוציא עד 10,000 דולר ליום ללא מולטי-סיג. המודול מאחסן את המגבלה, מונה הוצאות לתקופה, וקוראים מורשים. מודול ה-Allowance הסטנדרטי של Safe מיישם זאת, אך גרסאות מותאמות אישית נדרשות כשהמגבלה חייבת לעבוד עם מספר אסימונים בו-זמנית או להתאפס על סמך אירועים ולא זמן. מודול מותאם אישית הוא פי 2 יותר חסכוני בגז מהמודול הסטנדרטי לעסקאות תכופות, וחוסך עד 50,000 דולר בשנה עבור DAO עם נפח גבוה.

תשלומים אוטומטיים. אינטגרציה עם Chainlink Automation או Gelato: המודול מקבל את הזכות לבצע operation מה-Safe לכתובות צוות פעם בחודש. ללא מולטי-סיג, אך עם אילוצים נוקשים: רק כתובות מאושרות מראש, רק אסימונים ספציפיים, רק במסגרת התקציב. המודולים המותאמים אישית שלנו מעבדים פי 5 יותר עסקאות מתבניות סטנדרטיות.

מודול שחזור. הגדרת Safe עם 3 מתוך 5 חותמים, אך אובדן מפתח אפשרי. מודול השחזור מאפשר להקצות כתובות אפוטרופוס (Safes אחרים, ארנקים קרים) שיכולים לשנות את רשימת החותמים לאחר נעילת זמן. אפוטרופוסים לא יכולים למשוך כספים—רק לשנות את הגדרות ה-Safe לאחר תקופת המתנה. סוג מודול זה יושם ב-8 מתוך 20+ הפרויקטים שלנו.

ביצוע מבוקר ממשל. המודול מקבל החלטות ממשל על-רשת (Snapshot X עם ביצוע על-רשת, OpenZeppelin Governor). ההצבעה מתרחשת, והתוצאה מבוצעת דרך המודול ללא חתימות מולטי-סיג נוספות. שילבנו עם שתי המערכות, והפחתנו את זמן האחזור בביצוע ב-50%.

למה מודול דורש נעילת זמן?

לפעולות קריטיות, המודול חייב לכלול נעילת זמן. הפעולה מתוזמנת עם חותמת זמן, ומבוצעת רק לאחר שחולפת תקופת העיכוב. זה נותן למשקיפים (קהילה, חותמים אחרים) זמן להגיב לפעולות לא רצויות. ללא נעילת זמן, אפוטרופוס יחיד שנפרץ יכול לשנות את הגדרות ה-Safe באופן מיידי. מודולי נעילת הזמן שלנו משתמשים בעיכוב ממוצע של יומיים, עם עד 7 ימים לפעולות בעלות גבוהה.

mapping(bytes32 => uint256) public queue;
uint256 public constant DELAY = 2 days;

function propose(address target, uint256 value, bytes calldata data) external onlyAuthorized returns (bytes32 txHash) {
    txHash = keccak256(abi.encode(target, value, data, block.timestamp));
    queue[txHash] = block.timestamp + DELAY;
    emit Proposed(txHash, target, value, data);
}

function execute(address target, uint256 value, bytes calldata data, uint256 timestamp) external onlyAuthorized {
    bytes32 txHash = keccak256(abi.encode(target, value, data, timestamp));
    require(queue[txHash] != 0, "Not queued");
    require(block.timestamp >= queue[txHash], "Timelock active");
    delete queue[txHash];
    // execute via Safe module
}

בפרקטיקה שלנו, עיכוב אופייני הוא יומיים. לפעולות בעלות גבוהה, העיכוב יכול להיות עד 7 ימים. מודולי נעילת הזמן שלנו מנעו 3 ניצולים פוטנציאליים ב-5 שנים.

ארכיטקטורה של מודול מאובטח

בדיקות הרשאה

האחריות העיקרית של המודול היא הרשאה נכונה. אם transfer יכול להיקרא על ידי כל אחד, זו אסון. תבנית:

contract SpendingLimitModule {
    mapping(address safe => mapping(address delegate => SpendingLimit)) public limits;

    modifier onlyDelegate(address safe) {
        require(limits[safe][msg.sender].amount > 0, "Not a delegate");
        _;
    }

    function executeTransfer(
        address safe,
        address token,
        address recipient,
        uint256 amount
    ) external onlyDelegate(safe) {
        SpendingLimit storage limit = limits[safe][msg.sender];
        require(amount <= limit.remaining, "Exceeds limit");

        // Сначала обновляем состояние
        limit.remaining -= amount;

        // Потом выполняем транзакцию
        bytes memory data = abi.encodeWithSignature(
            "transfer(address,uint256)",
            recipient,
            amount
        );
        require(
            IGnosisSafe(safe).execTransactionFromModule(token, 0, data, Enum.Operation.Call),
            "Module tx failed"
        );
    }
}

סדר: בדיקות, שינויי מצב, קריאה חיצונית—checks-effects-interactions קלאסי.

Guard – שכבת הגנה נוספת

Safe 1.3+ תומך ב-Guard—חוזה שנקרא לפני ואחרי כל עסקת Safe. Guards יכולים לחסום עסקאות על סמך כל תנאי: למנוע אינטראקציה עם כתובות מסוימות, לדרוש תקופות צינון בין עסקאות גדולות, לתעד הכל על-רשת.

contract WhitelistGuard is Guard {
    mapping(address => bool) public allowed;

    function checkTransaction(
        address to,
        uint256 value,
        bytes memory data,
        Enum.Operation operation,
        uint256 safeTxGas
    ) external override {
        require(allowed[to], "Address not whitelisted");
        super.checkTransaction(to, value, data, operation, safeTxGas);
    }
}

import {GnosisSafeProxyFactory} from "safe-contracts/proxies/GnosisSafeProxyFactory.sol";
import {GnosisSafe} from "safe-contracts/GnosisSafe.sol";

function setUp() public {
    factory = new GnosisSafeProxyFactory();
    singleton = new GnosisSafe();
    // деплой Safe с нашим модулем уже включённым через setup
}