# Drips Docs

## Docs

- [Accessing Drips](/access): Drips is an open-source application and protocol built on Ethereum, a publicly-accessible, global blockchain. While we've built the Drips App for simple interaction with Drips' underlying smart contracts, there are a multitude of alternative tools that enable interaction with the Drips Protocol, some of which are listed below.
- [FAQ](/faq): The Drips Protocol is free to use and does not impose any fees on users. Users will still need to pay gas
fees to interact with the Drips Contracts as they would with any contract on Ethereum.
- [Managing Drip List and project visibility](/advanced/drip-list-and-project-visibility): By default, newly-claimed projects and created Drip Lists are publicly visible across the Drips App, including on their owner's profiles. However, as the owner of a project or Drip List, you may choose to *hide* them. In addition, Drip Lists transferred to another address must be explicitly un-hidden before appearing on the new owner's public profile.
- [Usage with a Safe multisig](/advanced/usage-with-a-safe): You can use the Drips App as a Safe App for conveniently proposing transactions to your Safe.
- [Claim your open-source project](/get-support/claim-your-repository): A *Project* on Drips represents an open-source repository on GitHub, with support for other Git hosts coming soon. Every GitHub repository starts out on Drips as *unclaimed*. In this state, it can already be funded with a Drip List, or added as a dependency of another project. At any point, the project's maintainers can *claim* their project on Drips, configure a list of *maintainers* and *dependencies*, and collect any previously-received earnings. Future incoming funds are then automatically split as configured by the project maintainers, resulting in deeply-nested dependencies receiving their allocation.
- [Administering a RetroPGF Round](/rpgf/administering-your-round): As a round administrator, you are responsible for managing the lifecycle of your RetroPGF round—from reviewing applications to publishing results and facilitating payouts. This guide covers the key administrative tasks after your round has been [created and published](/rpgf/create-your-round).
- [Applying to a RetroPGF Round](/rpgf/apply-to-a-round): Applying to a RetroPGF round on Drips allows you to showcase your past contributions and be considered for funding by the round organizers. This guide explains the application process from the perspective of an applicant.
- [Create a RetroPGF Round](/rpgf/create-your-round): Retroactive Public Goods Funding (RetroPGF) on Drips allows communities to fund projects and contributors for their past impact. This process is organized into *Rounds*, each with its own timeline, budget, and participants.
- [RetroPGF on Drips](/rpgf/overview): Retroactive Public Goods Funding (RPGF) is a powerful mechanism for funding impactful work that has already been completed. Instead of funding promises about future work, RPGF allows communities to identify and reward projects and individuals who have already provided demonstrable value. This "results-based" approach helps ensure that funds are directed effectively towards proven contributors.
- [Voting in a RetroPGF Round](/rpgf/vote-on-a-round): As a *badgeholder* in a Drips RetroPGF Round, your role is to evaluate the contributions of applicants and allocate votes to reward the impact you believe they've created. This guide will walk you through the voting process.
- [Drip Lists](/support-your-dependencies/overview): On Drips, anyone can create a *Drip List* to flexibly send funds to a list of up to 200 open-source GitHub repositories, Ethereum addresses, or other Drip Lists at a time. As project maintainers come to Drips to claim their funds, they themselves are asked to provide a list of other projects they depend on, and can choose to automatically forward a percentage of their earnings to them. In this article, we'll go over how you can create your own *Drip List*, and start supporting it with continuous or instant donations using any ERC-20 token.
- [Accounts in Drips](/the-protocol/accounts-in-drips): In this section we take a look at the Drips Protocol's driver-based account model and review the types of user accounts that are available in Drips V2 today.
- [Drips v2 features](/the-protocol/drips-v2-features): The goal of Drips v2 is to be the most powerful and feature-complete decentralized, autonomous, and non-custodial protocol for streaming and splitting funds in web3, with the following key features.
- [Overview](/the-protocol/overview): The Drips protocol is a fully decentralized, non-custodial, autonomous, and gas-optimized protocol allowing you to schedule and structure your ERC-20 token transactions to particular addresses. The information provided herein are for educational purposes only.
- [Security](/the-protocol/security): At Drips, we take security seriously and have taken a number of steps to ensure the security of our smart contracts on Ethereum.
- [Smart Contract details](/the-protocol/smart-contract-details): This deployment is based on the <a href="https://github.com/radicle-dev/drips-contracts/releases/tag/v2_ethereum_deploy" target="_blank">'v2\_ethereum\_deploy' tag </a>from the Drips Smart Contracts repository.
- [Applicant metrics](/wave/applicant-metrics): When contributors apply to work on an issue, maintainers see a **Code Metrics** scorecard summarizing their public GitHub activity. This page explains how each metric is calculated and what the categorical labels mean.
- [Drips Wave](/wave): Drips Wave is a recurring bounty cycle designed to help ecosystems attract developers, accelerate maintenance, and grow their communities. Instead of one-off grants or long-term commitments, Wave creates a predictable rhythm of contribution where developers can "Fix, Merge, and Earn."
- [Understanding Points & Rewards](/wave/points-and-rewards): Drips Wave uses a transparent, points-based system to quantify value and distribute rewards. Whether you are a Maintainer scoping work or a Contributor solving issues, understanding how points flow is key to maximizing your success in a Wave.
- [Drips Wave - Terms and Conditions](/wave/terms-and-rules): Bounty sprints (“**Drips Wave Programs**”) in which you may participate as a contributor or maintainer (“**you**”, “**your**” or “**Participant**”), are hosted on the platform (“**Wave Platform**”) developed by the Public Goods Association (“**Association**”, “**we**”, “**our**”), a Swiss association with its registered seat is in Zug. Drips Wave Programs are designed to reward genuine impact within a designated third-party ecosystem. Each Drips Wave Program may consist of a series of waves (“**Drips Waves**”).
- [Withdrawing Your Rewards](/wave/withdrawing-rewards): After a Wave ends and your contributions have been evaluated, your earnings are converted into **Reward Grants**. Each grant represents a portion of the reward pool you've earned, payable in USDC on the Stellar network. When a new grant is available, you'll receive a notification email.
- [Handling renamed GitHub repositories](/get-support/advanced/handling-renamed-github-repos): Due to Drips' unique decentralized and permissionless approach to Public Goods Funding, there are a few extra considerations when it comes to handling funds sent to GitHub repositories on Drips that were later renamed on GitHub. Let's dive a bit deeper into why that is, and how best to handle it.
- [Managing Custom Datasets](/rpgf/advanced/custom-datasets): Custom datasets allow round admins to enrich applications with additional data, giving badgeholders more context during the voting process. You can upload one or more CSV files, and the data from these sets will be displayed as distinct cards on the relevant application pages, and also be included in all CSV exports of application data.
- [API Reference](/advanced/drips-sdk/api-reference): Creates the main SDK instance with access to all modules.
- [Blockchain Client Support](/advanced/drips-sdk/blockchain-client-support): The SDK supports `Viem`, `Ethers v6` or `custom` blockchain clients.
- [💧Drips SDK](/advanced/drips-sdk/drips-sdk): The **Drips SDK** is a TypeScript library for building applications that interact with the [Drips protocol](https://github.com/drips-network/contracts).
It wraps much of the [Drips App](https://www.drips.network)’s functionality to make common operations re-usable.
- [Error Handling](/advanced/drips-sdk/error-handling): The SDK throws `DripsError` instances for all SDK-related failures. These errors extend the standard JavaScript `Error` class with additional context information.
- [GraphQL Configuration](/advanced/drips-sdk/graphql-configuration): The SDK connects to Drips' GraphQL Multi-Chain API for querying blockchain data and metadata.
- [Initialization](/advanced/drips-sdk/initialization): The `options` parameter allows you to customize the SDK's behavior:
- [Installation](/advanced/drips-sdk/installation): The Drips SDK is built on top of Viem, making it a required peer dependency.
Support for Ethers v6 is included to accommodate applications that rely on Ethers.
- [IPFS Metadata Uploader](/advanced/drips-sdk/ipfs-metadata-uploader): The IPFS metadata uploader is required for "write" SDK instances.
- [Modules](/advanced/drips-sdk/modules): The SDK is organized into modules, each handling specific aspects of Drips.
- [💧Drips SDK](/advanced/drips-sdk/overview): The **Drips SDK** is a TypeScript library for building applications that interact with the [Drips protocol](https://github.com/drips-network/contracts).
It wraps much of the [Drips App](https://www.drips.network)'s functionality to make common operations re-usable.
- [Quick Start](/advanced/drips-sdk/quick-start)
- [Creating a collaborative Drip List](/support-your-dependencies/collaborative-drip-lists/creating-a-collaborative-drip-list): With a Collaborative Drip Lists, a group of people can come together and vote on the recipients of a Drip List before it gets deployed on-chain. This makes it easy to settle on a list of dependencies with distributed teams, and even allows running larger Public Goods Funding programs on Drips.
- [Voting on a list](/support-your-dependencies/collaborative-drip-lists/voting-on-a-list): Voting on a collaborative Drip List is quick, easy, and entirely gasless. Here's a step-by-step guide on how to submit your vote.
- [Account metadata](/the-protocol/advanced/account-metadata): The Drips Protocol includes functionality allowing general metadata information to be associated with user accounts. Like setting streams or Splits, the authority to add such metadata ultimately rests with the end-user who controls the account. However apps building on Drips can build on this capability to store any kind of metadata they wish (with their end-users' permission).
- [Batching with Caller](/the-protocol/advanced/batching-with-caller): `Caller` adds a number of powerful functionalities to Drips related to batching of function calls and delegation of access control.
Specifically, it is also a <a href="https://github.com/radicle-dev/drips-contracts/blob/master/src/Caller.sol" target="_blank">smart contract</a> included with the Drips V2 deployment that builds on <a href="https://eips.ethereum.org/EIPS/eip-712" target="_blank">EIP-712</a> and <a href="https://eips.ethereum.org/EIPS/eip-2771" target="_blank">EIP-2771</a>.
- [Drips inner workings](/the-protocol/advanced/drips-inner-workings): This page offers an introduction to the core mechanics of how streaming is implemented in smart contracts. The implementation can be found on [Github](https://github.com/radicle-dev/drips-contracts) in `Drips.sol`.
- [Fractional amounts](/the-protocol/advanced/fractional-amounts): If you know how token decimals work, feel free to skip this section.
- [FAQ for Maintainers](/wave/maintainers/faq): These frequently asked questions cover the essentials of nominating issues, managing time, and understanding how your contributors get paid.
- [Participating in a Wave](/wave/maintainers/participating-in-a-wave): As a Project Maintainer, Drips Wave allows you to leverage your community to accelerate development. By identifying "good first issues" or critical maintenance tasks, you can attract contributors who are ready to build. Participation is entirely free for maintainers, and Wave Organizers (e.g. the Stellar Development Foundation) provide a funding pool to reward contributors for their work, allowing you to incentivize contributions without impacting your budget.
- [Points Budgets](/wave/maintainers/points-budgets): Wave Programs may have two points budgets configured: a **per-repo budget** that caps the points any single repository can contribute per Wave, and a **per-org budget** that caps the combined points across all of an org's approved repos per Wave. These caps help ensure that no one repo or org dominates the reward pool, encouraging a more balanced distribution of issues across all participating repositories.
- [Repo Application Limits](/wave/maintainers/repo-application-limits): Wave Programs may limit how many repositories can be applied within a single Wave cycle. There are two types of repo application limits: a **per-user limit** that caps how many repos any one person can apply across all of their organizations, and a **per-org limit** that caps how many repos can be applied on behalf of a single organization across all of its members. These limits help keep applications manageable and fair when a Program receives more interest than it can review.
- [FAQ for Contributors](/wave/contributors/faq): These frequently asked questions cover how to find work, how the point system translates to money, and what is required to get paid.
- [Solving Issues & Earning Rewards](/wave/contributors/solving-issues-and-earning-rewards): Drips Wave turns open-source contribution into a structured, rewarding experience. As a contributor, you can browse curated issues from top-tier ecosystems, apply to work on them, and earn rewards based on your impact.