ERC-5805 — Voting With Delegation

Back to DeFi Building Blocks

ERC-5805: Voting with Delegation Checkpointing

ERC-5805 is the standard interface that ERC-20Votes / ERC-721Votes implement. Token holders delegate voting power to themselves or an address (a representative). Voting power is tracked in historical checkpoints so a governance vote at block N can read the delegate's voting power as it was at block N — protecting against flash-loan governance attacks.

Required Methods

function clock() external view returns (uint48);
function CLOCK_MODE() external view returns (string memory);
function getVotes(address account) external view returns (uint256);
function getPastVotes(address account, uint256 timepoint) external view returns (uint256);
function delegates(address account) external view returns (address);
function delegate(address delegatee) external;

Neo Equivalent

The Neo C# port stores per-account checkpoints (block, votes) in storage and reads them at vote time using binary search. Same flash-loan-resistance property, implemented identically.

Live on Neo TestNet

Both implementations deployed on Neo N3 TestNet.

Implementation	TestNet Address	Contract Hash
Solidity (neo-solc)	NUKHCo2gUfGE3vAyKDCYfWvkHcCjkN4MmL	0xb87fa58c…035f3110
Neo C# (nccs)	NSXG6PtP19h74j4xZyPTV6myWdMcWSsRwz	0x1d33818b…3243692

Verified: ERC-6372 clock interface (CLOCK_MODE = "mode=blocknumber&from=default"), token symbol, delegation API. Both implementations use block.number / Ledger.CurrentIndex as the timestamp source — flash-loan-resistant by construction. docs/standards-mirror/deployments/erc-5805/.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

abstract contract Votes {
    struct Checkpoint { uint48 fromBlock; uint208 votes; }

    mapping(address => Checkpoint[]) private _checkpoints;
    mapping(address => address)      public  delegates;

    event DelegateChanged(address indexed delegator, address indexed from, address indexed to);
    event DelegateVotesChanged(address indexed delegate, uint256 oldVotes, uint256 newVotes);

    function clock() public view returns (uint48) { return uint48(block.number); }

    function getVotes(address account) public view returns (uint256) {
        uint len = _checkpoints[account].length;
        return len == 0 ? 0 : _checkpoints[account][len - 1].votes;
    }

    function getPastVotes(address account, uint256 timepoint)
        public view returns (uint256)
    {
        require(timepoint < block.number, "future");
        Checkpoint[] storage cps = _checkpoints[account];
        if (cps.length == 0) return 0;
        // Binary search
        uint lo; uint hi = cps.length;
        while (lo < hi) {
            uint mid = (lo + hi + 1) / 2;
            if (cps[mid - 1].fromBlock <= timepoint) lo = mid; else hi = mid - 1;
        }
        return lo == 0 ? 0 : cps[lo - 1].votes;
    }

    function delegate(address delegatee) public {
        address old = delegates[msg.sender];
        delegates[msg.sender] = delegatee;
        emit DelegateChanged(msg.sender, old, delegatee);
        // ... move votes from old to delegatee, write checkpoints ...
    }
}

using System;
using System.ComponentModel;
using System.Numerics;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("VotingToken")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep17)]
public class VotingToken : SmartContract
{
    private const byte Prefix_Balance      = 0x01;
    private const byte Prefix_Delegate     = 0x02;
    private const byte Prefix_Checkpoint   = 0x03;   // delegate+blockIdx -> votes
    private const byte Prefix_NumCheckpts  = 0x04;   // delegate -> count

    [DisplayName("DelegateChanged")]
    public static event Action<UInt160, UInt160, UInt160> OnDelegateChanged;
    [DisplayName("DelegateVotesChanged")]
    public static event Action<UInt160, BigInteger, BigInteger> OnDelegateVotesChanged;

    public static uint Clock() => Ledger.CurrentIndex;
    [Safe]
    public static string ClockMode() => "mode=blocknumber";

    public static UInt160 DelegateOf(UInt160 account)
        => (UInt160)Storage.Get(Storage.CurrentContext,
                                new byte[] { Prefix_Delegate }.Concat(account));

    public static BigInteger GetVotes(UInt160 account)
    {
        var n = (BigInteger)(Storage.Get(Storage.CurrentContext,
                new byte[] { Prefix_NumCheckpts }.Concat(account)) ?? ByteString.Empty);
        if (n == 0) return 0;
        return ReadCheckpointVotes(account, n - 1);
    }

    public static BigInteger GetPastVotes(UInt160 account, uint blockIndex)
    {
        if (blockIndex >= Ledger.CurrentIndex) throw new Exception("future block");
        var n = (BigInteger)(Storage.Get(Storage.CurrentContext,
                new byte[] { Prefix_NumCheckpts }.Concat(account)) ?? ByteString.Empty);
        if (n == 0) return 0;

        // Binary search for the last checkpoint with fromBlock <= blockIndex
        BigInteger lo = 0, hi = n;
        while (lo < hi)
        {
            var mid = (lo + hi + 1) / 2;
            if (ReadCheckpointBlock(account, mid - 1) <= blockIndex) lo = mid;
            else hi = mid - 1;
        }
        return lo == 0 ? 0 : ReadCheckpointVotes(account, lo - 1);
    }

    public static void Delegate(UInt160 delegatee)
    {
        if (!Runtime.CheckWitness(Runtime.CallingScriptHash) &&
            !Runtime.CheckWitness(delegatee))
            throw new Exception("must sign");

        var delegator = Runtime.CallingScriptHash;
        var oldDel = DelegateOf(delegator);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Delegate }.Concat(delegator), delegatee);

        var amount = BalanceOf(delegator);
        if (oldDel != null && !oldDel.Equals(UInt160.Zero))
            MoveVotes(oldDel, -amount);
        MoveVotes(delegatee, amount);

        OnDelegateChanged(delegator, oldDel ?? UInt160.Zero, delegatee);
    }

    public static BigInteger BalanceOf(UInt160 a)
        => (BigInteger)(Storage.Get(Storage.CurrentContext,
            new byte[] { Prefix_Balance }.Concat(a)) ?? ByteString.Empty);

    private static void MoveVotes(UInt160 delegate_, BigInteger delta)
    {
        var current = GetVotes(delegate_);
        var newVotes = current + delta;
        WriteCheckpoint(delegate_, newVotes);
        OnDelegateVotesChanged(delegate_, current, newVotes);
    }

    private static void WriteCheckpoint(UInt160 acct, BigInteger votes)
    {
        var n = (BigInteger)(Storage.Get(Storage.CurrentContext,
                new byte[] { Prefix_NumCheckpts }.Concat(acct)) ?? ByteString.Empty);
        var cpKey = new byte[] { Prefix_Checkpoint }.Concat(acct).Concat((ByteString)n.ToByteArray());
        var blob  = StdLib.Serialize(new object[] { (BigInteger)Ledger.CurrentIndex, votes });
        Storage.Put(Storage.CurrentContext, cpKey, blob);
        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_NumCheckpts }.Concat(acct), n + 1);
    }

    private static BigInteger ReadCheckpointBlock(UInt160 acct, BigInteger idx)
        => (BigInteger)((object[])StdLib.Deserialize(
            Storage.Get(Storage.CurrentContext,
                new byte[] { Prefix_Checkpoint }.Concat(acct).Concat((ByteString)idx.ToByteArray()))))[0];

    private static BigInteger ReadCheckpointVotes(UInt160 acct, BigInteger idx)
        => (BigInteger)((object[])StdLib.Deserialize(
            Storage.Get(Storage.CurrentContext,
                new byte[] { Prefix_Checkpoint }.Concat(acct).Concat((ByteString)idx.ToByteArray()))))[1];
}