Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Institutional-grade tokens
Tally powers token sales, distribution, and utility for 500+ protocols including Arbitrum, Uniswap, ZKsync, and Wormhole.
Ready to launch your token? .
Tally handles your airdrop, ICO, and vesting so you can focus on building
Tally's token launch platform reduces time to launch with production-ready, end-to-end solutions. Set your protocol up for success with a launch platform that reduces engineering timelines, vendor migrations, and custom integration work. As your protocol evolves, add staking, vesting, governance, or multi-chain support to meet the needs of your ecosystem.
Public token sales: Execute liquidity bootstrapping pools (LBPs) or other sale mechanisms with custom interfaces that simplify participation
: Distribute tokens to millions of recipients with gas-optimized claim processing
: Ship custom-designed claim pages with your branding and domain that provide clarity and consistency across all token operations
: Implement lockup periods and vesting schedules that integrate seamlessly with on-chain providers and custodians
: Launch tokens simultaneously across multiple EVM chains with unified supply management. Recipients claim on their preferred network without wrapped assets or bridging
: Launch just the token, pair it with from day one to incentivize long-term commitment, add to enable decentralized decision-making immediately, or progressively enable components later as your protocol matures.
Ready to launch your token? .
Users can easily draft proposals using proposal templates that are set up by their organization. Instead of manually locating, copying, and pasting a contract address for a custom action, users can conveniently create a proposal using their organization’s custom contract address book. Additionally, proposals created using proposal templates are also more easily identifiable on the proposal page since they have human readable names.
To implement proposal templates for your organization, reach out to us at [email protected].
Test proposals appear on the organization homepage indefinitely. Tally does not delete test proposals to maintain operational security.
Partial delegation is a voting mechanism that allows token holders to split voting power across multiple delegates rather than assigning it all to a single delegate. For example, if a user controls 1000 tokens, the user could delegate 400 tokens to Delegate A, 400 tokens to Delegate B, and self-delegate the remaining tokens.
Additional Reading: Arbitrum Partial Delegation and Private Voting Solutions Research
Multisig governance is typically paired with a signal voting mechanism to maintain legitimacy. As an example, Yearn, Synthetix, and Sushiswap all use the Snapshot voting tool to let token holders make key decisions and delegate authority.
After considering a proposal in the community's discussion venue, a signal vote will be held to assess support. While this typically involves voting with Snapshot, in some cases communities may use on-chain signal voting (eg. early Yearn ygov.finance voting tool) or off chain voting which is weighted by user accounts instead of token holdings (eg. polls in Discourse forums or Discord).
Regardless of voting system used (on or off chain, weighted by users or token holdings), the vote itself doesn't trigger execution of the proposal's effects. Instead, the vote serves as instructions for the multisig signers to execute the proposal using their admin priveledges.
Gasless voting enables free voting for tokenholder on Tally
Voting has become unaffordable for many delegates on Ethereum L1. Tally provides the infrastructure for organizations to fund a budget for gasless voting and execute voting transactions via a relayer service. The mechanism operates seamlessly as the allocated budget is submitted to Tally for the facilitation of these transactions.
To learn more about how relay works & why it's important read the Relay section.
Currently ENS DAO sponsors gasless voting on Tally will be live as of April 4, 2024.
Wallet must have ENS name registered as the wallet’s primary name
Wallet must have at least 100 ENS in delegated voting power
8 votes per wallet (subject to increase)
Relay enables free delegation for eligible token holders.
Token holders can delegate their voting power, whether to themselves or a trusted delegate, with Relay generously covering the associated gas fees for these delegation transactions. The mechanism operates seamlessly as organizations allocate a dedicated budget to Tally for the facilitation of these transactions.
However, certain restrictions are in place to ensure fair participation. To utilize this gasless delegation service, token holders must meet specific criteria, including holding the minimum token requirements stipulated by each organization. For token holders who do not meet these eligibility criteria, conventional delegation remains an option, with the responsibility of covering gas fees falling on the individual.
Tally will only relay for token holders who hold at least a minimum number of governance tokens. The minimums vary per organization: 10 ENS, 10 UNI, 30 GTC, 40 ARB, or 50 POOL.
Tally will only relay a delegation transaction once per wallet per organization.
Add vesting with Hedgey & Sablier
Optional transfer restrictions, vesting schedules, and lockup mechanisms with seamless integration to specialized on-chain vesting providers and custodians like Hedgey and Sablier.
Team and investor allocations: Distribute tokens to team members and investors with multi-year vesting schedules and cliff periods to align long-term incentives.
Airdrop vesting: Combine airdrops with vesting to prevent immediate sell pressure while rewarding community members over time.
Grants and contributor rewards: Set up vesting schedules for grant recipients and protocol contributors to encourage sustained participation.
Ready to integrate vesting? .
Tally is the best place to explore organization delegates.
Tally is the home for organization delegation, on Tally you can:
To vote in a Governor organization you must delegate tokens to yourself or to another address.
Easily explore all delegates in a organization. Filter by voting power, popular delegates, or the issues you care about (Public Goods, Security, and more).
Create a delegate statement, link your twitter, and signal to voters what issues you care about.
Explore delegates for any organization directly on Tally and decide how to delegate your vote!
To navigate to the Delegates page, click Community in the organization homepage.
Select Community.
You can search by ENS name or wallet address. You can sort delegates by Voting Power and Received Delegations. You can also choose a Focus Area from the All Focus Areas dropdown menu.
Click the Delegate button to easily delegate your voting power to that organization member, or click on their profile name to learn more about their participation in the organization.
Security Council elections are a pivotal aspect of decentralized governance, ensuring that the guardianship of a organization remains in the hands of its community.
Step 1: Navigate to security council .
Step 2: .
Step 3: Complete contender registration flow.
Step 4: Sign message and submit transaction.
Step 1: Navigate to security council .
Step 2: Connect ledger via Wallet Connect.
Step 3: Complete contender registration flow.
Step 4: Follow the prompts and sign message in Wallet Connect,
Step 5: Follow the prompts and sign transaction in Wallet Connect,
If you need additional support please contact [email protected] or message Tally on.
Launch branded token sales with custom interfaces
Execute liquidity bootstrapping pools (LBPs) or other sale mechanisms with custom interfaces.
Tally builds branded token sale experiences that abstract away technical complexity, allowing you to seamlessly distribute tokens.
Launch token sales with tailored experiences that match your brand and specific distribution requirements. Tally's infrastructure handles the technical complexity while you maintain full control over the sale mechanics and user experience.
Key capabilities:
Design & deploy incentives to bootstrap protocol usage and accrue token value
Well-designed incentives and staking programs attract aligned token holders who add value to your protocol. Tally provides a complete, modular staking solution—open-source smart contracts and a ready-to-use interface that makes participation effortless. Deploy reward programs and staking systems tailored to your protocol's needs without building infrastructure from scratch.
Protocols use Tally's incentives and staking solution to return protocol revenue to token holders, reward long-term commitment, encourage governance participation, incentivize DeFi liquidity, and compensate network validators.
Reward active governance participants for their time
Reward active governance participants for their time, expertise, and contributions.
Compensation mechanisms encourage thoughtful participation while reducing voting power concentration among large holders. Tally's solutions include requirements to ensure only engaged and accountable delegates are rewarded.
Design compensation structures that reward quality participation, not just voting power. Tally's infrastructure integrates reputation scoring to ensure rewards go to delegates who actively contribute to governance.
Key features:
enhance security, community engagement, & delegate transparency.
Extend Tally's governance platform with integrations that enhance security, community engagement, and delegate transparency.
Create or link a Safe to your organization for secure multi-signature treasury management. Managing your Safe through Tally enables access to all governance features maintaining the security of multi-sig approvals.
For help using Tally as a Safe multisig, .
Key features of Tally's governance solutions
Secure, transparent, and efficient voting mechanisms ensure all governance decisions reflect the will of the community. Collaborative proposal creation tools enable multiple contributors to work together seamlessly, while no-code fund transfers simplify complex governance actions without requiring coding skills. Approved proposals execute automatically with support for arbitrary executable actions that run directly through the governance system.
Learn more about and delegating on .
The Tally API is in open beta!
The makes it easy to query onchain data about Governor organizations. List Governors, onchain proposals, and accounts with delegations. Use the API to build notifications, dig into voter data or build governance right into your game or app.
Comprehensive Data Access: Dive deep into the world of Governor organizations. From listing Governors to exploring on-chain proposals and accounts with delegations, we've got you covered.
A decentralized voting application
Tally Zero is a completely decentralized voting application that uses React and IPFS via thirdweb. This app allows you to connect to any governor address and vote on a proposal in a completely decentralized way.
Interested in Tally zero? .
is a completely decentralized voting application designed to facilitate onchain voting via the InterPlanetary File System (IPFS) through thirdweb. It serves as a fundamental tool to ensure that people can always vote onchain, even if all the more complex front ends, such as Tally and Boardroom, are down.
Explore your organization's homepage.
The Tally homepage shows details about a specific organization, including current and past proposals, assets, and delegates.
On the organization Home page, key information & metrics are shown. You'll also see a button to Delegate vote on the right hand side along with your voting power information.
You can put any on-chain action into a Tally proposal using Custom Actions.
Custom Actions on Tally provide a versatile way to create and manage organization proposals with complex requirements. These actions enable users to execute a variety of operations within a single proposal. Custom actions include any on-chain action that Tally does not have a custom UI for (ex: token transfers).
Tally has recipe books for the following custom actions:
Tally offers simplified tuple arrays in Custom Actions.
Tally's Custom Action builder supports the tuple[] type, called tuple arrays.
The tupletype in Soldity is a data structure that contains a fixed number of elements, each of which can be of a different type. For instance, a tuple can contain an integer, a string, and a boolean value all together. The tuple[]type, called a "tuple array", contains a list of tuples.
How to create a organization swap proposal on Tally
Empower your organization by creating an on-chain proposal on Tally using the Swaps recipe! This tool allows organizations to exchange tokens directly from their treasuries, facilitating treasury diversification. These organization Swaps are powered by .
A organization member formulates a swap proposal, specifying the assets to trade and the amount to sell. The UI provides an
Tally enables crosschain governance with Advanced Execution.
Advanced execution refers to the execution of actions specified in a proposal as soon as it is passed.
In a basic execution scenario, a proposal, once approved by the organization members, would need to be manually executed by someone, usually a organization member or a designated executor. This manual step can introduce delays and is dependent on human intervention.
On the other hand, advanced execution involves setting up smart contracts and automated processes to execute the actions specified in a proposal as soon as it is approved. This can include sending funds to a specified address, but can also involve more complex actions such as interacting with other smart contracts, triggering certain functions, or even a series of actions that need to be executed in a specific order.
Campaign for delegations on Tally by creating a delegation statement.
Make voting more capital efficient, cheaper or more private
The Scopelift team built a Flexible Voting extention with support from Uniswap Grants Program. For implementation details, check out :
This new building block allows arbitrary delegate contracts to be developed which can unlock all kinds of new use cases, such as:
Voting with tokens while earning yield in DeFi
Voting on L2 with bridged tokens
Use diff checker to identify any possible differences between an existing Snapshot Proposal and a new on-chain proposal made on Tally.
Users can create an on-chain proposals of a snapshot proposal on the Tally platform. Voters should use the diff checker to view check what differences are made, if any, in the new on-chain proposal on Tally.
Private voting encrypts individual votes on-chain while maintaining verifiable final results. Votes are encrypted when cast and only decrypted after the voting period ends, revealing the final tally while preserving voter privacy.
Private voting can be implemented on top of a Governor with Flexible Voting. Implement the in the Governor, then deploy a shielded pool that uses zero-knowledge proofs or MPC to keep votes private. Voters can move votes into the pool, then the pool sends its vote totals back to the Governor without revealing the votes.
Additional Reading:
Tally enables on-chain transactions via Safe, including submitting proposals, voting, and delegating.
Learn how to deploy, configure and operate Tally staking contracts.
These technical guides go in-depth on how staking works, how to set it up, and how to operate a staking system.
Tally is built on top of the . Tally indexes the on-chain data from and enables users to make calls to Governor smart contracts running autonomously on the blockchain.
To be compatible with the Tally app, we recommend you use OpenZeppelin's . This modular, battle-tested system of organization smart contracts gives token holders control of their organization on-chain.
A typical Governor organization uses three contracts: a token contract, a Governor contract, and a timelock contract.
How to configure and deploy a Governor
Controlling multisig Safes with Governor
Governor is composable with Gnosis Safe, which has led to an emerging ecosystem of Governor <> Safe integrations that enable new organization use cases.
Tally supports a variety of on-chain voting mechanisms.
How to upgrade a multi-sig to a fully onchain DAO
from Tally and from Zodiac put together this video walkthrough about how to upgrade a Gnosis Safe to an onchain Governor on Tally:
This upgrade path is particularly useful for progressively decentralizing a DAO. Often, a multisig makes sense for a newer DAO with a smaller treasury. As the stakeholder set expands, organization might find that it needs the security and decentralization of onchain proposals.
This Zodiac upgrade path makes it easy to progressively convert the Safe into a Governor without moving all assets and permissions between contracts.
Protocol-agnostic integration: Support for Balancer LBPs and custom sale contracts
Branded experiences: White-labeled interfaces that align with your protocol's design
Simplified user flows: Abstract away complexity
Real-time analytics: Track participation, raised capital, and token distribution metrics
Hyperwave partnered with Tally to plan and execute its token sale using Balancer's liquidity-bootstrapping pool (LBP). Tally built a custom token sale interface and worked with the Hyperwave team throughout the launch process to maximize token sales.
Results:
Raised ~$500k in initial token sale
Seamless user experience
Custom interface that matched Hyperwave's brand
How it worked:
Tally designed and deployed a branded token sale page
Users could participate through a simplified interface
The Tally team provided ongoing support throughout the launch window
Post-sale analytics and reporting helped inform future token distribution decisions
Ready to launch a token sale? Talk to our team to get started.
Reputation score tracking: Measure delegate engagement across voting, forum contributions, and discussion activity
Automated eligibility gating: Only delegates meeting minimum thresholds receive compensation
Flexible distribution models: Configure rewards based on voting power, reputation, or hybrid approaches
Transparent dashboards: Public visibility into delegate scores and participation history
Obol uses Tally's infrastructure to reward governance participants based on Delegate Reputation Score (DRS).
How it works:
Delegates receive scores from 0-100 based on voting participation, forum rationales, and discussion engagement.
Only delegates with DRS ≥ 65 qualify for compensation. Active delegates receive rewards using a square root model based on delegated voting power, reducing concentration while supporting smaller delegates.
Token holders view delegate scores and participation history directly on Tally for informed delegation decisions.
Learn more about Obol's delegate compensation system.
Ready to launch delegate compensation? Talk to our team to get started.
One common use case for advanced execution involves interacting with a cross-chain bridge in a situation where the exact cost of the transaction is not known in advance. For example, a organization may have a timelock contract that currently has no funds in it, and they need to send an instruction to a cross-chain bridge. However, the bridge charges a fee for moving messages from one blockchain to another, and the exact cost of this fee is not known until the transaction is executed. As a result, it is not possible to specify the fee when creating the proposal.
In such scenarios, advanced execution can be extremely useful as it allows the organization to write the smart contract code in such a way that the necessary funds (e.g., ETH) can be sent to the execute function at the time of execution, which then gets forwarded to the timelock contract, and ultimately to the final destination (the cross-chain bridge).
Advanced execution works by allowing the smart contract underlying a proposal to include more sophisticated logic and actions that can be executed automatically once the proposal is approved.
In the example above, the smart contract code for the proposal could be written to include a function that sends ETH to the execute function of the contract. This ETH would then be forwarded to the timelock contract, and then to the final destination (the cross-chain bridge). This way, even though the exact fee for the cross-chain bridge is not known at the time of creating the proposal, the necessary funds can still be sent at the time of execution.
When a proposal is created, then you can enter some ETH value to send in the Custom Action’s recipe.
To use advanced execution, you need to include the necessary logic and actions in the smart contract code underlying the proposal.
When creating a proposal, you can specify the amount of ETH (or any other token) to be sent as part of the Custom Action’s recipe. This is the set of instructions that will be executed if the proposal is approved.
For example, you could specify that a certain amount of ETH should be sent to the execute function of the contract as part of the Custom Action’s recipe. This ETH would then be forwarded to the timelock contract and then to the final destination as specified in the smart contract code.
Click on the organization you want to create a statement for.
You'll see a Delegation Statement for that organization directly beneath the header. Click Edit.
Click Edit at the top right of the Delegation Statement box.
The next page allows you to populate your Delegate Profile. Click the box to indicate you're actively seeking delegations, then use the text editor to write and preview your full delegation statement. At the bottom, you can auto-generate a summary using AI, or choose to enter it manually.
Create a Delegate Profile.
Click the Save button at the top right to share your delegate statement live on Tally.
Connect this wallet to our platform
Complete the profile creation process
Important: If you have Rabby wallet installed as a browser extension, it may prevent Solana wallets from being detected. If you don't see your Solana wallet options, temporarily disable the Rabby extension and refresh the page.
Obtain your Ledger's Solana address through your wallet interface
Email [email protected] with:
Subject: "Ledger Address Update"
Current profile address (from software wallet)
Ledger Solana address
You'll receive email confirmation when your profile is updated
Connect your Ledger device when accessing our platform
You'll need to add your hardware wallet through your software wallet's interface
Create a new stake account specifically for your Ledger wallet address (similar to the stake account you made with your software wallet)
Use your hardware wallet for all transactions moving forward
Cross-post proposals to Discourse with Tally's forum bot. Automatically sync governance activity between Tally and your Discourse forum to keep community discussions aligned with on-chain voting. Talk to our team to get started.
Distinguish high quality delegates from less active ones through our Karma integration. Delegates receive karma scores based on their participation in governance, both on-chain and in forums. Talk to our team to get started.
Enable token holders to delegate voting power to trusted representatives without transferring token ownership. Tally's delegation system supports full delegation, partial delegation across multiple delegates, and integrations with staking and token launch.
Enable cross-chain governance with Multigov to meet token holders where they are. Organization members can govern from any chain, with support for Solana, Ethereum, and EVM-compatible L2s. MultiGov lowers barriers to participation by reducing gas costs for L1 governance and allows protocols to expand to new networks while maintaining unified governance.
Remove financial barriers to governance participation by eliminating gas fees for voting and delegation. Relay is a sponsorship system where organizations cover transaction costs for members' governance activities.
Expand governance across new EVM networks with full platform support. Tally integrates network archive nodes, block explorers, and API access to enable all platform features. Integration process typically takes 5-10 business days.
Ready to launch governance? Talk to our team to get started.
Versatility: Dreaming of building a notification system for organization proposals? Or perhaps integrating governance mechanics into your next big game? The Tally API supports a myriad of applications.
Ease of Use: With our GraphQL-based API, you only request the data you need. Plus, with GraphQL's self-documenting nature, you'll find it a breeze to navigate and understand our API's capabilities.
Robust Support: Our community and support channels are always ready to assist. Whether you're just getting started or need advanced technical support, we're here for you in our Discord.
Interested in learning more? Talk to our team to get started.
Decentralization: Tally Zero is built using React and IPFS via ThirdWeb, which ensures that the application is completely decentralized. This means that it does not rely on any central authority or single point of failure, making it resilient and secure.
Onchain Voting on the application allows users to connect to any governor address and vote on a proposal in a completely decentralized manner. This ensures that the voting process is transparent, secure, and tamper-proof.
Zero Dependency: Tally Zero is designed to be a zero-dependency application. This means that it does not rely on any external services or applications to function. Even if other front ends are down, Tally Zero will still be operational, ensuring that people can always vote onchain.
IPFS Deployed: The application is deployed on IPFS, a peer-to-peer hypermedia protocol designed to make the web faster, safer, and more open. This ensures that the application is accessible from anywhere in the world and is resistant to censorship.
In June 2023, AWS had a compute outage that affected Tally during a big vote in Aribtrum DAO. Voting through the outage was made possible by Tally Zero.
Get the full story here.
After running validations, the recipe prepares executable code – including a call to Milkman – for execution upon proposal execution.
Upon proposal passage and execution, the proposal puts the Milkman market order on-chain.
An offchain Milkman bot listens for the swap request and forwards it to the CoW protocol.
CoW solvers compete to fill the order at the best price.
Shielded voting (i.e. secret/private voting)
Cheaper subsidized signature based voting
Tally is looking for partners to integrate support for this extension. If you're considering deploying a Governor with flexible voting, reach out to us at [email protected].



How to make your Token and Governor contract compatible with Tally
Tally supports organizations on Ethereum, Polygon, Optimism, Arbitrum, Avalanche, Base, Moonbeam, Scroll, BNB Chain, Gnosis, and various testnets.
Tally connects with the on-chain contracts for your organization in two places. Tally’s servers index the on-chain data, and Tally’s web3 site helps users make calls directly to the contracts running on the blockchain.
Here, we describe the interface that your contracts need to follow to be compatible with Tally. The easiest way to be compatible is to use the Open Zeppelin Wizard to deploy a governance token and governor
If you do need to change something, check that your contracts implement the methods and event logs in the sections below to make sure that your changes are compatible with Tally’s data indexing and transaction calls.
Tokens: ERC-20 and NFTsOpenZeppelin GovernorCompound Governor BravoSupported Use Cases FAQLearn about decentralized governance from overviews of key concepts, individual protocols, and voting system frameworks.
Learn about what decentralized governance is and why it matters.
Staking for value accrual: Return protocol revenue or treasury assets to token holders through staking rewards. Distribute value from protocol fees, native token emissions, or treasury holdings.
Delegate compensation: Reward active governance participants based on their contributions and engagement. Integrate reputation scoring to gate compensation.
Multiple reward sources: Distribute rewards from protocol revenue, treasury assets, token emissions, or combine all three—in any ERC20 token or multiple tokens simultaneously
Governance integration: Staked tokens retain full voting power, so holders don't have to choose between earning rewards and participating in governance. Optionally, make rewards conditional on active governance participation
Liquid staking support: Enable token holders to earn rewards while keeping their tokens transferable and usable across DeFi.
Flexible eligibility criteria: Design custom requirements for earning rewards based on specific behaviors that benefit your protocol.
Battle-tested contracts: Deploy with confidence using audited, open-source smart contracts.
Ready to launch incentives and staking? Talk to our team to get started.
The Proposals page shows a list of proposals associated with the organization. Any active proposals will be shown at the top, with a chronological list of past proposals below. Click Load more to see more.
Click on a proposal to go to the relevant Proposal Page.
The Community page offers an overview of the organization's delegates. The Top Delegates chart shows the current top 5 delegates' voting power over time,
Clicking on a delegate's name will take you to the relevant Tally Profile.
The Treasury page displays information on theorganization's top assets.
Below, the Gnosis Safes section displays information on any linked Gnosis Safes. Click on a Safe to access its Gnosis Safe Page.
The Admins section at the bottom shows the organization admins - users who are able to update settings on the organization's homepage.
You can access Contract Parameters from the More section.

Your organizations shows a list of all of the organizations you're a member of, split into two sections: organizations you manage (organizations where you have the SuperAdmin or Admin role), and organization memberships. Click on any organization to navigate to its organization Page.
A Tally Profile shows details about that wallet's organization Memberships and POAPs. It also includes information the user has added via Settings.
At the top, you'll see a voter's display name, wallet address, and linked Twitter account. You'll also see a Delegate button, which allows you to delegate your voting power to that address.
Below, you'll see that voter's organization Memberships, with information on their voting power and delegations for each organization.
The POAPs section displays POAPs held by the address.
Update the information shown on your Tally Profile by accessing Settings from the drop-down menu or clicking the Edit Profile button from your Tally Profile.
Click the Edit button to make changes.
The information you enter in Settings is public to everyone. The data in your Tally Profile is a mix of on-chain data and off-chain data. Editing your Tally Profile adds off-chain data to the on-chain data for your address. In some cases, it overrides the on-chain data (e.g. your Tally name and avatar override your address’s ENS name and avatar, if any).
Update your Tally username.
Choose a PFP from your wallet or upload an image.
Update your Bio to tell us a bit about you!
Link your Twitter account.
Generate a Tally API key. Visit our API Portal to learn more!
Click Log out to sign out of your Tally Profile.
Each action involves targeting specific contract addresses, selecting appropriate contract methods, and setting calldata according to the needs of the specific operation being proposed. This flexibility allows for a wide range of governance activities to be conducted seamlessly.
To include custom actions in your proposal on Tally, enter the Target contract address or upload your ABI file if the contract is not on Etherscan. Select the desired Contract method, and enter the call data for that method.
To create a proposal with a tuple array, add Custom Actions to your proposal. Then, use the imported ABI. Tally will infer the type from the ABI and help build the tuple array.
If a tuple or tuple array is nested in another tuple, enter the nested tuple(s) in plaintext with brackets. This tuple builder contains two nested tuple arrays, contactDetailsand chains , and one nested tuple bountyTerms :
To add tuple arrays and tuples, enter them in plaintext:
Gather Feedback: Users can easily gather feedback on organization proposals before submitting them on-chain.
Retain Context: All draft proposal metadata is recorded and included in the on-chain proposal when submitted.
Flexibility in Submission: Draft proposals are created offchain and can later be submitted on-chain at any time. This makes it possible for different stakeholders to create the proposal and ultimately submit it.
If you've created a draft that you are no longer interested in using, you can delete it from the Preview screen: just open the overflow menu in the top right and select "Delete draft".
Tally detects the connected wallet is a smart contract wallet (Safe).
Tally will automatically detect the Safe wallet
Multiple signatures may be required
Do not close the window while the signing flow is in progress
A sign in message will appear
A Safe transaction URL is generated and displayed:
This URL can be shared with co-signers for multi-sig Safes
Complete signing process through Safe’s interface
Submit message
Tally verifies the signed message
The user is now authenticated as their Safe wallet
Users can now:
Update their Tally profiles
Participate in governance by voting and/or delegating
Execute on-chain transactions
You can also sign in as Safe using WalletConnect from the Safe mobile app, following:
Mobile instructions (recommended)

Key features of Tally's token launch solutions
Launch just the token, pair it with staking from day one to incentivize long-term commitment, add governance to enable decentralized decision-making immediately, or progressively enable components later as your protocol matures.
Tally builds branded claim interfaces in close collaboration with your team to ensure brand alignment and user clarity. Custom domains maintain consistent branding across all token operations.
Tally deploys your protocol's governance smart contracts, including Governor and Timelock, ensure a smooth and convenient transition from token claim to active governance participation.
Launch with ERC20Votes
Tally deploys your token, a non-fungible, non-transferable token that can be minted and revoked by the Governor. The ERC20Votes extension ensures your governance token supports vote delegation and efficient tracking of voting power over time.
Deploy Governor and Timelock contracts
Launch tokens simultaneously across multiple EVM chains. Recipients claim on their preferred network without wrapped assets or bridging, eliminating friction and complexity from multichain distributions. Tally's cross chain claiming experience reduces operational overhead, improves user experience, and ensures token holders can participate from any supported chain without technical barriers.
Tally provides continued technical support, infrastructure monitoring, and feature development as your protocol grows.
Tally helps your team prepare for a clean launch:
Pre-launch links and interfaces
Educational and onboarding materials
Page scaffolding
Integration with specialized tooling and providers as needed
Ready to launch your token? .
Staking on Tally distributes protocol revenue or native issuance to token holders. It's the foundation for open, trust-minimized systems.
Optionally, the rewards can be incentives for particular actions. Rewards can depend on particular behavior, like validating the network, long-term holding or governance activity.
Tally staking offers:
Flexible staking infrastructure: Implement staking for your protocol’s specific needs.
Multiple reward sources: Distribute rewards from protocol revenue, treasury assets, token emissions, or all of the above.
Governance integration: Staking is compatible with governance, so that holders don’t have to choose between rewards and governance. Optionally, rewards can be conditional on active participation in governance.
Validator support: Pay stakers and operators to validate protocol security.
Tally's solution works for protocols at any stage. It supports new token launches and established projects. This guide covers both strategic direction and technical details.
Launch a new token with built-in utility, or enhance your existing tokenomics. Either way, Tally's solution provides the foundation for sustainable economic alignment.
Staking contracts distribute rewards over time
Rewards can come from anywhere. The most common sources are 1) protocol revenue and 2) issuance of the protocol's native token. The rewards can be in any ERC20 token or even in more than one token.
Tally's staking contracts distribute rewards among eligible staking users over time.
Tokenholders stake protocol tokens for a share of the rewards
ZKsync is using Tally's staking solution to create an economic feedback loop where active governance participation drives protocol growth and rewards flow back to contributors. The program will distribute 35 million ZK tokens across two seasons.
Program structure:
Season 1: 10M ZK rewards for 400M tokens staked
Season 2: 25M ZK rewards for 1B tokens staked
Participants earn up to 10% APR by staking ZK and delegating to active governance participants.
How it works:
Delegation-based rewards: Token holders must stake ZK and delegate to active participants to earn rewards. Active participants are delegates who voted in at least 2 of the last 5 governance proposals. This ties rewards directly to governance activity.
Continuous reward streaming: Rewards distribute continuously over 30-day epochs, preventing yield discontinuities and giving stakers time to respond to changing conditions.
Governance integration Staked tokens retain full voting power. Eligibility criteria ties rewards to governance activity, ensuring staking incentivizes active protocol participation.
Learn more about .
Ready to launch staking? .
Key features of Tally's incentive and staking solutions
Tally's staking system allows protocols to return protocol fees to token stakers. This creates direct economic alignment between protocol usage and token holder rewards.
How it works:
Protocol governance decides what percentage of fees to distribute to stakers
Fee distribution can be automated through smart contracts
Rewards can be paid in native tokens, ETH, stablecoins, or other assets
Unlike other staking systems that force users to choose between earning yield and participating in governance, Tally's solution supports both.
How it works:
Staked tokens can delegate their voting power
Optionally, rewards depend on the tokens being active in governance
Customer example: Obol implemented staking with governance integration, ensuring their stakers can earn rewards while still contributing to protocol governance decisions. Read the OBOL case study .
Tally's staking system integrates with tracking to measure and reward quality governance participation.
How it works:
Delegates receive scores from 0-100 based on voting participation, forum rationales, and discussion engagement
Scores update after each governance cycle to reflect current activity levels
Only delegates meeting minimum reputation thresholds (e.g., DRS ≥ 65) qualify for staking rewards
Token holders can view delegate scores and participation history to make informed delegation decisions
Customer example: uses DRS integration to gate delegate compensation, ensuring only active, engaged delegates receive staking rewards.
Enable token holders to earn rewards while keeping their tokens transferable and usable across DeFi.
Your community can stake, track rewards, and manage positions through one intuitive interface.
Tally's staking system is compatible with staking and restaking protocols that provide validated services.
How it works:
Native tokens can be used to secure actively validated services
Compatible with protocols like EigenLayer and Symbiotic
Aligns token holder incentives with network security
Staked tokens can serve as insurance against reorgs or losses.
How it works:
Native tokens are staked in a pool and accrue rewards
If something goes wrong, like a reorg or shortfall crash, staked tokens are slashed to cover the losses
Stake streaks reward long-term holders, creating incentives for extended token holding periods and reducing market volatility.
How it works:
Stakers' earning power increases over time
Rewards scale based on continuous staking duration
Encourages long-term protocol alignment, and reduces token velocity
Ready to launch incentives and staking? .
Governing protocols on multiple chains
Tally has partnered with Wormhole on MultiGov, which powers multichain governance for organizations.
Your organization, everywhere. MultiGov lets organizations meet token holders where they are. organization members can govern an on-chain organization from any chain. MultiGov supports organizations on Solana, Ethereum and EVM-compatible L2s. Multichain organizations will lower barriers to participation and reach users everywhere.
Until now, organizations operated their governance on a single chain.
On L1
Many of the oldest and largest organizations have their token, Governor and treasury all on Ethereum mainnet. Rising L1 gas costs make that setup increasingly expensive. MultiGov gives voters a way to lower gas costs.
On a single L2
Newer protocol organizations might launch on one network. Once they find product-market fit there, they often want to expand to other ones. MultiGov gives protocols a way to meet users where they are.
Save on gas costs
Govern protocol across chains
Meet community where they are
organization can follow the protocol to new networks
MultiGov organizations use a hub-and-spoke model. This model combines well-understood building blocks – governor, token bridges, and message-passing.
On the "hub" chain, the organization has a standard and with the . The hub can be any supported EVM chain. Tokenholders can choose bridge their hub governance tokens to spoke chains.
On each "spokes" of a MultiGov organization, there's a bridged gov token and a spoke Governor. The bridged gov token keeps track of voting power on that chain. When there is a proposal, the voters on that spoke chain vote on a spoke Governor. Votes on each spoke Governor can be aggregated and bridged back to the hub chain.
To learn more about how organizations can use MultiGov, watch Tally CTO Raf Solari’s ETH Denver 2024 talk on Multichain organizations
Wormhole, powered by $W token holders, will be the first to use this pioneering multichain governance system. Wormhole's organization will enable token holders on any supported chain to engage in the governance process. This approach to governance will enhance the user experience, making community contributions easier.
Interested in implementing MultiGov for your protocol? .
How to Use the Tally API
To get started, you'll need an API key. Sign in to Tally. On your User Settings Page, see the "Tally API" section. Generate an API key, and keep it somewhere safe.
You'll need to include that API key as an HTTP header with every request, i.e. {"Api-Key": "YOUR_KEY_HERE"}
To get started quickly, check out the . This simple React app uses Tally's API to list DAOs and their proposals.
The public API is documented on . The API is a graphql API lets you request exactly the data you need.
One big advantage of graphql is that it's self-documenting. Check out the . You'll need to add your API key in the "Request Headers" section, like this: {"Api-key": "YOUR_KEY_HERE"}
Note that the playground also includes undocumented endpoints. Using them is not recommended for production apps, because they are subject to change without notice.
Free Tally API keys are rate-limited to ~1 request per second. If you'd like to switch to the paid tier to increase your rate limit, reach out on the .
Learn how to propose deploying Uniswap v3 on a fresh EVM chain using Tally.
You can make a proposal on Tally to deploy Uniswap v3 on a fresh EVM chain.
The first step of launching Uniswap V3 on a fresh EVM chain is to deploy the smart contracts that comprise the protocol. To simplify this process, Uniswap Labs has devised deployment scripts and management CLI, ensuring a smooth rollout of the required contracts onto a new EVM chain.
Simply set up and fund a deployment account to cover the gas charges (estimating 40-50M gas). Then, execute a single command within the CLI. This will sequentially deploy each contract, marking checkpoints that can be rolled back if complications arise.
Make a proposal on Tally using Custom Actions.
Target contract address: 0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41 (the public ENS resolver address)
Contract method: setText
Calldatas:
Resources
of Uniswap v3 deployment on Celo
How to queue, execute, and cancel proposals
Besides creating and voting on proposals, users can also: queue, execute, and cancel.
Queuing, executing, and canceling proposals can all be accomplished directly from the .
Once voting ends, a proposal is not complete. If a proposal passes, additional steps are required before execution. A successful Governor proposal still needs to be queued—if the organization uses a Timelock—and then executed.
Once a proposal passes, you can queue and execute it from the same place you voted:
Queue prepares a proposal for execution. The queue action sends the proposal to the Timelock contract, which starts the countdown until the proposal can be executed.
Someone needs to call the queue() function because the EVM (Ethereum Virtual Machine) does not support scheduled or automatic calls. Every call must be kicked off by a user.
If a Governor does not have a Timelock, then proposals don’t need to be queued. They can be executed as soon as the proposal passes.
Generally, anyone can queue a proposal that has passed! The only exception is that some custom Governor contracts limit who can call queue().
This depends on the Timelock Delay of the Timelock contract. You can check that delay on Etherscan until Tally adds it to the .
Executing a proposal runs its function calls on-chain. Each proposal is associated with one or more function calls, which are visible in the Executable Code section of the . These calls can do things like transfer assets from the treasury, update parameters of the Governor itself, change or upgrade a DeFi protocol, or call another smart contract.
Generally, anyone can execute a proposal that has passed! The only exception is when a custom Governor contract limits who can call execute().
In some situations it is important to send ETH at the same time as executing a proposal (for example, when paying the Toll for sending a crosschain message to a bridge). In this case, it may be necessary to send ETH as part of the execution of the proposal.
To cancel a proposal, click the three-dot menu to access additional actions. You can also copy the proposal's URL and view contextual information.
It depends! There isn’t a standard version of cancel logic across Governor implementations. Governor Alpha, Governor Bravo and OpenZeppelin Governor each have different behavior.
OpenZeppelin Governor
OpenZeppelin Governor leaves the cancellation up to the developer implementing the contract. Many organizations implement a Canceller role that gives a list of addresses the power to cancel proposals.
Governor Alpha
If the proposer’s voting power drops below the voting threshold, anyone can cancel that proposal.
Governor Bravo
Same as Governor Alpha. Also, the proposer can always cancel their proposal.
Not if it’s the exact same one. To re-submit a proposal, create a new proposal with the same executable code.
For organizations that use the Governor contract, only delegated tokens can participate in voting. What does this mean for you, a token holder?
You must delegate your tokens to participate in voting. You may choose to delegate to others or to yourself.
If you wish to vote on proposals directly, delegate your voting power to your own address. Or, you can delegate your voting power to another community member and let them vote on your behalf. You can update your delegation at anytime.
Note: To vote on a proposal, votes must be delegated BEFORE the proposal is live. For security reasons, votes delegated during a proposal period cannot be used until the next proposal.
You can also delegate your voting power to a specific address directly on their .
Navigate to your by clicking your profile name at the top right and selecting Profile from the drop-down.
At any point, you have the complete freedom to re-delegate your tokens to a different address by following the same steps you initially used to delegate your tokens. This flexibility ensures that you can adapt to changing circumstances and align your delegation with your current preferences or strategies.
Additionally, you also have the option to undelegate your tokens, thereby reclaiming your voting power to participate directly in the decision-making process. This may be important if a vote you feel particularly strongly about comes up; you can take a more active role in the governance of the organization whenever you feel it is necessary or appropriate.
Remove barriers to organization governance participation with gasless transactions.
Every blockchain interaction - whether casting a vote, delegating voting power, or creating governance proposals - requires participants to pay transaction fees (commonly known as "gas fees") on the underlying blockchain network. These fees represent a significant barrier to participation, potentially excluding valuable contributors and skewing governance decisions toward those with greater financial resources.
Relay is a sponsorship system where organizations can cover the transaction costs for their members' governance activities like voting and delegating. organizations can now cover the costs that would otherwise prevent members from participating in crucial decisions.
The technical foundation of Relay rests on OpenZeppelin Defender, a trusted security framework in the blockchain world. When a organization enables Relay, they set aside a specific budget for governance transactions. As members participate in governance activities, Relay automatically handles the complex process of paying transaction fees, making the experience seamless for users - they can simply focus on making thoughtful governance decisions.
Tally maintains this service through a small fee on each transaction, ensuring the system remains sustainable while keeping costs manageable for organizations. This approach is similar to how payment processors charge small fees to maintain their infrastructure while providing valuable services.
Tally has processed hundreds of thousands of governance transactions, with associated gas fees reaching hundreds of thousands of dollars. These numbers represent not just costs, but potential barriers to participation. Each transaction fee could have been a reason for a valuable member to stay silent instead of contributing their perspective.
When organizations sponsor transactions through Relay, they're making a powerful statement about their values. They're saying that every voice matters, regardless of a member's ability or willingness to pay gas fees. This commitment to inclusivity strengthens the entire governance ecosystem in several ways:
Enhanced Participation Metrics: By eliminating financial barriers, organizations can expect increased engagement across their membership base, leading to more representative governance decisions.
Demographic Diversification: The removal of transaction cost barriers enables participation from a broader spectrum of community members, including those in regions where gas fees might represent a significant expense.
Governance Efficiency: With reduced friction in the voting and proposal processes, organizations can achieve quicker decision-making cycles while maintaining high participation rates.
For organizations interested in implementing gasless voting and delegation with Relay, Tally's team can be reached at to discuss specific needs and implementation details.
Stake tokens on Tally.
Staking is the easiest way to earn rewards and participate in governance. To learn more about why protocols are using Tally Staking to accrue value, visit Incentives & staking.
Token holders can now stake OBOL and RARI on Tally and earn rewards. To learn more, read the full announcements for stOBOL and stRARI.
How to Stake OBOLHow to Stake OBOLZKsync staking is coming soon. To stay up to date with ZK staking and learn more, read the full and , or follow & on X.
Wormhole's W token can be staked for potential future rewards. To stake your W tokens, visit the .
Ready to bring staking to your protocol? .
How to Stake OBOL on Tally
Staking for OBOL is live on Tally. stOBOL helps secure the OBOL network and allows token holders to earn rewards by participating in governance. Follow the steps below to stake OBOL directly from your wallet in just a few clicks.
On the homepage you can easily access staking earnings over time, available balance, past transactions, delegation status, and more.
Locate the staking portal on the bottom right of the staking homepage. Here you can also view and update delegation. (Note: delegation is required to stake OBOL and earn rewards)
In the staking portal, you can easily stake and unstake OBOL tokens. The portal will automatically populate available token balances, preview transaction cost, and prompt delegation when required.
Enter your desired token balance, press stake or unstake, and submit your transaction via wallet. Submitted transactions will automatically update staked and unstaked token balances.
If you need assistance with staking, submit a request to [email protected].
Tally now provides comprehensive support for wstOBOL (wrapped stOBOL), enabling OBOL governance participants to seamlessly manage their tokens across DeFi protocols while maintaining visibility of their total governance power.
As OBOL expands into Pendle, token holders need tools to:
Track balances across all OBOL token variants (OBOL, stOBOL, wstOBOL)
Easily convert between token types in one canonical place
Understand their total voting power regardless of token distribution
Make informed decisions about governance vs. DeFi participation
Access NatSpec documentation of all the functions in the contract source code & more on .
For detailed information about wstOBOL and how it works, see Obol's .
Set up Tally's staking system: prerequisites, reward sources, and considerations for successful deployment.
To implement Tally's staking system, you'll need the following:
Compatible tokens:
A standard ERC20 token to use as the staking token. Typically, the staking token is the native token of the protocol, like UNI.
One or more ERC20 tokens to distribute as rewards. e.g. WETH or the native token of the protocol for inflationary rewards.
Note: Rebasing tokens or non-standard ERC20 tokens won't work.
Reward source: Rewards come from protocol revenue, treasury funds, or minting new tokens.
Optionally, staking supports additional features:
Governance compatibility - for staking token that are also governance tokens. In other words, tokens that implement ERC20Votes. Staking passes through voting power to the underlying governance token. No changes are needed on the governance system.
Staking reward criteria can use an . Calculators increase or decrease rewards based on any criteria. Calculators can use offchain criteria with an oracle.
Many protocols launch staking with their token launch. Tally can help with a flow that combines the two events. Combining them offers several benefits:
Immediate utility for new tokens
Higher staking conversion rates
Reduced initial selling pressure
Clear value proposition for tokenholders
Learn more about how Tally helped Obol combine token launch with staking launch .
Your implementation approach depends on your protocol's stage and needs:
Implement staking alongside your token launch
Design with value accrual in mind from day one
Create an economic loop between usage, fees, and rewards
Add staking to create utility for existing tokens
Use protocol revenue or token inflation to reward stakers
Consider phasing in rewards over time to test and adjust parameters
For the fastest and most reliable implementation:
Contact Tally's team at
Tell Tally about your staking and reward tokens
Tally will guide you through the deployment process
Get a fully-configured staking user interface on Tally
To deploy a test or self-serve staking contract
See the
Get email notifications about organization proposals
Subscribe to Tally Notifications to get emails when there's a new proposal in a organization you follow. Tally supports the following types of notifications:
New proposal - receive an email when a new proposal begins.
Proposals ending soon - if you have not voted on a proposal, receive an email when it has 24 hours remaining before votes close
Notification on voting results - receive an email when a proposal ends with the final results
Click on your profile picture located at the top of the page. This will take you to the .
Type it into the modal.
We will send one-time verification code to the address you provided to ensure it is accurate. Check your email inbox for a message from us containing the OTP. It may take a moment to arrive.
Return to the Notifications Center and input the code you received.
Click confirm to complete the email verification process.
Navigate to the home page.
Search for the organization you want to receive email notifications from.
Press the purple subscribe button.
You will receive a notification that you have successfully subscribed to email notifications from the specific organization.
Navigate to the home page.
Search for the organization you want to unsubscribe from email notifications.
Press the unsubscribe button
You will receive a notification that you have successfully unsubscribed from email notifications from the specific organization.
Tally offers exclusive discounts to ecosystem partners
Tally drives growth for your chain, protocol, or ecosystem. We provide the following value to teams in your ecosystem:
infrastructure including:
Staking contracts
Revenue collection and distribution
Staking application layer
Launch and protocol operations advisory services
10% off and claim infrastructure products
10% off protocol operations and products
20% protocol products
Ready to partner with Tally? .
Tips for deploying and debugging the Staker system.
Insufficient reward balance:
Ensure reward tokens are transferred to the staking contract before notification
Check that the reward notifier has sufficient balance or approval
Oracle operations
If using an oracle-based calculator, tools like OpenZeppelin Defender can push earning power updates on-chain
The PauseGuardian should monitor the oracle’s updates and react quickly if the oracle goes offline or posts incorrect earning power
Earning power not updating:
Earning power doesn’t automatically update.
Anyone can run a bot to update earning power. There’s an economic incentive for MEV searchers to do updates, but they might not know about the incentive.
We recommend running the scripts in the repo as a backup, in case the MEV searchers don’t.
How often do rewards get distributed, and how is earning power recalculated?
The REWARD_INTERVAL is configurable when deploying a new reward source. When there’s a new reward, the staking system updates everyone’s reward schedules based on earning power. The rewards are distributed over a period of time, the REWARD_DURATION.
How does the system handle vote checkpoints/snapshots?
The underlying governance token handles snapshotting. Staker puts the governance tokens for each delegate into a separate account, called a “surrogate”. Then, it calls delegate() on the underlying governance token to distribute voting power. This way, the underlying governance system does not have to change.
How to Stake RARI on Tally
Staking for RARI is live on Tally. stRARI helps secure the RARI network and allows token holders to earn rewards by participating in governance. Follow the steps below to stake RARI directly from your wallet in just a few clicks.
Bridge to Arbitrum One .
Bridge to RARI Chain .
On the homepage you can easily access staking earnings over time, available balance, past transactions, delegation status, and more.
Locate the staking portal on the bottom right of the staking homepage. Here you can also view and update delegation. (Note: delegation is required to stake RARI and earn rewards)
In the staking portal, you can easily stake and unstake RARI tokens. The portal will automatically populate available token balances, preview transaction cost, and prompt delegation when required.
Enter your desired token balance, press stake or unstake, and submit your transaction via wallet. Submitted transactions will automatically update staked and unstaked token balances.
If you need assistance with staking, submit a request to [email protected].
Tally is currently compatible with the following chains:
Ethereum
Arbitrum One
Arbitrum Nova
Avalanche
Base
Blast
BNB Smart Chain
Corn
Filecoin
Flow Mainnet
Gnosis
HashKey Chain (coming soon)
HyperEVM
Kinto
Linea
Lisk
Moonbeam
Nova
Optimism
Polygon
Polygon zkEVM
RARI Chain
Rootstock Mainnet
Scroll
Soneium
Swellchain
Vana Mainnet
Viction
Zircuit
ZKsync Era
If you would like to integrate your chain with Tally email us at .
The following chains are deprecated and will no longer be supported in future releases:
Celo
Cyber
Darwinia
Gravity Alpha
Distribute tokens to millions of recipients
Distribute tokens to millions of recipients with gas-optimized claim processing.
Configure custom claim experiences tailored to your community and tokenomics. Set flexible eligibility criteria based on on-chain activity, snapshots, or allowlists. Deploy branded claim pages that scale from hundreds to millions of recipients across any EVM chain.
Tally's airdrop infrastructure uses Merkle tree-based claim processing to minimize gas costs while supporting large recipient lists.
Key capabilities:
Govern protocol upgrades and treasuries securely and efficiently
Deploy production-ready governance that scales with your protocol without requiring vendor migrations or custom integration work. As your governance matures, add advanced features like MultiGov, optimistic governance, or security council elections to meet the evolving needs of your community.
Protocols use Tally's governance solutions to enable decentralized decision-making, distribute funds, coordinate communities, streamline proposals, and ensure community oversight through transparent voting.
Take action in your organization by initiating an on-chain proposal on Tally.
To submit an on-chain proposal, you must have sufficient voting power to meet the organization's Proposal threshold. This figure can be found on each organization Page by expanding the Contract Parameters section near the top of the page.
Visit the of the organization you'd like to create a proposal for, then click the Create new proposal button at the top of the page.
In order to vote on a proposal, first make sure that you've and !
Note that tokens you own are not active for voting until you delegate. You must delegate to yourself if you wish to vote on proposals directly with your own tokens.
Select the active proposal that you'd like to vote on to navigate to its .
Add a organization to an existing ERC20 token or NFT
A Governor contract expects a particular interface from its token contract. requires a token contract that implements the or the .
If a token may someday be useful for running an on-chain organization, deploy it with a voting interface for future Governor compatibility. If the token is already deployed and it cannot be upgraded, the best workaround is to deploy a wrapper token contract that adds the voting interface to an existing token.
Integrate Tally's staking contract into a DeFi protocol
Tally staking lets holders earn rewards, participate in governance, and use their assets in DeFi. This guide outlines considerations for add the LST to a lending market, AMM, or restaking system.
See below for details about how a DeFi protocol can integrate the from the .
The LST is a standard ERC20 token with no "weird" features like rebasing. The integration will be similar to other ERC20 tokens.
Note: FixedGovLST uses a rebasing LST internally. Integrating against the underlying rebasing LST is not recommended!
Add a new or existing organization to Tally's interface.
Ready to add your organization's governance to Tally? All you need is a deployed and a few minutes to get started.
Select the Get Started button on the Tally homepage (or ), select Deploy myself, then select Deploy contracts yourself.
Enter your organization's info: its name, description, and Governor Contract details. Then select Add Governor. That's it!
In decentralized organizations, users can directly participate in governance.
User participation in governance helps create deeper alignment between protocol stakeholders. Some governance systems offer financial incentives for contributions such as voting, writing forum posts, or submitting proposals. Finally, decentralized governance offers the opportunity to pursue personal interests while having an outsize impact in a vibrant and growing ecosystem.
Both the base layer and application layer governance are crucial for the proper functioning and evolution of a blockchain network.
Governance is a critical aspect of any decentralized network as it ensures that the network can adapt, evolve, and operate efficiently without a central authority. The governance of a blockchain network can be broadly categorized into two layers: the Base Layer Governance and the Application Layer Governance.
The base layer refers to the blockchain consensus mechanism itself. This is the foundational layer of a blockchain network that includes the blockchain protocol, consensus algorithm, and the native cryptocurrency. The base layer governance involves decisions and changes related to the core protocol of the blockchain, such as changes in the consensus algorithm, block size, and transaction fees.
Manage your organization.
Decentralized governance applies traditional governance concepts in a way that allows for direct input from users.
Decentralized governance refers to frameworks for managing collective action and common resources outside of the existing legal system.
Economic activity has traditionally been organized via companies - legal entities capable of entering into agreements and controlling property. These common agreements and assets are managed via a system of corporate governance; executive officers control day to day operations while answering to the board of directors, who in turn report to shareholders. Any disputes are escalated to the traditional court system.
The rules of decentralized organizations are primarily enforced by code, rather than the legal system. This gives decentralized systems greater predictability as changing laws or governments don't impact the organization. But it also requires greater care in designing governance mechanisms, as token holders can't rely on the courts to address minority shareholder protections or other needs.
Standards for interacting with on-chain Governor Proposals
Governor organizations are smart contract accounts, which means they have the capability to make any on-chain call that a wallet or externally-owned account can. This flexibility is crucial for the integration of third-party applications with the Governor. This section will provide a detailed guide on how to integrate third-party apps with the Governor, ensuring seamless interaction and functionality.
Understand the Governor Contract: Before integrating a third-party app, it is essential to have a thorough understanding of the Governor contract, its functions, and its capabilities. The Governor contract is responsible for creating and managing proposals, as well as executing approved proposals.
Include ERC20Votes to future-proof a token for on-chain governance
If you are deploying a token that might govern a organization in the future, include voting methods. It's easy and safe to add them up front. It's much harder to upgrade or wrap the token to add them later.
Deploy your token with . That means providing voting methods, getVotes and getPastVotes. Governors can call those voting methods when counting votes on proposals.
Ever since , Governor proposals have had an on-chain, human-readable `description` field. Governor frontends like Tally, Compound and others follow this de-facto standard:
Proposal descriptions should be markdown text.
The first line of the description, regardless of format, is the title.
Everything after the first newline is the body of the proposal. Frontends should render it as markdown.
Tokenomics: The economic model of a token, including its supply, distribution, utility, and incentive mechanisms.
Rewards: Tokens or other assets distributed to participants for contributing to the network, such as through staking.
Yield: The rate of return earned on staked tokens, typically expressed as an annual percentage.
Earning power: A metric that determines a staker's proportional claim on rewards, which may be equal to or modified from their staked amount.
Earning power calculator: A component that determines how rewards are distributed to stakers based on various criteria.
Reward notifier: A contract that informs the staking system about new rewards and triggers their distribution.
Delegation surrogate: A contract that holds staked tokens and delegates their voting power to a specified address.
Reward stream: The mechanism by which rewards are distributed gradually over time rather than all at once.
Reward duration: The time period over which rewards are distributed (default 30 days in the Tally system).
Delegation: Assigning voting power to a specific address without transferring token ownership.
Delegatee: The address that receives voting power through delegation.
Governance Token: A token that grants voting rights in a protocol's governance system.
Governance Staking: Staking that preserves governance voting rights while earning rewards.
Auto-Delegation: A system that automatically delegates voting power according to configurable rules.
Liquid Staking Token (LST): A token representing a staked position that can be transferred or used in DeFi while the underlying tokens remain staked.
stGOV: Tally's liquid staking token implementation for governance tokens.
Rebasing LST: A liquid staking token whose balance automatically increases as rewards accrue.
Fixed LST: A liquid staking token with a fixed balance where the token-to-underlying exchange rate changes as rewards accrue.
Withdraw Gate: A contract that enforces a configurable delay when unstaking to prevent reward gaming.
Reward Source: The origin of rewards distributed to stakers (e.g., protocol fees, treasury, or token emissions).
Protocol Revenue: Fees generated by a protocol's operations that can be distributed to stakers.
Stake Streak: A mechanism that increases rewards based on how long a user has been staking continuously.
Bump: The process of updating a deposit's earning power, which may be incentivized with a small reward.
Reward Rate: The speed at which rewards are distributed per unit of time.
Oracle-Based Earning Power: A system where external data feeds influence staking rewards, such as delegatee activity scores.
Overwhelming Support Auto-Delegate: A delegation strategy that only votes on proposals with significant consensus.
Dual Staking: The ability to use staked tokens for multiple purposes simultaneously, such as with EigenLayer.
Restaking: Using already-staked tokens to secure additional protocols or services.
ERC20: The standard interface for fungible tokens on Ethereum.
ERC20Votes: An extension to ERC20 that supports vote delegation.
EIP-2612: A standard allowing gasless approvals using signed messages.
Permit: A function that processes signed approvals without requiring separate transactions.
OnBehalf: Methods that allow actions to be performed on behalf of users via signatures.
Ready to launch incentives and staking? Talk to our team to get started.
While the decentralized governance space is full of opportunities to contribute, as a new user it can be tough to know where to start.
The Education section of this Gitbook is a great entry point, offering general information about governance mechanisms and prominent decentralized protocols.
As you find projects and communities that interest you, the next step towards valuable participation is learning more about their systems and governance processes:
Read the protocol documentation and blog
Try using the system yourself
Visit the community's forum to see current discussions and proposals
Ask questions in the community chat, usually on Discord
Once you have a good understanding of how things work, you'll be able to follow each community's particular norms and procedures for contributing and making governance changes.
The consensus mechanism is a set of rules and processes that nodes in a blockchain network must follow to agree on the current state of the blockchain. Different blockchain networks use different consensus mechanisms, such as Proof of Work (PoW), Proof of Stake (PoS), or Delegated Proof of Stake (DPoS).
Protocol changes refer to any modifications made to the underlying code of the blockchain. These changes can include bug fixes, improvements, or new features. Protocol changes often require a majority of nodes to agree and implement the changes, which may result in a hard fork or a soft fork.
The application layer consists of all of the various decentralized apps (dApps) built atop the underlying blockchain. Examples of application layer governance systems include Decentralized Finance (DeFi) protocols and general-purpose decentralized autonomous organizations (DAOs). The application layer governance involves decisions and changes related to the dApps and smart contracts built on the blockchain.
DeFi protocols are financial services, such as lending, borrowing, or asset trading, that are built on blockchain technology. The governance of DeFi protocols often involves decisions related to the parameters of the protocol, such as interest rates, collateral requirements, and fee structures.
DAOs are organizations represented by rules encoded as a computer program that is transparent, controlled by organization members and not influenced by a central government. DAOs aim to codify the rules and decision-making processes of an organization, eliminating the need for documents and people in formalized roles.
Decentralized governance often involves more direct voting as compared to companies; token holders can vote on executive actions and parameter changes instead of delegating their power to a board of directors and executive officers. This empowers participants, but can also lead to voter apathy and less organizational agility due to the sheer volume of issues to review.
Decentralized governance vests power directly with token holders, removing exeuctive teams that could become targets of censorship, manipulation, or bribery. Relying on code for executing agreements also reduces reliance on external legal systems.
Discussion venues are typically open to all, giving token holders, protocol users, and the broader community an opportunity to share their thoughts. And some protocols distribute governance rights to their users as an incentive, which can further align interests over time.
Flexible Voting: Tally's flexible voting setup prepares protocols for advanced governance structures. Flexible voting enables sophisticated governance models like MultiGov and partial delegation.
Claim & delegate
To ensure a smooth and convenient transition from token claim to active governance participation, Tally provides a post-claim delegation experience to enhance user engagement and simplify the delegation process.
Launch with expert guidance
Tally provides detailed guidance on setting key parameters to ensure smooth and effective operation of the protocol's governance system: Proposal Threshold, Quorum Requirement, Voting Period, Voting Delay, Execution Delay, and more.
Tokenholders stake the staking token: the protocol's native token. Then, they earn a share of the rewards proportional to their share of all staked tokens over time. They can stake, claim rewards, and unstake at any time.
Staking supports governance. If the staking token is also a governance token, holders can use their staked tokens in governance. That way, tokenholders don't have to choose between governance and receiving rewards.
Optionally, the staking system can have eligibility criteria stipulate particular actions from tokenholders to get rewards. For example, it could require that staked tokens be active in governance to earn rewards. There's a large design space for incentivizing token-aligned services.
Liquid staking tokens (LSTs)
IOTA EVM
Kroma
Mantle
Mode
PulseChain
ShimmerEVM Mainnet
X Layer
Deploy an OpenZeppelin token contract that includes both ERC20Wrapper and ERC20Votes. Then, point the Governor wrapper contract instead of the token contract.
For more information, see this post from the Tally blog that walks through the process of deploying a Governor for an existing token.
A token wrapper does come with tradeoffs. Users will have to wrap their tokens to vote, and then unwrap them to use them in places that expect the unwrapped version. They may also be confused about where their token went after wrapping if their wallet doesn’t know about the wrapped version.
One thing to note is that setting up voting already requires setup: token holders have to delegate their votes – even to themselves – before voting. The wrapping step could be combined with delegation to keep the process simpler for tokenholders.
The `ERC20Votes`/`ERC721Votes` logic on the token contract is responsible for voting power bookkeeping that can’t be done on another contract. That bookkeeping involves several things: updating voting power when there’s a delegation or transfer, taking a snapshot of the voting power at the start of each proposal, and emitting event logs for indexers whenever there’s a change in delegation or voting power.
Each `transfer()` and `delegate()` call updates the counts of voting power, so that it’s computationally cheap to save a voting power snapshot for a proposal. Governor needs a voting power snapshot to prevent double-voting. It would be too computationally expensive for an external contract like Governor to keep track of which tokens have already voted without a snapshot, because an attacker could move around tokens to vote multiple times with the same token.
Open Zeppelin's ERC20Votes extension is safe and self-contained. It has been audited and is currently deployed in thousands of token contracts.
The main tradeoff is gas usage. Fortunately, users can make that decision themselves.
Users can choose to activate their voting power by calling delegate. When an account is delegated, transfers will also update voting power. That update uses extra gas. Users who do a lot of transfers can always un-delegate their tokens to save gas by delegating to the zero address.
If a proposal description doesn’t follow this standard, Tally’s frontend will make a best-effort to render it, but it might not appear as intended.
key: network key of chain you're deploying to
value: address of v3 factory on that network
Chainlist for ChainIDs






Adjust organization settings, including logo, description, and links.
All Admin abilities.
Appoint additional Admins and Superadmins.
No Admin in your organization? Reach out to the Tally team.



Delegation: Enable token holders to delegate voting power to trusted representatives without transferring token ownership. Supports full delegation, partial delegation across multiple delegates, and integrations with staking and token launch.
Security council elections: Establish democratic elections for security councils that safeguard protocol interests. Tally's custom-built council elections ensure the highest standards of integrity in selecting leadership.
Optimstic governance: Streamline decision-making by assuming proposals pass unless explicitly vetoed by delegates, enabling faster execution while maintaining community oversight for critical decisions.
Delegate compensation: Reward active governance participants for their time, expertise, and contributions. Systems ensure only engaged and accountable delegates are rewarded through minimum reputation scores or participation thresholds.
Multichain support: Enable cross-chain governance with MultiGov to meet token holders where they are. Organization members can govern from any chain, with support for Solana, Ethereum, and EVM-compatible L2s.
Gasless voting and delegation: Remove financial barriers to governance participation by eliminating gas fees for voting and delegation. Organizations cover transaction costs for members' governance activities.
Ready to launch governance? Talk to our team to get started.
How many votes are needed for quorum
What options people have when casting a vote and how those votes are counted
What type of token should be used to vote
You can write your own module or choose one from OpenZeppelin contracts.
These parameters must be set for the Governor contract:
votingDelay: how long after a proposal is created that voting power is fixed (a larger delay gives users time to unstake tokens)
votingPeriod: how long a proposal remains open to vote
A proposal threshold can also be set, which restricts proposal creation to accounts with enough voting power.
The OpenZeppelin Contracts documentation includes guides and a detailed API reference for learning about developing secure smart contract systems.
You may also find the OpenZeppelin wizard useful for configuring a smart contract.
Check out our guide to ensure your OpenZeppelin Governor is compatible with the Tally platform:
Tally offers an all-in-one guide explaining how to use Governor in the PDF below.


Identify the functions of the third-party app that need to be integrated with Governor. These functions could include creating proposals, voting on proposals, or executing approved proposals.
Develop an interface that will allow the third-party app to interact with the Governor contract. This interface should include functions that allow the app to create proposals, vote on proposals, and execute approved proposals.
Rigorously test the integration in a safe environment, such as a testnet. This will ensure that it works as expected and does not have any security vulnerabilities.
Deploy.
Security: Ensure that the integration does not introduce any security vulnerabilities and that all interactions with the Governor contract are secure.
Gas Efficiency: Ensure that the integration is optimized for gas usage to minimize costs.
Compatibility: Ensure that the integration is compatible with the existing functions and capabilities of the Governor contract
Upgradability: Design the integration in such a way that it can be easily upgraded in the future to accommodate changes in the Governor contract or the third-party app.
The LST contracts has been audited twice, in both a private audit and a public contest.
The underlying direct staking system , Staker, has also been audited twice, with both a private audit and a public contest.
Staker is built on UniStaker. Unistaker's three audit reports are available here.
Price oracle integration
If the LST does not have a native price oracle, the price can be inferred from the price of the underlying staked token's price.
The fixed-balance LST is built on top of a rebasing LST. The rebasing LSTs can be unstaked 1:1 for the underlying staked token. Here's how to pull the underlying staked token balance in Solidity:
Note: If the LST has a withdrawal delay, there is a potential duration mismatch between the LST and staked token. It's not safe to infer the price from the underlying token in that case, because the LST's and staked token's prices could diverge.
Liquidity considerations
The LST is transferrable, so it will have its own liquidity. The underlying staked token also has liquidity. Because the LST can be unstaked for the underlying token, risk analysts should also consider the liquidity of the underlying token.
Programatic liquidations should consider the liquidity of both assets and whether there is a withdrawal delay.
LST Governance
The LST and the underlying Staker contract both have limited admin roles.
In general, the admins cannot take staked assets or accrued rewards. They can change the reward schedule, the rules for reward eligibility, and turn on the fee switch.
Slashing Risk
The default version of the staking system does not have any slashing features.
Upgradeability
The staking contracts are designed to be immutable. However, like any smart contract, staking can be deployed as an upgradeable proxy.
If they're deployed that way, DeFi integrators should understand the upgrade path for the system.
function getUnderlyingBalance(address user) external view returns (uint256) {
// Get the fixed LST token balance of the user
uint256 fixedTokenBalance = fixedLstContract.balanceOf(user);
// If the account has no balance, return 0
if (fixedTokenBalance == 0) return 0;
// The share scale factor is public on the FixedGovLst contract
uint256 shareScaleFactor = fixedLstContract.SHARE_SCALE_FACTOR();
// Convert the fixed LST tokens to shares by multiplying by the scale factor
uint256 userShares = fixedTokenBalance * shareScaleFactor;
// Use the rebasing LST contract's stakeForShares function
uint256 underlyingBalance = governanceLstContract.stakeForShares(userShares);
return underlyingBalance;
}Multi-chain support: Deploy airdrops across any EVM-compatible chain
Flexible eligibility criteria: Configure claims based on on-chain activity, snapshot data, or custom allowlists
Branded claim experiences: Custom interfaces that match your protocol's design
Gas-optimized claiming: Merkle proofs minimize transaction costs for claimants
Scalable infrastructure: Handle distributions from hundreds to millions of recipients
Native multi-chain claims: Enable users to claim tokens across multiple networks in a single flow
Hyperlane partnered with Tally to execute the HYPER token launch with native claim support across five blockchain networks. The launch distributed tokens to over 235,000 addresses who claimed nearly 70 million HYPER tokens.
Results:
235,000+ eligible addresses across 5 chains
~70 million HYPER tokens claimed
Native multi-chain claim experience
Gas-optimized claiming process
How it worked:
Tally designed eligibility criteria based on Hyperlane's community snapshot
Custom branded claim page integrated with Hyperlane's visual identity
Merkle tree implementation enabled gas-efficient claims across multiple chains
Users could claim tokens natively on Arbitrum, Ethereum, Optimism, Base, or Polygon
Real-time dashboard provided distribution analytics throughout the claim window
Merkle tree optimization: Tally's airdrops use Merkle tree data structures to store recipient eligibility off-chain while enabling on-chain verification.
Multichain architecture: Deploy the same airdrop across multiple EVM chains with consistent claiming logic. Recipients can claim on their preferred network without complex bridging or wrapped token mechanics.
Claim window controls: Set custom start and end dates for claim periods, with optional extensions and emergency pause functionality.
: Combine airdrops with vesting schedules to distribute tokens over time while maintaining a seamless claiming experience.
Ready to airdrop? Talk to our team to get started.
If you haven't yet connected your wallet, Tally will prompt you to do so. Most governance frameworks require a proposal threshold - a minimum amount of voting power - to create a proposal. Make sure you connect with the tokens required to create a proposal in it. Then click Continue.
Enter a Title for your proposal, then add a Description. Explain the intent behind the proposal and include any helpful context for the voters.
Add actions to be executed if the proposal passes. You can select Tally's Transfer Tokens recipe for a proposal that calls for the transfer of tokens, or select the Custom Action button.
Note: Governor Alpha/Bravo has a limit of 10 actions. There is no limit for OpenZeppelin Governor.
If you choose the Transfer tokens recipe, enter the Target wallet address, select the Token you would like to transfer, and enter the Value of the token you would like to transfer. Enter a Memo to describe the purpose of the transfer, and optionally, upload a Media image such as an invoice. Tally will populate an infographic as a preview of the recipe.
For a Custom action, enter the Target contract address or upload your ABI file if the contract is not on Etherscan. Select the desired Contract method, and enter the call data for that method.
Actionless Proposals: If you choose to skip this step, and create a proposal with no actions, a transfer of 0 ETH to you (the proposer) will be added, as Governor requires one executable action for the proposal to be submitted on-chain.
Preview your proposal, then select Save draft or Publish. If you're ready to submit the proposal on-chain, you'll also need to sign the transaction to the chain using your wallet. Draft proposals are created offchain and can later be submitted on-chain at any time. Draft proposals can be created and submitted by different users.
Having successful validations will give proposers, voters, and executors confidence that the proposal is valid. The Proposal Simulations feature is currently in beta and runs via the Tenderly Simulator API. Tally simulates the execution of the proposal assuming it is successful and queued on a fork of your organization's network. From there, Tally runs each executable payload, impersonating the treasury (usually the timelock).
When creating a proposal on Tally, the API will automatically run a simulation for the executable payload provided. You can view the result of this simulation in the Executable code tab of the proposal details. Each function will have its own result.
If one function fails, it is likely that the proposal execution will fail. If the function failed, click View raw result to inspect the response from the Tenderly Simulator API for additional insights. If the function fails or in cases when state changes may impact the success of a function, you may also want to re-run the simulation of the proposal.
For example, an organization proposes to transfer 1 ETH to an address, but their treasury has 0 ETH. As you might expect, the simulation result fails. From there, the organization funds their treasury with 2 ETH; click Re-run to re-simulate the proposal. You should now expect a successful proposal!
Click on the Vote button in the upper right corner of the page.
In the Voting pop up, choose your vote— For, Against, or Abstain. (Note that Abstain isn't an option in all DAOs, depending on their contract setup.) If you'd like, add a comment to explain the reason for your vote to the rest of your DAO. Once you're done, click Submit.
Confirm and sign the transaction via your connected wallet (example below shows MetaMask confirmation).
For DAOs that use the Governor contract, only delegated tokens can participate in voting. If you want to vote on proposals directly, you need to delegate your voting power to your own address. Check out our Delegate Your Voting Power doc for a step-by-step guide!
Tally may still be indexing the vote—check back in a bit!
Still not seeing what you'd expect? Join our Discord and open a ticket in #support.














Decentralize multi-sig control of your organization.
Council elections are a pivotal aspect of decentralized governance, ensuring that the guardianship of a organization remains in the hands of its community. Elections serve as a testament to the democratic ethos of organizations, allowing stakeholders to have a say in selecting the individuals who will be at the forefront of safeguarding their interests.
Through a transparent and structured process, they aim to identify and empower those with the expertise, vision, and commitment to navigate the challenges that may arise, all while upholding the principles and objectives of the organization. It's not just about choosing leaders; it's about reinforcing trust, fostering accountability, and ensuring that the organization's security apparatus remains robust and responsive.
With Tally's custom-built council elections, elevate your organization's council elections to the highest standards of excellence and integrity.
In the rapidly evolving world of organizations, a council serves as a mechanism for stability and security. It consists of designated members with the authority to make necessary changes to the protocol during emergencies. The council's role is not only to govern but also to address potential threats, ensuring the organization's security and adaptability.
A council is comprised of a certain number of members who are entrusted with the responsibility of making urgent modifications to the protocol during emergencies. Their roles are usually outlined as follows:
Emergency Actions: Addressing critical situations that demand immediate attention, such as potential risks to users' funds. To execute emergency actions, a consensus of a certain number of members is required.
Routine Operations: Apart from emergencies, the council also supervises routine software updates, maintenance, and parameter adjustments, which are considered as "Non-Emergency Actions".
To ensure accountability and infusion of fresh perspectives, the members of the Security Council are elected democratically on a semi-annual basis. Tally can customize all aspects of the election process. Typically, it is structured as follows:
Nomination: Initially, contenders register to become nominees, requiring a certain percentage of votes.
Compliance Period: A period for the foundation to vet the nominees.
Election Period: A period where delegates vote for the nominees, with the voting weight decreasing linearly over the last two weeks.
A Security Council operates within a framework that emphasizes security by design, incorporating the following elements:
Constrained Access: Access to the Upgrade Executor, a core component of the governance system, is strictly limited to prevent unauthorized or malicious activities.
Reuse of Existing Architecture: Leveraging existing secure infrastructure to avoid the introduction of new contracts that would require additional security measures.
Adherence to Specifications: The implementation strictly adheres to the guidelines outlined in the organization's official documentation, ensuring the intended security properties are met.
As a stakeholder in aorganization, the establishment of a Security Council—and an efficiently run election—should matter to you for several reasons:
Security and Integrity: A council acts as a safeguard, protecting the system and its users from potential threats and vulnerabilities.
Adaptability: It ensures that the organizationremains versatile and capable of adapting to changing circumstances without compromising its foundational principles.
Democratic Governance: Elections at regular intervals foster a democratic environment, allowing for the inclusion of new skills and perspectives, and preventing the entrenchment of power.
Ready to run an election? .
Liquid democracy, where each token represents one vote, is an ideal governance model in theory. But many organizations face challenges such as voter apathy, lack of technical knowledge, and an overwhelming volume of complex proposals. These barriers can significantly reduce the effectiveness and speed of decision-making.
Optimistic governance offers a solution to these challenges by assuming that most proposals are approved, unless explicitly veto-ed by delegates otherwise. In this model, the decision-making process is streamlined, with a clear mechanism for delegates or community members to intervene if necessary. This is particularly useful for proposals related to maintenance upgrades, technical changes, or parameter adjustments, which may not require extensive community deliberation, but still need oversight and the ability to veto in the edge case that the proposed changes are malicious.
To implement optimistic governance, Tally proposes a structured process designed to balance efficiency with accountability. The process involves several key steps:
Proposal submission
Proposals are submitted by the proposer using a standardized template
A proposal draft is shared with the community to gather initial feedback and ensure transparency
Due diligence
Scope limitation: This process should typically only be reserved for maintenance-related or technical proposals that require timely decisions but do not necessitate lengthy discussions
Council composition: The council is composed of a diverse set of members, balancing technical expertise with community representation. This ensures both competent oversight and broad representation in decision-making
Conflict of interest disclosures: Council members are required to disclose any conflicts of interest that may affect their voting on proposals
Both Governors could implement a "Super Quorum."
Once a majority votes in favor, the voting ends. The Governor can send the proposal or veto to the timelock immediately
The Optimistic Governor has the ‘PROPOSER_ROLE’ role on the timelock
The Veto Governor has the ‘CANCELLER_ROLE’ role on the Timelock. The veto Governor's voting period must be shorter than the timelock delay, so that it can cancel proposals in time
Optimistic governance provides an efficient way to manage routine and technical proposals, enabling a more agile decision-making process while ensuring that the organization retains oversight and accountability.
This approach helps prevent decision-making gridlock while fostering community participation and informed decision-making. If you're interested in implementing Optimistic governance,? .
Learn how to propose token vesting plans with Hedgey on Tally.
Using Hedgey, you can make a proposal for ERC-20 token vesting plans. Token vesting plans allow on-chain teams to issue vesting token plans to members, mirroring traditional vesting with features like cliffs, flexible schedules, and backdated start dates. It's fully on-chain, revocable, and customized for on-chain teams' needs.
Key features include linear/periodic unlock strategies, on-chain governance voting, customizable dates, governance rights to vesting tokens, admin features for transferring vesting plans, delegation of vesting plans to multiple addresses, and beneficiaries' ability to claim tokens at their discretion. The contracts are fully on-chain, ensuring interaction even without Hedgey UIs.
You can create vesting plans one at a time or multiple in the same transaction. You need to add 2 custom actions to a proposal.
The first custom action is to approve the allowance for the Hedgey contract to spend the tokens to create vesting plans.
Target contract address: the address of your organization governance token, or whatever token you are planning to use for vesting
Contract method: approve
Then, input the parameters as follows:
Locker: 0x1bb64AF7FE05fc69c740609267d2AbE3e119Ef82 (address of the vesting plans contract)
Token: address of your DAO token
totalAmount: the total amount of tokens to be distributed to vesting recipients
Note all of the plans batched need to have the same period and vesting admin.
Consider the following example:
If you have a specified total amount of tokens, for example 100,000, that you are distributing with a 2-year vesting term, the calculation for streaming would be different than for monthly payments.
For streaming: The vesting term spans 63,072,000 seconds, as there are 31,536,000 seconds in a year. Assuming your token has 18 decimals, you would calculate the rate of token distribution per second as follows: (100,000 * (10^18)) / 63,072,000 = 1,585,489,599,188,230. If your token has a different number of decimals, replace 18 with the appropriate number in the formula.
For monthly payments: Over a 2-year vesting term, there are 24 discrete periods (months). The calculation for the rate of token distribution per month would be: (100,000 / 24) * (10^18) = 4,167 * (10^18). This implies that 4,167 tokens will vest each month. However, in the last month, only 4,159 tokens will vest to complete the total distribution of 100,000 tokens.
Guide to auto-delegates in stGOV
When users stake governance tokens with the LST, they can actively delegate their voting power to specific delegates. However, in situations where tokens are held in DeFi protocols, cold storage, or centralized exchanges, direct delegation becomes challenging. This is where auto-delegates come in.
Auto-delegates provide a backup mechanism for governance participation when stGOV tokens are not actively delegated by their holders. They ensure that governance power doesn't become "stranded" and maintains active participation in the protocol's governance.
Auto-delegates solve several critical problems:
Preventing Governance Power Loss: Without auto-delegates, voting power from stGOV tokens held in DeFi or exchanges would be effectively lost to governance.
Maintaining Quorum: Auto-delegates help ensure sufficient voting participation to reach quorum for important proposals.
Protecting Against Capture: A well-designed auto-delegate strategy prevents governance capture when a large portion of tokens are inactive.
Reflecting Community Consensus: Auto-delegates can be configured to vote according to established community values and preferences.
Any version of a liquid staking token that tries to force users to update their delegate punitively, by withholding rewards, is likely to be beaten in the market by a version that doesn't do this. And that version is very likely to be less organization aligned than this LST's strategy of moving voting weight to the AutoDelegate.
In out view, the best option is to allow disengaged token holders to earn the same yield, but make sure their voting weight stayed active in a way that is under the organization's control. This approach is much better than trying to punish them, and allowing a more pathological set of incentives to play out. Ultimately, the AutoDelegate's is under the control of the active delegates and those that pick them.
The simplest approach is to not use an auto-delegate at all, effectively sending the voting power to a "burn" address.
Characteristics:
Voting power from non-delegated tokens is completely removed from governance
Simplest implementation with no additional code or maintenance
Reduces total active voting power, potentially making quorum easier to achieve
May lead to governance power concentration among active delegators
Best for:
Protocols prioritizing active participation only
Situations where you want to penalize inactive token holders
Communities with high active governance participation already
This option, implemented in , only votes on proposals that have strong support, but haven't yet reached quorum.
Characteristics:
Only votes when proposals have reached a configurable threshold of support
Helps high-consensus proposals cross the finish line
Won't vote on controversial proposals, i.e. those with mixed support.
Key Parameters:
subQuorumBips: The percentage of the quorum that proposals must have already achieved from FOR votes
supportThreshold: The required ratio of FOR votes to (FOR + AGAINST) votes
votingWindow: The timeframe before a proposal's deadline when the auto-delegate can vote
Best for:
Governance systems seeking to maintain quorum while respecting community consensus
Protocols wanting to avoid governance deadlock on broadly supported proposals
Communities with lower active participation rates
Protocols can create custom auto-delegates tailored to their specific governance needs and philosophy.
Potential Custom Implementations:
Delegate Council Auto-Delegate: Follows voting decisions made by a trusted council or experts
Meta-Governance Auto-Delegate: Votes based on a meta-governance system
If you'd like help building a custom delegate, . We'd love to help.
Keep your organization's details on Tally up-to-date.
To access the organization Settings page, click the Settings button in the header of your .
From the Basics tab of organization Settings, you can update all of your organization's information, including its logo, name, description, and links. You can also include Contact Information for your organization.
From the Admins tab, view your organization's . If you have the Superadmin role, you can also add these roles for other wallet addresses.
From the Safes tab, you can create or link a Gnosis Safe:
Effective governance hinges on motivated, informed delegates. Yet in most mature organizations, fewer than 10 % of token holders take the time to read, debate, and vote.
A transparent Delegate Reputation Score (DRS) turns that silent majority into a strategic resource by rewarding the behavior every protocol needs: participating in proposal commentary, adding context, and voting with responsibility and accountability. organizations like Arbitrum and Obol are already utilizing DRS for delegate compensation mechanisms to reward quality governance participation.
How to operate staking contracts
To deploy a staking contract, you'll need to decide the following parameters:
stakeToken - The ERC20 token which users will stake to earn rewards.
The Reward token can be the same or different from the Staker token. If there are rewards denominated in more than one token, other token can be automatically swapped for the reward token before they're distributed
How to make an ERC-20 or ERC-721 token contract that will work with on-chain governance.
Tally expects tokens to implement the relevant standard, like or . Also, Tally needs the token contract to implement the for delegation and voting power checkpointing.
Specifically, Tally needs the following methods and event signatures for indexing and web3 calls:
Tally's API listens to event logs from token contracts when indexing them. Your token contract will need to maintain the same event signatures:
On-chain voting is trustless; offchain voting is not.
On-chain voting refers to governance systems where individual votes are submitted as transactions, and recorded directly on the blockchain. Submitting on-chain requires users to pay a transaction fee for each vote.
Smart contracts can be designed to execute proposals automatically based on the outcome of on-chain votes, removing the need for a trusted third party or core team to enact vote results. Examples of on-chain voting systems include MakerDAO, Aave, and protocols built on Compound's governance framework.
First, let's get down the basics.
The section assumes users have a general understanding of cryptocurrency, along with some familiarity with the Ethereum ecosystem in particular (most governance protocols currently exist on Ethereum).
If you find that you're still a little unclear, check out the external resources below.
Create Sub-organizations and manage Grants Programs using the Zodiac Governor module.
Zodiac is a collection of tools built according to an open standard by the team behind Gnosis Safe. The Zodiac open standard enables organizations to act more like constellations, connecting protocols, platforms, and chains, no longer confined to monolithic designs. To learn more about the ideas behind Zodiac, visit the or read the .
rewardToken - The ERC20 token in which rewards will be denominated.Typically, this token is the native token of a protocol or a wrapped version of it.
admin - The address which will have permission to manage the staking system
The admin can take a limited set of admin actions, such as adding new sources of rewards, changing the earning power calculator and overriding eligibility for a particular address.
earningPowerCalculator - The contract that will calculate earning power for the staking system.
The simplest earning power calculator is the IdentityEarningPowerCalculator, which distributes rewards proportional to stake over time. More complex calculators can use arbitrary criteria to distribute rewards however they want.
One or more rewardNotifiers - Account(s) that can push rewards into the staking system by notifying the staking contract of a new reward emission.
Pushing rewards into the system is permissioned. Malicious accounts can grief by pushing dust rewards into the system, so rewardNotifiers should ideally be audited smart contracts or trusted accounts that always call transfer() and notify() atomically.
MAX_CLAIM_FEE - The max claim fee that the admin can set.
This guardrail keeps the admin from being setting an unreasonably high claim fee. It should be set to a number greater than zero, if the staking contract might ever use a non-trivial earning power calculator.
maxBumpTip - The max that a searcher bot can earn from updating an account's earning power.
The admin can update the tip.
claimFeeAmount - The fee that a user must pay to claim their reward.
When using a non-identity earning power oracle, set a non-zero claimFee to prevent a minor exploit where users split up their stakes into tiny ineligible deposits to avoid being bumped down.
feeCollectorAddress - The address that collects the claimFee, if any.
Reward Notifiers are responsible for distributing rewards to the staking system. The admin of Staker can add and remove them.
There are currently three kinds of reward notifiers:
TransferFromRewardNotifier - is approved to call transferFrom to move tokens
TransferRewardNotifier - holds a balance of reward tokens in the notifier. Distributes them over time.
MintRewardNotifier - mints new reward tokens directly from the token contract
In most cases, someone must periodically call the public notify() method on a reward notify for it to push rewards into the staking system.
The rewardInterval is set when the notifier is deployed. We'd recommend an interval like 30 days.
To add a new reward source:
Deploy a RewardNotifier
Give the notifier tokens with approve, a balance or mint permission as needed.
Have the staker's admin call setRewardNotifier(address _rewardNotifier, bool true)
Once the notifier is hooked up, call notify() on it to push its rewards into the staking system.
More secure than offchain voting
No trusted third party is required to count or enact votes
Passed proposals can be executed automatically
Works well for approving protocol changes or other high-risk votes
Offchain voting refers to governance systems where individual votes are not submitted as blockchain transactions. No transaction fees are necessary for offchain votes.
In token weighted voting schemes, users are prompted to sign messages with their wallet to vote, and the resulting data is stored via a decentralized file storage system such as IPFS or Arweave. While this storage mechanism reduces risk of vote tampering, a trusted third party is still needed to accurately count the votes and enact the results on-chain using admin privileges. The most prominent offchain voting system, Snapshot, has been adopted as a voting tool by several protocols including Yearn Finance and Sushiswap.
Some protocols also occasionally use non token weighted polls, which give each user one vote regardless of token holdings. Examples include polls in Discourse forums and Discord chats. These polls are vulnerable to manipulation, but can be helpful in gauging community sentiment earlier in the development process before proposals are put up for token holder voting.
No transaction fees required to vote
Offchain votes can be recorded via decentralized data storage systems, reducing risk of vote tampering
Works well for sentiment polls or other low-risk votes
Several protocols are experimenting with using both offchain and on-chain votes in different parts of the governance process. For example, CurveDAO uses Snapshot offchain voting for initial sentiment polls of token holders, and only proposals that successfully pass the polling stage are put up for an on-chain vote. Hybrid approaches like this can help reduce transaction fee expenses while still leaving token holders in full control of system functions.
Aragon and Snapshot are also implementing "optimistic voting," which allows for offchain poll results to be executed on-chain and uses Aragon Court as a security mechanism. More information is available in the Snapshot Voting Design page.
A review process is conducted to ensure that the proposal meets the necessary criteria, such as technical feasibility and alignment with the organization's goals
This stage may involve verifying the proposal’s technical details, ensuring that any code or assets involved are secure, and confirming that the proposal author is legitimate
Council vote
A council, consisting of delegates with technical expertise and community representatives, votes on the proposal
If the proposal passes with a sufficient majority (eg: 4 out of 6 members), it proceeds to the next stage
Optimistic veto window
Following the council vote, a defined veto window opens (typically lasting 7 days), during which any organization member or delegate can cast a veto vote to block the proposal
A veto vote can only cancel the proposal if 2 conditions are met:
The veto turnout meets a quorum threshold, ensuring that the veto process remains representative of the broader community’s stance, AND
A majority (eg >50%) of the veto votes are cast. By default, if delegates don’t vote at all, then only veto votes will be captured. If delegates choose to cast ‘Support’ votes, then this condition will only be met if the number of veto votes exceeds the number of support votes
Execution
If the veto window closes without sufficient opposition, the proposal is executed as originally planned
If the proposal is vetoed, it is canceled, and further revisions may be required before resubmission
Tally's frontend will need to connect the Veto Governor to the Optimistic Governor
The Zodiac Governor module facilitates the management and control of Gnosis Safes by a DAO. With the Zodiac Governor module, a DAO can become a privileged member of the Safe, allowing it to manage signers and execute transactions. This page will guide you through the use case of creating Sub-organizations and managing Grants Programs using the Zodiac Governor module.
Once integrated, the Governor DAO becomes a privileged member of the Safe. This privilege includes the ability to add or remove signers on the safe, giving the Governor DAO full control over membership.
The Governor DAO maintains control over the Safe's funds. It can spend money and execute transactions, allowing the parent DAO to maintain executive authority over its subsidiary structures.
This design opens up several unique opportunities for DAO management:
It allows for the creation of Sub-organizations, where a committee of experts act as signers on the multisig. Even while they operate independently, the parent DAO retains ultimate authority.
It is an ideal mechanism for delegating funds to Grants programs. The DAO maintains authority over both the funds and the Grants program administrators, ensuring a chain of responsibility.
It helps in avoiding centralization dangers, where Grants program administrators could potentially misuse funds without any on-chain recourse.
It offers a solution to political disagreements among signers, preventing funds loss due to indecision or conflict.
It serves as a vital component in the operation of decentralized Grants programs.
Instead of directly transferring funds to the Gnosis safe, the DAO gives the Gnosis safe a spend approval of a certain amount. For instance, rather than transferring $1 million from the treasury, the DAO could give the Gnosis safe a Spend Approval of $1 million. This ensures that the funds only leave the DAO when the multi-sig signers create a transaction. As a result, the funds always remain under the control of the DAO.
Creating a SubDAO for grants oversight or multisig management is straightforward.
Use the Zodiac Governor Module no-code tool to initiate the creation of a Grants Oversight DAO, and follow the steps below:
Select your existing parent DAO token during the creation flow.
Create a new Governor for the SubDAO with your desired parameters for oversight. You can use the same parameters as the parent DAO or opt for different ones to match your specific needs.
The Safe App will automatically create your Governor SubDAO and add it to your multisig.
Finally, a couple of steps are needed to get your new SubDAO fully represented on Tally.
Copy the contract address of the Governor that was created by the Zodiac Governor Module no-code tool and add it directly to Tally.
Link the contract address of the multisig that was created via the Zodiac Governor Module to your Parent DAO, making it easily visible from the parent DAO on Tally.
Resilience: In the face of emergencies, a council's swift actions help maintain the stability and functionality of the organization, thereby preserving users' trust and investments.








Your token contract also needs to implement voting and delegation functions. If you are using an ERC20 token, you can use the ERC20Votes extension from OpenZeppelin contracts library.
If you're using an ERC71 token, you can use OpenZeppelin's ERC721Votes extension.
The Tally frontend helps users make these function calls to delegate their votes:
The token contract must implement the name() function, so that Tally knows what to call the token.
The token contract must implement a symbol() function, so that Tally knows the short name of the token.
ERC20 token contracts must implement a decimals() function, so that Tally can correctly render token balances:
event DelegateVotesChanged(
address indexed delegate,
uint previousBalance,
uint newBalance
);
event DelegateChanged(
address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate
);event Transfer(
address indexed from,
address indexed to,
uint256 amount
);
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);function delegate(address delegatee)
function delegateBySig(
address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s
)
function getVotes(address account) uint256
function name() string
function symbol() string
// ERC20 only:
function decimals() public view returns (uint8) function name() stringfunction symbol() stringfunction decimals() public view returns (uint8) spender: 0x3466EB008EDD8d5052446293D1a7D212cb65C646 (the Hedgey Batch Planner contract address)
amount: the total amount that you will deploy in the vesting batch
Create a second custom action with the following.
Target contract address: 0x3466EB008EDD8d5052446293D1a7D212cb65C646
Contract method: batchVestingPlans
Recipient: address of grant recipient
Amount: total amount of tokens they will granted (include decimals)
Start: Unix time stamp of when the unlocking will start
Cliff: Unix time stamp of an optional cliff, if no cliff you can input 0 or the start date
Rate: The amount of tokens that unlock each period - use the spreadsheet helper
Period: the seconds in the period for vesting, so for instance use a 1 for a streaming style period.
vestingAdmin: the admin of the vesting plans who can revoke plans
adminTransferOBO: this allows the vestingAdmin to transfer plans on the recipients behalf in the case of emergency
mintType: 7; this is a specific number for the Hedgey dApp to display things properly.

Lack of Knowledge: for non-technical delegates especially, some proposals are just too complex to understand. The sensible thing to do in such cases is to abstain from voting.
Free‑rider dilemma: most benefits accrue regardless of participation.
Information overload: proposals can exceed 40 pages; time is scarce.
Fragmented tooling: forum, off-chain voting, and on‑chain voting platforms are often different.
Quorum resilience: more active voters means proposals pass or fail on merit, not turnout luck.
Higher decision quality: structured rationales expose trade‑offs early, reducing costly rewrites.
Professionalized stewardship: paying for attention lets delegates hire analysts or subject‑matter experts.
External confidence: regulators, partners, and institutional LPs equate sustained turnout with robustness.
Metric
Why it matters
Possible Data Sources
On‑chain vote participation
Direct impact on governance protocol rules & treasury
Tally APIs / contract calls from block explorer
Off‑chain vote participation
Signals attentiveness to sentiment checks and social proposals that often precede binding actions
Snapshot APIs
Forum topic creation
Starts public discussions and proposals, shows initiative and research depth
Discourse API
Forum replies & rationale quality
Adds context for delegates and contributes to healthy discourse
Discourse API
Weightings should mirror the causal leverage of each action on proposal quality, not merely its ease of measurement.
Voting is an outcome event stemming from weeks of deliberation, and forum discourse is the process that actually shapes that outcome. Threads in which delegates surface trade‑offs, negotiate red lines, and integrate feedback from diverse stakeholders do more to refine a proposal’s final state than the eventual on‑chain “yes” or “no.”
Empirically, organizations that weight forum contributions 2‑3× higher than raw vote counts (e.g., Arbitrum, Obol) observe faster consensus formation and fewer post‑vote amendments.
In addition to weightings, there are also other important aspects to consider in designing the delegate scoring formula.
Limiting the reward pool, and the number of delegates who are eligible to receive rewards each cycle.
Including a normalization window (last 90 days or last 5 proposals) keeps scores responsive while muting one‑off spikes.
Having correlation mechanisms to add additional points to the score only when delegates explain at least 50 % of their votes.
Exploring square‑root or tiered payouts mitigate plutocracy by flattening the payout curve beyond a threshold.
Ensuring sybil resistance, which can be achieved from requiring verified delegation, KYC, or proof‑of‑personhood attestations.
Budget: Up to 7 000 USD (or 16 500 ARB) per delegate per month.
Metric stack: Forum participation (communicating vote rationale, feedback on proposals, creating new proposals) + Offchain Voting (Snapshot) + Onchain Voting (Tally)
Results:
An average of 40 out of 75 enrolled delegates qualified for rewards.
Voting power mobilised: + $56.8 M previously dormant.
Average voter count per proposal: 7 → 15+ (↑ 117 %).
Quorum time fell from 58 h to 48 h (‑17 %).
Rewards: 165 000 OBOL over six months, distributed via square rooted voting‑power curve.
Scoring window: Last 5 on‑chain proposals → agile enough to reflect new entrants.
Qualitative override: Core team can grant “research bonuses” for deep‑dive analyses.
Co‑design weights with the community to avoid perceptions of capture.
Short look‑back windows (≤ 6 cycles) keep scores up‑to‑date.
Curve or tier budgets to reward breadth of participation (Obol) or minimum standards (Arbitrum).
Publish the data – CSV export + public Dune dashboard.
Review quarterly – Retune weights; prune gamed edge cases.
Tally can surface delegate scores directly on your organization’s delegate page, and if the scores are onchain, these scores can directly be streamed into reward‑distribution contracts. Whether you’re launching your first incentive pilot or scaling an existing scheme, our team can help.
Interested in integrating DRS? Talk to our team to get started.
Binance Academy: Overview of blockchain technology.
Ethereum Foundation learn page: List of educational resources curated by the Ethereum Foundation.
EthHub docs: Community resource for learning about Ethereum.
: User-friendly overview of how Ethereum works.
Bankless: Content platform focusing on decentralized finance.
The Defiant: DeFi-focused newsletter and interview series.
Our Network: Community newsletter focused on o-chain data and analysis.
: Daily coverage of decentralized finance.
: Concise roundup of the Ethereum ecosystem.




Common questions about Swaps, asked and answered.
The quotes come from CoW's price estimator API, which estimates current prices from on-chain sources. As the order executes in the future, prices may vary.
Upon proposal creation, you will receive a quote from CoW based on current market conditions. However, market conditions may change by the time of proposal execution, and a new quote from CoW will be used to create your order.
ensures that your order only executes if the market price is close, using a price oracle and a slippage parameter.
The default price checker on Tally uses Uniswap v3 as a price oracle and sets a max slippage. Custom price checkers can implement any logic they want.
enables smart contracts, like Governor, to place CoW Swap market orders on-chain. Milkman's price checker ensures that orders only fill at prices close to the market price.
If the price checker rejects fills with unfavorable prices, the assets to sell remain in the Milkman order contract. To return those funds to the organization's treasury, the Milkman order needs to be canceled with another on-chain proposal. See .
Tally's default price checker uses the Uniswap V3 oracle to get market prices.
If you select this price checker, Tally suggests a max slippage and picks the Uniswap pair(s) to use for the price oracle.
If there is not a direct path (e.g. COMP<>USDT), Tally will try to make a “bridge” with two pairs, e.g. COMP->WETH->USDT instead of COMP->USDT. If that doesn’t work, you’ll have to make a custom price checker route.
Note that steps 3-7 happen after the Governor proposal.
You want to sell 5 COMP to buy USDT
You create an order with Milkman. You set the price checker to use the Uniswap v3 oracle oracle and to accept 10% slippage.
That milkman order goes on-chain. Solvers compete to offer the best price for your order.
The best offer from CoW solvers is 100 USDT for 5 COMP.
If no solver comes up with a price greater than 90% of the oracle’s market price, then the order will sit unfilled until someone does. This order can also be canceled by whoever has the cancel role. In the context of a Governor proposal, that’s the organization, as it is the entity that request the swap.
You will need to find the contract address of a price checker and encode the data it can use to determine if the order gets a good price, usually slippage and a swap path. You may need to find a custom price checker that Custom price checkers can do anything, though.
A Swap Recipe usually includes two executable calls.
approve Milkman to spend sell token
requestSwapExactTokensForTokens on Milkman
If the trade sells ETH, the funds must first be deposited for , since swap pairs must be ERC20s.
deposit ETH to WETH contract
approve Milkman to spend WETH
requestSwapExactTokensForTokens on Milkman
When casting a vote for a swap, you should check the receipt for accuracy.
The quoted price provides a rough estimate of current market conditions before a swap is filled. The path and slippage show how the price checker will calculate the market price and how much slippage to accept.
After a swap is executed successfully, the Swap Receipt will link to the CoW order and to the order contract.
To cancel an order, the Governor must call cancel on Milkman via an on-chain proposal. Only the governor has authority to cancel an order. Canceling the order returns the assets that were for sale to the treasury.
This means that the order isn’t placed yet. The governor proposal has not yet been executed. Once the proposal has been executed, it will create an order on CoW via Milkman.
Solvers pay gas to take an order. If the gas costs are large compared to the size of the trade, you’ll need high slippage to ensure that the solvers can make a profit after gas costs.
Auto-compounding liquid staking token
The liquid staking token, also called the LST, is the easiest way to get rewards from staking. It's like what stETH does for ETH staking.
The LST is, of course, liquid. Staking positions can be transferred without unstaking.
The LST auto-compounds rewards. Holders will automatically accrue the rewards without having to call claim()
The LST keeps governance power active. When the LST is in DeFi, cold storage, or a centralized exchange, the LST provides a backup plan for governance power.
The backup, called the , has the job of keeping voting power active in governance. For example, see the , which only votes on proposals that have lots of consensus.
Check out the code in the open-source .
Holder stake tokens to receive LST tokens.
Optionally, they can delegate the governance token voting power
The LST contracts deposit the staked tokens in Staker. The LST assigns the voting power to the holder's chosen delegate, if any. Otherwise, it assigns the voting power using the delegate
The can be configured by governance. This keeps the default voting power aligned with the organization and mitigates capture risk.
Holders can redeem their liquid staking tokens for the underlying staked token at any time. The LST has a short withdrawal delay to prevent MEV extraction.
Stakers - any holder of the staking token can stake for rewards
Owner - manages the fee switch
DelegateAdmin - controls the auto-delegate
Searchers - anyone, such as MEV searchers, can be a "crank turner" to push rewards through the system to stakers.
The owner can change the fee, up to a hardcoded MAX_FEE_BIPS .
The fee is collecting on rewards. When a reward is distributed from the underlying staking system to stakers, the fee is applied to the reward amount.
The fee is only collected on rewards. There's no fee on deposits, staked assets, or withdrawals.
The LST wants to accrue rewards in staking tokens, not other reward tokens. To do so, it auctions off rewards to MEV searchers. The LST has a that allows any caller to swap a fixed amount of native tokens for all its staking rewards, which can be in any token(s).
Think of this system as a reverse Dutch auction. The buyer, the LST, is always willing to accept X amount of staking tokens for its accumulated staking rewards. Each block, the accumulated staking rewards increase. Eventually, an MEV searcher should be willing to accept all the accumulated rewards in return for X amount of staking tokens. Note that the MEV searcher also has to pay the gas for this transaction.
Here's an example:
An LST contract has accrued rewards of 0.99 ETH in the staking contract.
The payoutAmount in the LST is configured to 500 staking tokens.
Imagine ETH is trading at $2,500 and the staking token is trading at $5.
At this point, the accrued rewards are worth $2,495, and LST is asking for $2,500 worth of the staking token. No searchers are willing to make that trade because it's a loss for them.
Each LST deployment consists of two ERC-20 tokens that distribute rewards through the same underlying accounting system.
- Implements a rebasing style liquid staking token similar to stETH. One LST token is worth one of the underlying staked token, and each user's balance is updated dynamically.
- Implements a fixed balance vault-style staking token. A user's balance does not change, but also does not map 1:1 with the underlying staked token. Instead, the number of underlying tokens a user may claim in exchange for their position goes up over time.
Each deployment of the LST system includes both style of tokens, but a project may choose to emphasize one or the other, or to put both front and center for their users. Generally, fixed balance tokens are preferred by integrators and custody providers.
For more information about the LST contracts, see
Understand what Gnosis Safes are and how they work on Tally.
It's easy to create or link a Gnosis Safe on Tally from Organization settings. Learn more about Gnosis Safes below, or skip right to the step-by-step instructions.
Gnosis Safe is a smart contract multi-sig wallet running on Ethereum that requires a minimum number of people to approve a transaction before it can occur. This added layer of security helps to protect against the loss or theft of funds.
Gnosis Safes are commonly used to manage pooled organization funds. organizations often require a certain number of members to sign off on any fund transfers. organization actions are generally voted upon by all members and then executed by the core group of signers.
A multi-sig Gnosis Safe works by requiring multiple signatures, or "keys," in order to execute a transaction. When the safe is created, the user specifies the number of keys that are required to sign a transaction before it is executed.
To submit a transaction with a Gnosis Safe, you would first need to create the transaction on the Ethereum network. This can typically be done using a wallet or other Ethereum-enabled application. Once the transaction has been created, it must be signed by the required number of keys associated with the safe. This process typically involves each key holder using their own private key to sign the transaction. Once the transaction has been signed by the required number of keys, it can be submitted to the Ethereum network to be executed.
Gnosis Safe supports Ether and all assets that fully comply with the . This includes assets such as DAI, USDC, UNI, and many others.
An Owner is a signer of the of the Gnosis Safe smart contract wallet. Owner accounts sign off on transactions on the Gnosis Safe smart contract, such as transferring funds from the wallet.
The threshold is the number of signers required to confirm a transaction. Once the threshold of owner accounts have confirmed a transaction, the Safe transaction can be executed.
Delegates are non-owners that are authorized to initiate transactions for a specific Safe which then would show up on the official Gnosis Safe interfaces. Delegates need to be authorized by an owner of a Safe.
Delegates can be viewed, added and removed via the .
To empower organizations that use Gnosis Safes, Tally allows users to create or link their Safes to your organization.
Creating a Gnosis Safe on Tally creates the exact same instance of Gnosis’s smart contract that Gnosis’s own app does, with the added benefit of managing it from the same Tally organization that you may be using for Governor and Tokenless organizations. Having your Gnosis Safe linked on Tally will also allow users to take advantage of Tally features such as the Create Proposal tool and Recipes.
To create a new Gnosis Safe, simply select the Create Safe button from the Safes tab of the page.
Select the Safe's network, give it a name, add and set its . Then click the Create Safe button!
To link an existing Gnosis Safe, select the Link Safe button from the Safes tab of the page.
Select the Safe's network, give it a name, and enter its address. Then simply click Link Safe!
How to set Proposal Threshold, Quorum, Voting Period, Voting Delay, and Timelock Delay
A Governor contract has several important parameters that affect the lifecycles of its proposals. Think about these parameters as a balancing act between ease of passing proposals and security against malicious proposals. That’s an important – and tough – tradeoff to get right!
Here's a guide to picking these parameters to set a DAO up for success by picking the right parameters:
Be careful at the start, though. If the parameters are set too high, it will be hard to make the onchain proposal that updates the parameters!
The Proposal Threshold is the amount of voting power that an account needs to make a proposal. Governors on Tally usually set the threshold to somewhere between 0% and 2% of circulating token supply.
The purpose of the threshold is to prevent spam proposals and to make sure that anyone making a proposal has either direct economic exposure or trust from delegators. Some DAOs set the proposal threshold to 0 to lower the barriers to participating.
Picking a good Proposal Threshold depends on the distribution of delegated voting power, which might be hard to know before the DAO gets off the ground. Once the distribution of voting power is known, it’s a good idea to have a medium-size group of delegates over the threshold. DAOs on Tally typically set their Proposal Threshold to a place where at least 5-10 delegates have enough voting power to make a proposal.
The Quorum is the amount of `For` votes – sometimes also including the amount of `Abstain` votes – for a proposal.
Picking a good quorum is tough, because it depends on voter turnout, which might be hard to know in advance. A too-high quorum might make it impossible for a Governor to pass *any* proposals! On the other hand, too-low quorum might open up the Governor to spam attacks, where an attacker repeatedly submits a malicious proposal and forces other voters to repeatedly vote it down.
For Governors on Tally, the quorum is usually somewhere in the range of 1-10% of circulating token supply.
The voting period is how voting lasts on each proposal. At the end of the voting period, the proposal has passed or failed. Most DAOs pick a period between 3 and 7 days.
Less than 3 days, and someone can try to sneak through a proposal on a weekend or during a period of low activity. Something closer to 7 days gives everyone time to review a proposal.
The voting delay is the amount of time between when a proposal is submitted and when it goes up for voting. Most Governors have a voting delay of 0. The Governors that do have one usually pick a period of one day or less.
The delay gives token holders time to delegate their voting power before the vote starts or buy more votes. Governor takes a snapshot of all the voting power at the start of voting. Delegation and balance changes after that don’t affect voting power. That said, most DAOs decide that this extra time for managing votes isn’t worth slowing down the proposal.
The timelock delay is the minimum amount of time between when a proposal posses and when it can be executed. There’s a big agility vs. security tradeoff here, so DAOs pick values all the way from 0 days to 7 days for their timelock delay.
Tally recommends picking a delay of 0 for Governors that only manage a treasury. The security benefit of a delay isn’t as relevant. The exception is if the Timelock has someone with an emergency veto/cancel role. In that case, they probably want at least 3 days to react to potentially malicious proposals.
For Governors that control a DeFi protocol where users might want to withdraw their funds before a big protocol change, we usually see timelock delays closer to 7 days.
How to deploy a Governor Bravo or Alpha that's compatible with Tally
Tally supports and Alpha, but we consider it deprecated. If you are deploying a new Governor, we recommend OZ Governor is more actively maintained and has all of Bravo's features.
If you're already using a direct fork of Governor Bravo, then your organization should work with Tally out of the box. If you insist on making changes to the base contract, then you can use this guide to make sure that your changes are compatible with Tally's API and web interface.
Tally's API listens to event logs from Governor contracts when indexing them. Your contract will need to maintain the same event signatures that OZ Governor implements:
Governance‑call attendance
Real‑time engagement, question‑answer loop, social accountability
Calendar analytics
Research & reporting
Long‑form analyses, risk reports; lifts the knowledge floor for everyone
GitHub PRs and commits
Rewards auto-compound
Rewards must be manually staked
Native staking is more configurable. The LST is easier to use. Tally staking supports both at the same time, so users can choose the best option for them.
Liquid ERC20 tokens
Non-fungible positions
One staking position
Multiple positions
Rewards claim automatically
Claim rewards manually
The price checker uses the Uniswap v3 oracle. The Uni v3 price is 21 USDT for 1 COMP.
The price checker confirms that the best offer is greater than the market price with slippage. Here’s the logic:
The offer of
100 USDT / 5 COMP = 20 USDT per COMP
is greater than the price checker’s limit of
21 USDT per COMP * 0.9 slippage = 18.9 COMP
The price checker allows the order to execute on CoW protocol
The LST contract claims Staker's rewards regularly.
The position compounds. The rewards are auctioned off for more of the staked token, which is added to each user's staked position. e.g. a deposit worth 100 GOV tokens might grow to be worth 105 GOV tokens.
A few blocks later, the LST contract earns another 0.01 ETH. Now, the accrued rewards are worth $2,500, and the LST is asking for $2,500 of the staking token.
At this point, the value of ETH available to be claimed is equal to the value of the payout amount required in staking token.
Once a bit more ETH accrues, it will be profitable for a searcher to trade their 500 staking tokens and pay the gas to trade for the accrued ETH rewards.
The LST holders have now increased their collective holdings by 500 of the underlying staking token.




Tally's frontend app helps users make web3 calls to your Governor contract. The app lets users create Proposals as well as vote on, queue and execute them.
To be compatible with Tally, your Governor will need these function signatures:
The Tally app need reads state from the public getters of these state variables:
Tally needs the quorum to figure out whether a proposal passed.
Tally expects a quorum constant:
Note that the OpenZeppelin interface uses a function instead of a constant for quorum.
For Governor Bravo, Tally uses the voting delay to know when voting starts. Governor Alpha does not have a voting delay. For Governor Bravo, a votingDelay constant on Governor is required:
Note that the OpenZeppelin interface uses a function instead of a constant for voting delay.
Tally uses the voting period to correctly show the end of voting. A votingPeriod() constant on Governor is required:
Note that the OpenZeppelin interface uses a function instead of a constant for voting period.
Tally's app expects the following proposal states. If your Governor uses a custom proposal lifecycle, those states won't show up correctly on on Tally:
Governors can change their own parameters, like proposal times and the amount of voting power required to create and pass proposals. To make sure that Tally indexes your Governor's parameter changes, implement these event signatures:
event ProposalCreated(
uint id,
address proposer,
address[] targets,
uint[] values,
string[] signatures,
bytes[] calldatas,
uint startBlock,
uint endBlock,
string description
);
event VoteCast(
address indexed voter,
uint proposalId,
uint8 support,
uint votes,
string reason
);
event ProposalCanceled(uint id);
event ProposalQueued(uint id, uint eta);
event ProposalExecuted(uint id);function castVote(uint proposalId, uint8 support) external
function castVoteWithReason(
uint proposalId,
uint8 support,
string reason
) external
function castVoteBySig(
uint proposalId,
uint8 support,
uint8 v,
bytes32 r,
bytes32 s
) external
function state(uint proposalId) public view returns (ProposalState)
function propose(
address[] memory targets,
uint[] memory values,
string[] memory signatures,
bytes[] memory calldatas,
string memory description
) public returns (uint)
function execute(uint proposalId) external payable
function queue(uint proposalId) external
function cancel(uint proposalId) externaluint public votingDelay;
uint public votingPeriod;
uint public proposalThreshold;
uint public constant quorumVotes;uint public constant quorumVotes;uint public votingDelay;uint public votingPeriod;enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
} event VotingDelaySet(uint256 oldVotingDelay, uint256 newVotingDelay);
event VotingPeriodSet(uint256 oldVotingPeriod, uint256 newVotingPeriod);
event ProposalThresholdSet(uint256 oldProposalThreshold, uint256 newProposalThreshold);
Tally Security Vulnerability Disclosure Policy
At Tally, we take security seriously and value the contributions of security researchers who help keep our platform and users safe. This policy provides guidelines for conducting security research and reporting vulnerabilities responsibly.
To report a vulnerability, reach out to [email protected]
Main application at tally.xyz
Associated subdomains
API endpoints
Web application functionality
Denial of Service (DoS) attacks
Spam attacks
Social engineering attacks
Physical security attacks
Do No Harm:
Do not attempt to access, modify, or delete data belonging to other users
Do not attempt to degrade or disrupt our services
Do not use automated scanning tools without explicit permission
Initial Report: Submit your findings through our secure bug reporting platform or email with:
Detailed description of the vulnerability
Steps to reproduce
Proof of concept
Rewards are based on severity and quality of report:
Critical:
Direct loss of user funds
Smart contract vulnerabilities leading to theft
Remote code execution
Access to private keys or sensitive credentials*
High:
Authentication bypass
Significant disclosure of private information
Injecting malicious transactions for users to sign
Stored cross-site scripting
Medium:
Reflected cross-site scripting
Cross-site request forgery
Smart contract vulnerabilities affecting liveness
Low:
Missing security headers
Non-sensitive user data exposure
Race conditions without direct security impact
*Note that public environment variables such as RPC endpoints are not considered sensitive.
Please allow us 90 days before public disclosure
Coordinate disclosure timing with our security team
We encourage responsible disclosure through our bug bounty email address
Credit will be given to researchers who follow these guidelines
We will not pursue legal action against researchers who:
Follow this responsible disclosure policy
Make good faith efforts to avoid privacy violations, destruction of data, and interruption or degradation of our services
Do not exploit vulnerabilities beyond the minimum necessary to demonstrate the vulnerability
Primary Contact:
This policy may be updated from time to time. Please review it before starting any security research or submitting reports.
Learn how to propose token grants with Hedgey on Tally.
Using , you can make a proposal for your organization to distribute grants directly to grant recipients. Token Grants allow your organization to distribute tokens for incentives, and other reward mechanisms to spur ecosystem development, decentralization, and proliferation.
Grants by Hedgey come in a few forms, so it is important to decide beforehand which version is most appropriate for your grant needs. Grants is at its core a simple distribution mechanism to distribute tokens to the grantees, with a public dashboard, and bake in time based milestones when the grantees will receive the tokens. Grants can be either revocable, or non-revocable, include ability to participate in governance with Tally, or can prevented from governance participation. Other key features include linear (streaming) or periodic time-based distribution schedules.
Compatibility considerations when implementing OpenZeppelin governor
To be compatible with the Tally app we recommend you to use OpenZeppelin's library . If you want to implement changes to this base contract, here is the interface that you should follow to make sure your contract works with our app.
Tally's API listens to event logs from Governor contracts when indexing them. Your contract will need to maintain the same event signatures that OZ Governor implements:
Smart contract interactions
Issues already reported by another researcher
Issues in third-party dependencies that are already publicly known
Do not attempt to phish or social engineer our employees or users
Testing Requirements:
Only test against accounts you own or have explicit permission to test
Create a separate test account for security research
Do not test in a way that could impact other users or the platform's stability
Immediately stop testing if you encounter sensitive user data
Impact assessment
Suggested remediation (if any)
Response Timeline:
Initial acknowledgment: Within 24 hours
Triage and severity assessment: Within 3 business days
Regular updates on fix progress: Every 5 business days
Resolution timeline based on severity:
Critical: 7 days
High: 30 days
Medium: 60 days
Low: 90 days
Critical
$5,000-$25,000
High
$2,500-$5,000
Medium
$500-$2,000
Low
$100-500
Tally's frontend app helps users make web3 calls to your Governor contract. The app lets users create Proposals as well as vote on, queue and execute them. In addition, the app reads state from the contract with function calls.
To be compatible with Tally, your Governor will need these function signatures:
If your OpenZeppelin governor contract uses a Timelock, it will also need this signature:
Tally needs the quorum to calculate if a proposal has passed. That means that Tally requires the Governor to have a quorum() function:
Optionally, Tally also supports the quorumNumerator() and quorumDenominator() functions. Governors with quorums that are a function of token supply should implement these functions:
If the Governor is missing either quorumNumerator() or quorumDenominator(), Tally falls back to the quorum() function and assumes that the quorum is fixed.
Tally needs to know the voting delay to calculate when voting starts without polling the blockchain. A votingDelay() function on Governor is required:
Tally needs to know the voting period to calculate when a proposal finishes voting without polling the blockchain. A votingPeriod() function on Governor is required:
Tally's app expects the following proposal states. If your Governor uses a custom proposal lifecycle, those states won't show up correctly on on Tally:
Governors can change their own parameters, like proposal times and the amount of voting power required to create and pass proposals. To make sure that Tally indexes your Governor's parameter changes, implement these event signatures:
If your OpenZeppelin governor contract uses a Timelock, it will also need this event:
Tally handles the ProposalExtended event, which is emitted by governors that implement the PreventLateQuorum extension:
Since Governor v4.9, all voting contracts (including ERC20Votes and ERC721Votes) rely on IERC6372 for clock management. The Governor will automatically detect the clock mode used by the token and adapt to it. There is no need to override anything in the Governor contract. You can learn more about compatibility of your token and Governor contract with clock mode here.
Tally checks the contract lock using the IERC-6372 standard. We accept blocknumber and timestamp clock modes.Specifically, Tally expects Governor and token contracts to implement a CLOCK_MODE() function that returns either mode=blocknumber&from=default or mode=blocknumber&from=<CAIP-2-ID> . If the call to the governor's CLOCK_MODE() method returns mode=timestamp then proposal start and end times will be interpreted as unix timestamps otherwise they will be interpreted as block numbers.
If you're interested in support for another contract clock, Tally would need to do some custom work. Get in touch with [email protected].
event ProposalCreated(
uint256 proposalId,
address proposer,
address[] targets,
uint256[] values,
string[] signatures,
bytes[] calldatas,
uint256 startBlock,
uint256 endBlock,
string description
);
event ProposalQueued(uint256 proposalId, uint256 etaSeconds);
event ProposalCanceled(uint256 proposalId);
event ProposalExecuted(uint256 proposalId);
event VoteCast(
address indexed voter,
uint256 proposalId,
uint8 support,
uint256 weight,
string reason
);function votingDelay() public view virtual returns (uint256);
function votingPeriod() public view virtual returns (uint256);
function quorum(uint256 timepoint) public view virtual returns (uint256);
function proposalThreshold() public view virtual returns (uint256);
function state(uint256 proposalId) public view virtual override returns (
ProposalState
);
function getVotes(
address account,
uint256 timepoint
) public view virtual returns (uint256);
function propose(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
string memory description
) public virtual returns (uint256 proposalId);
function execute(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) public payable virtual returns (uint256 proposalId);
function castVote(
uint256 proposalId,
uint8 support
) public virtual returns (uint256 balance);
function castVoteWithReason(
uint256 proposalId,
uint8 support,
string calldata reason
) public virtual returns (uint256 balance);
function castVoteBySig(
uint256 proposalId,
uint8 support,
uint8 v,
bytes32 r,
bytes32 s
) public virtual returns (uint256 balance);function queue(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) public virtual override returns (uint256)function quorum(uint256 timepoint) public view virtual returns (uint256);function quorumNumerator() public view virtual returns (uint256);
function quorumDenominator() public view virtual returns (uint256);function votingDelay() public view virtual returns (uint256);function votingPeriod() public view virtual returns (uint256);enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
} event VotingDelaySet(uint256 oldVotingDelay, uint256 newVotingDelay);
event VotingPeriodSet(uint256 oldVotingPeriod, uint256 newVotingPeriod);
event ProposalThresholdSet(uint256 oldProposalThreshold, uint256 newProposalThreshold);
event QuorumNumeratorUpdated(uint256 oldQuorumNumerator, uint256 newQuorumNumerator);event TimelockChange(address oldTimelock, address newTimelock);event ProposalExtended(uint256 indexed proposalId, uint64 extendedDeadline);Conversely, revocable grants are a solution for grantees that are expected to perform tasks and achieve milestones, or distribute incentives and rewards, in the future. With a revocable grant, if the grantee does not meet their milestones, or for any other reason, the organization can claw back the tokens from the grantee based on their vesting schedule - which is often configured to align with the time based milestones.
Before creating the grants proposal, you should prepare the data that will be pasted into Tally and be delivered to the Hedgey smart contract upon execution of the approved proposal.
Token Contract Address: <ERC-20 Token Contract Address>
Hedgey Batch Contract Address: 0x3466EB008EDD8d5052446293D1a7D212cb65C646
Hedgey Grants Contract: <Hedgey Smart contract - depends on revocable & voting grid below>
Hedgey Grants Contracts
Revocable
Not Revocable
Allows Tally Governance
0x1bb64AF7FE05fc69c740609267d2AbE3e119Ef82
0x73cD8626b3cD47B009E68380720CFE6679A3Ec3D
No Tally Governance
0x2CDE9919e81b20B4B33DD562a48a84b54C48F00C
0x1961A23409CA59EEDCA6a99c97E4087DaD752486
Distribution Frequency / Period: This determines (in seconds) how frequently tokens are distributed to grantees. For the “streaming” version, this would be 1, where a small amount of tokens is distributed and claimable each second. Here are some other handy periods:
Frequency
Value for Period
Streaming / Linear per second
1
Daily
86,400
Weekly
604,800
Every 2 Weeks
1,209,600
Monthly
2,628,000
Grant Recipients Details:
Recipient Address
Total amount of Tokens to be distributed
Start date (in unix time)
Cliff date (in unix time)
Rate: the amount of tokens that vest in each period
You can use this link and make a copy to help you create the plans, input the items in orange, and then you’ll have your finished Tuple of Plans in cell B6 to copy into Tally.
With your prepared data at hand, navigate to the Tally portal and create your proposal. In the "Custom Actions" section, you will need to input two actions: the first is the ERC-20 token allowance approval, and the second is the actual Hedgey Grants creation transaction.
Target Contract address: the Address of your organization Token or ERC-20 Token to be used for grants
Contract method: ‘approve’
Calldatas: spender: 0x3466EB008EDD8d5052446293D1a7D212cb65C646 (the Hedgey Batch Planner contract address)
amount: the total amount that you will deploy in the grants batch
Paste in the BatchPlanner contract 0x3466EB008EDD8d5052446293D1a7D212cb65C646, and then we need to select one of two methods.
If you are distributing Revocable Grants, choose the “batchVestingPlans” method. If you are distributing Non-revocable Grants, choose the “batchLockingPlans” method.
Inputs are as follows:
Locker: <Hedgey Contract Address>
Token: address of your organization token
totalAmount: the total amount of tokens to be distributed to grant recipients
Plans: this is an array (tuple) of each grants plan, which you can paste in the details of each recipient individually
Recipient: address of grant recipient
Amount: total amount of tokens they will granted (include decimals)
Start: Unix time stamp of when the unlocking will start
Cliff: Unix time stamp of an optional cliff, if no cliff you can input 0 or the start date
Period: the seconds in the period for vesting
vestingAdmin: the admin of the vesting plans who can revoke plans - only for revocable grants
adminTransferOBO: this allows the vestingAdmin to transfer plans on the recipients behalf in the case of emergency
mintType: 7; this is a specific number for the Hedgey dApp to display things properly
For non-revocable grants, still use mintType 7, but the vestingAdmin and adminTransferOBO functions will not be required.
Learn how to propose streaming payments with Sablier on Tally.
Using Sablier, you can make a proposal on Tally to stream ERC-20 tokens.
Streaming refers to the continuous transfer of tokens over time from one account to another. Instead of sending a lump sum of tokens in a single transaction, streaming allows for the gradual and real-time transfer of funds.
Streaming can be used for vesting, airdrops, grants, payroll, etc. You can read more about the benefits of streaming for organizations here and here.
To call Sablier's contract, there are three steps:
Find the on your organization's network.
Enter that address into Tally's Custom action.
Pick the method that you want to call.
Before interacting with the Sablier contracts, the first step is to approve the spending of the token you are looking to use. If you want to stream DAI, for example, you will need to approve the spending of a certain amount of DAI. This is not done in our own contracts, but instead, in the contract of the token you are looking to spend.
The ERC-20 implementation has a function called approve, which is the function we are going to call. Let’s say we want to stream 3141 DAI. The approval call will look like this:
In the example above, the Signature field highlights the function to be called. In the Calldata field, the address field is the contract address of the Sablier contract you are looking to interact with, and uint256 is the amount of tokens you are looking to spend, decimals included.
This is important. Different tokens have different amounts of decimals. For example, USDC has 6 decimals and DAI has 18 decimals.
If the token you are looking to spend has 18 decimals, as is the case with DAI, you will need to add eighteen 0s to the amount you are looking to spend. If you want to stream 542 DAI, that means that the actual amount you will need to put in will be 542000000000000000000.
Note: If the amount you are trying to send already has decimals (for example, 124.5 DAI), you will need to subtract the amount of decimals in the amount from the amount of 0s that you need to add. To make this clearer, if you are looking to stream 124.5 DAI, meaning an amount with 1 decimal, you will only need to add seventeen 0s as opposed to eighteen, as there is already a decimal included in the amount. In this case, the deposit amount will look like this: 124500000000000000000."
Finally, the Target value is the contract address of the token you are looking to stream, with the Value field having no relevance here given we won’t spend any ETH in this transaction; we are merely approving the spending of a certain ERC-20 token.
On every chain Sablier is deployed on, there are three types of stream shapes you can create:
Linear: allows you to create linear streams, with or without cliffs.
Tranched: allows you to create streams by tranches, meaning timelocks, periodic unlocks, etc.
Dynamic: allows you to create streams with dynamic payment curves, including non-linear ones.
More can be read about the different types of streams . Depending on which contract you are looking to interact with, and on which chain you are will be doing so, the contract addresses will change. Head over to find the right contract address.
We have approved the spending of our token, so we can create the actual stream now.
In this example, we will focus on Lockup Linear. It's fairly similar for Lockup Tranched and Lockup Dynamic, though this latter one is harder to interact with. Feel free to reach out to the Sablier team on to get help.
There are two ways to create a stream in Lockup Linear:
CreateWithDurations: allows you to create a stream that will start as soon as the stream creation transaction is included in the blockchain, which will run for a specific duration.
CreateWithTimestamps: allows you to create a stream that will start on a specific date and will end on a specific date.
Both ways support cliffs, and differ only slightly in the way you call them programmatically in Sablier's contracts. When using either function, whether CreateWithDurations or CreateWithTimestamps, they need to be appended with LL if using Linear, LT if using Tranched, and LD if using Dynamic
Here is an example of what a function call with CreateWithTimestamps looks like:
As in the previous spending approval example, the Signature field highlights the function we are calling. The Target field represents the contract we are calling, which in this case is the SablierV2LockupLinear contract on Mainnet. And as in our last example, the Value field can be set to 0.
We will now take an interest in the Calldata field, and specifically the tuple it contains.
The structure of the tuple is as follows:
Let’s go over them one by one:
sender address: this is the address you are funding the stream with, which will also have the ability to cancel the stream.
recipient address: the address you are looking to stream the funds to. They will be able to subsequently withdraw funds from the stream.
amount (decimals included): the amount of tokens you are looking to stream, with decimals included, as previously explained. Numbers have to be sent between quotation marks, meaning if a parameter's value is 100.0, it should be written as "100.0".
Regarding cancelation, all streams in Sablier V2 have a cancelation setting.
If it’s set to true, that means that the stream can be canceled at any time by the stream creator. The stream creator is the organization. Canceling the stream will stop it and return the funds which haven’t yet been streamed over to the stream creator. If the organization wants to cancel a cancellable stream, generally that will require another proposal.
If it’s set to false, the stream is non-cancelable, which means that it cannot be stopped. The recipient is then guaranteed to receive the funds in the stream, no matter what happens. Setting the stream as non-cancelable is an irreversible action, there’s no way to make it cancelable afterwards.
Regarding transferability, all streams in Sablier V2 are represented by an NFT owned by the stream recipient. Whoever owns the NFT is the recipient of the stream.
If transferability is set to true, the NFT (and by extension the stream) is transferable to someone else. This means the recipient could send the stream over to another address they own, or they could send it over to someone else. It also means the stream could be sold on OpenSea by the recipient without the vesting period being over. Or they could theoretically borrow against it in an NFT lending protocol by using it as collateral.
If transferability is set to false, the NFT cannot be transferred to someone else. The recipient will not be able to sell it to someone else on a marketplace like OpenSea, and they won’t be able to borrow against it in an NFT lending protocol.
Regarding the cliff date, it’s a cut-off point for releasing assets. Prior to the cliff, the recipient cannot withdraw, though assets continue to accrue in the stream. If you don’t want a cliff, you simply set the same date there as the start date.
If you want a cliff, you can set a date in the future depending on how long you want your cliff to last. If you want a 1-month cliff, and your stream starts on January 1st, your will cliff date will need to be on February 1st.
CreateWithDuration differs only slightly, as can be seen in the following tuple:
As you may have noticed, the only different part is the following section:
Instead of having a start date, cliff date, and end date, as in CreateWithTimestamps, the CreateWithDurations function only requires a cliff duration (in seconds), and the total stream duration (also in seconds).
There is no start date or end date required, as the stream will start as soon as the stream creation transaction is validated. Once that’s done, the stream starts and will last for the total duration.
token contract address: the contract address of the ERC-20 token you are looking to stream.
cancelable (true/false): whether or not the stream should be cancelable. We will go over this more in a minute.
transferable (true/false): whether or not the stream is transferable to someone else. We will go over this more in a minute.
start date (unix timestamp): the start date of the stream, as a UNIX timestamp. The Unix Timestamp is in seconds, not to be confused with milliseconds.
cliff date (unix timestamp): the cliff date of the stream, as a UNIX timestamp. We will go over this more in a minute.
end date (unix timestamp): the end date of the stream.
broker address: the broker address. If you don’t know what this is, you don't need it. Simply set it to 0x0000000000000000000000000000000000000000 as laid out in the example.
broker fee: the broker fee. Again, if you don’t know what this is, you don’t need it. Simply set it to 0.


Signature: approve(address,uint256)
Calldata:
address: 0xB10daee1FCF62243aE27776D7a92D39dC8740f95
uint256: 3141000000000000000000
Target: 0x6B175474E89094C44Da98b954EedeAC495271d0F
Value: 0Signature: createWithTimestampsLL(tuple,tuple,uint40)
Calldata:
tuple: ["0xf26994E6Af0b95cCa8DFA22A0BC25E1f38a54C42", "0xb4bf8a8475d1e8e9a2088f118ad0e2cdc2896183", 100000000000000000000, "0x3DcBc355c5B5FdF45D2d2ccc8890d76C5b30394A", false, true, [1737936000, 1769472000], "", ["0x0000000000000000000000000000000000000000", 0], ["0", "2000000000000000000"], 1738195200]
Target: 0x7C01AA3783577E15fD7e272443D44B92d5b21056
Value: 0tuple: [
sender address,
recipient address,
amount (decimals included),
token contract address,
cancelable (true/false),
transferable (true/false),
[
start date (unix timesteamp),
cliff date (unix timesteamp),
end date (unix timesteamp)
],
[
broker address,
broker fee
]
]tuple: [
sender address,
recipient address,
amount (decimals included),
token contract address,
cancelable (true/false),
transferable (true/false),
[
cliff duration (seconds),
total (seconds)
],
[
broker address,
broker fee
]
][
cliff duration (seconds),
total (seconds)
]Rate: The amount of tokens that unlock each period - use the spreadsheet helper
Quarterly
7,884,000
Annually
31,536,000
Understand how Tally's staking contracts work under the hood
Staker is a flexible, configurable staking contract. It distributes on-chain staking rewards to the holders of an ERC20 token, including governance tokens. The rewards are proportional to the amount staked over time. Rewards can be boosted or penalized by the eligibility criteria.
System Architecture
Here's an architecture diagram of the staking smart contracts:
The staking contracts have modules for calculating earning power, hooking up sources of rewards, and extensions. Protocol teams can assemble a staking system from these audited pieces.
Staking is out-of-the-box compatible with existing `ERC20Votes` governance tokens. It supports `ERC20Votes` delegation with the "surrogate factory" pattern. Staking creates a surrogate contract for each delegate. It delegates voting power in each surrogate to the delegate.
When Staker receives rewards, it distributes them over a period of time, e.g. 30 days. Distributing over time gives unstaked tokenholders a chance to stake. A smooth schedule also minimizes discontinuities from flash staking.
Staker is built on. Unistaker is based on Synthetix's.
UniStaker and Staker have been audited several times. The audit reports are.
Any instance of Staker needs these pieces to work.
Staker Contract: The main contract that handles staking, reward distribution, and voting power delegation
Earning Power Calculator: Determines how rewards are distributed to stakers
Delegation Surrogate: Manages governance voting power for staked tokens
Reward Notifier(s): Connect reward sources to the staking system
Instances of Staker can add these extensions for extra features.
StakerPermitAndStake: Adds EIP-2612 permit functionality for better UX
StakerOnBehalf: Enables signature-based execution of staking actions
StakerCapDeposits: Enforces a cap on the total stake amount
The LST, also called stGOV, is the easiest way to get rewards from staking.
The LST is, of course, liquid. Staking positions can be transferred without unstaking.
The LST auto-compounds rewards. Holders will automatically accrue the rewards without having to call claim()
The LST keeps governance power active. When the LST is in DeFi, cold storage, or a centralized exchange, the LST provides a backup plan for governance power.
Access the open-source .
The Staker contract is the core of the system. It manages:
Staking deposits and withdrawals
Reward distribution over time
Delegation of voting power
Earning power calculation
Staker uses a streaming reward mechanism, where rewards are added as lump sums, then distributed evenly over time. This gives stakers time to respond to changes in reward rates.
Staker uses a concept called "Earning Power" to distribute rewards. Every depositor gets Earning Power. Their share of the reward is their earning power divided by the total earning power in Staker, over time. The earning power calculator determines which depositors are eligible for rewards and how much they earn
Flat Earning Power
: Simple 1:1 mapping where earning power equals staked amount.
Oracle-based Earning Power
: More advanced calculator where earning power depends on the delegate's activity score. Here’s how it works:
An oracle puts scores on-chain
The calculator turns earning power on and off based on whether an address's score exceeds a configurable threshold
Staker uses the earning power over time to distribute rewards.
. Tally provides two implementations:
Tally's system distributes rewards through a stream mechanism:
Rewards periodically enter the staking system as lump sums
Those rewards stream to stakers over time
Stakers earn proportional to their staked amount
This approach gives stakers time to respond to changes in rewards.
Reward notifiers connect different token sources to the staking system. Tally provides three standard notifiers:
ERC20 transfer() Direct token transfers from a treasury or revenue source
ERC20 transferFrom() Approved transfers from a separate contract or wallet
ERC20 mint() -Newly minted tokens from an inflationary schedule
Each notifier handles capturing rewards from your chosen source and adding them to the staking reward pool.
Reward notifiers are responsible for informing the staking contract about new rewards:
holds rewards directly and distributes them by calling transfer()
relies on an approve(), so that it can call transferFrom() on the reward source
calls mint() on a token contract.
Staker uses the “surrogate pattern” to make staking compatible with governance tokens. That way, tokenholders don’t have to choose between earning rewards and doing governance.
Staker creates a surrogate contract for each delegate (address receiving voting power)
Surrogate deposits and withdrawals are fully controlled by the staking system. Staker does all the accounting.
The surrogate contract holds staked tokens and delegates all its voting power to the chosen delegatee. That way, staking is compatible with the underlying governance token.
Note that these surrogate contracts allow tokenholders to split up their voting power. i.e. partial delegation
Create custom earning power calculators to incentivize specific behaviors:
Activity-based rewards: Require governance participation to earn full rewards.
Time-weighted staking: Increase rewards for long-term stakers
Protocol usage rewards: Tie rewards to protocol usage
Admin controls:
The admin of the staking contracts can’t touch staked assets. They do control some system parameters:
Add and remove reward sources, by enabling and disabling reward notifiers
Set the eligibility criteria for rewards, by changing the earning power calculator
Change the emergency pause guardian.
Override eligibility for a particular address.
Upgrade strategy:
These contracts could be deployed immutable or with the upgradeable proxy pattern
To migrate an immutable Staker:
Deploy a new staking contract
Send rewards there
Have tokenholders migrate to the new one
Emergency measures:
The oracle-based calculator has failsafes in case the oracle misbehaves or goes offline:
If the oracle misbehaves by posting incorrect scores, a `PauseGuardian` can pause the system, reverting it to flat earning power.
If the oracle goes offline, the calculator also automatically reverts to using flat earning power.
The oracle can be replaced by Staker's admin.
Deposit: ~100,000-150,000 gas
Claiming rewards: ~60,000-100,000 gas
Withdrawal: ~80,000-120,000 gas
For optimal performance:
Distribute rewards at reasonable intervals, e.g., weekly or monthly
The earning power calculator should wait between updates, e.g. daily
The earning power calculator shouldn’t make lots of small updates, especially networks with high gas costs
Anyone can update earning power as it changes, but someone needs to do it. Staker provides “tips” as incentive for bots to do updates. If MEV bots do not know about the incentive, consider running the staker bots script directly.
Set claim fee parameters
To upgrade-in-place a proxy contract:
Use initializers instead of constructors for key params at deployment
Check the storage slots carefully to avoid corrupting state
These incentives don’t work testnets or for tokens with no market value.

// Sample code to create a basic Staker implementation
contract MyStaker is
Staker,
StakerDelegateSurrogateVotes,
StakerPermitAndStake
{
constructor(
IERC20 _rewardsToken,
IERC20Staking _stakeToken,
IEarningPowerCalculator _earningPowerCalculator,
uint256 _maxBumpTip,
address _admin
)
Staker(_rewardsToken, _stakeToken, _earningPowerCalculator, _maxBumpTip, _admin)
StakerPermitAndStake(_stakeToken)
StakerDelegateSurrogateVotes(_stakeToken)
{}
}// Deploy a simple earning power calculator
IdentityEarningPowerCalculator calculator = new IdentityEarningPowerCalculator();
// Or deploy an oracle-based calculator
BinaryEligibilityOracleEarningPowerCalculator oracleCalculator =
new BinaryEligibilityOracleEarningPowerCalculator(
owner,
scoreOracle,
staleOracleWindow,
oraclePauseGuardian,
delegateeScoreEligibilityThreshold,
updateEligibilityDelay
);// Example: deploy a transfer reward notifier
TransferRewardNotifier transferNotifier = new TransferRewardNotifier(
stakerContract, // The staking contract to notify
initialRewardAmount, // Amount to distribute per period
initialRewardInterval, // Time between distributions
owner // Admin of the notifier
);
// Transfer reward tokens to the notifier
rewardToken.transfer(address(transferNotifier), totalRewards);
// Call notify to distribute rewards
transferNotifier.notify();// The staking contract creates a surrogate for each delegatee
function _fetchOrDeploySurrogate(address _delegatee) internal returns (DelegationSurrogate _surrogate) {
_surrogate = new DelegationSurrogateVotes(stakeToken, _delegatee);
return _surrogate;
}// Example of a custom earning power calculator
contract CustomEarningPowerCalculator is IEarningPowerCalculator {
function getEarningPower(uint256 _amountStaked, address _staker, address _delegatee)
external
view
returns (uint256)
{
// Custom logic to determine earning power
return _calculateCustomEarningPower(_amountStaked, _staker, _delegatee);
}
function getNewEarningPower(
uint256 _amountStaked,
address _staker,
address _delegatee,
uint256 _oldEarningPower
) external view returns (uint256, bool) {
uint256 newPower = _calculateCustomEarningPower(_amountStaked, _staker, _delegatee);
bool qualifiedForBump = _isQualifiedForBump(newPower, _oldEarningPower);
return (newPower, qualifiedForBump);
}
// Your custom calculation logic
function _calculateCustomEarningPower(uint256 _amountStaked, address _staker, address _delegatee)
internal
view
returns (uint256)
{
// Implementation details
}
}







