Coming Soon

Fundraising
infrastructure,
enforced by code.

Non-custodial escrow for early-stage raises. Caps, timelines, and refunds enforced by smart contracts.

Private beta opening soon

The Problem

Most fundraising relies on manual settlement and reputational enforcement. Custody is social. Refunds are promises. Caps and timelines depend on coordination and good faith. Even honest teams fail under pressure, market shifts, or operational constraints. Capset replaces trust-based execution with programmatic enforcement. Terms are set on-chain, outcomes are automatic, and recovery is enabled when conditions fail.

How It Works

Escrow that enforces constraints.

Capset routes funds into non-custodial smart contracts with fixed parameters and publicly referenced terms. If conditions aren't met, contributors can claim refunds permissionlessly. No exceptions, no manual intervention.

01

Terms are set on-chain

Hard caps, soft caps, deadlines, and allocation rules encoded in the contract.

02

Funds held in escrow

Contributions locked until terms are satisfied. No early access, no custody risk.

03

Claim refunds permissionlessly

If soft cap isn't reached by deadline, contributors can claim their refunds. No approval needed.

Contract State Machine

Five immutable states enforced on-chain

State 0
Upcoming → before startTime
State 1
Active → accepting contributions
State 2
Ended → awaiting finalization
Finalize checks: softCap && tokensDeposited
Success
Finalized → claim tokens
Failure
Refunding → claim refund
Claim Tokens: When you contribute, you receive ERC20 claim tokens that represent your allocation under the listed terms.

Allocation Claims

Programmable proof of allocation.

When you contribute, you receive an ERC20 claim token representing your allocation under the listed terms. These tokens are portable, programmable, and designed for transparent settlement.

Simple to reason about

Each claim token represents a fixed allocation. Your balance reflects your position in the raise, making calculations and verification straightforward.

Transferable by default

Claim tokens are standard ERC20s. You can transfer allocation between addresses or integrate with other contracts without intermediaries.

Programmable settlement

Claim tokens support vesting schedules, unlock conditions, and composable distribution logic. Enabling transparent, automated settlement.

Built Different

Infrastructure that makes failure safe and success transparent.

Non-custodial

We never hold funds. Contracts are permissionless and auditable. No trusted intermediaries.

Core parameters are fixed

Once deployed, core rules cannot change. Caps, deadlines, and refund logic are set at deployment.

Failure-aware

We treat failure as a first-class outcome with programmatic recovery.

Automatic execution

Refunds and releases happen permissionlessly.

Transparent claims

All allocations tracked on-chain and publicly verifiable.

Multi-chain ready

Deploy on any EVM chain

OpenZeppelin standards

Battle-tested security patterns

Technical

Production-grade contracts. Zero trust assumptions.

Built with OpenZeppelin standards and battle-tested patterns. Currently in private testing on Base Sepolia.

ReentrancyGuard on all state-changing functions
Fee-on-transfer token protection (reverts if detected)
Immutable parameters set at deployment (no upgrades)
Terms are publicly referenced and verifiable on-chain
Presale.sol 
function finalize() external nonReentrant {
    require(state() == State.Ended, "Not ended");
    require(!finalized, "Already finalized");

    finalized = true;

    // Success: softCap reached AND tokens deposited
    if (totalRaised >= softCap && tokensDeposited) {
        successful = true;
        totalAllocated = requiredTokens;

        // Split funds: platform fee + team payout
        uint256 fee = (totalRaised * platformFeeBps) / 10_000;
        uint256 payout = totalRaised - fee;

        safeTransfer(feeRecipient, fee);
        safeTransfer(owner(), payout);
    } else {
        // Failed: enable automatic refunds
        successful = false;
    }

    emit Finalized(totalRaised, totalAllocated, successful);
}
Base Sepolia

Built For

Built for teams running on-chain raises.

Web3 teams launching presales, community rounds, or early-stage raises with fixed caps and timelines. Also used by DAOs, protocols, and creators managing programmatic allocation and settlement.

Who uses Capset

  • — Web3 teams running presales or community rounds with enforceable terms
  • — Protocols replacing multisig custody with non-custodial escrow
  • — DAOs funding initiatives with transparent allocation and settlement
  • — Creators running early raises with automatic refund enforcement

For Contributors

  • — Participate in raises with contract-enforced terms and automatic recovery if conditions fail.
  • — Refunds enforced by contract, not promises
  • — Verifiable allocations tracked on-chain
  • — No custody risk or manual settlement

Request early access

Join the waitlist to get notified when private beta opens.