Basin is a social network on Robinhood Chain where any post can carry a reward pool: $BASIN that's shared with the people who engage with it. It works like the social apps you know (a feed, replies, reposts, DMs, profiles), with a built-in wallet so earning and paying happen right where you post.

When you post, you can attach a pool of $BASIN. The tokens move into the pool contract when you post, and everyone sees the pool on the post. You can also add a pool later, to an older post of yours or to anyone else's: see boosting.

A pool stays open for 24 hours (a boost ends with the pool it joins, so boosting never restarts the timer). When it closes, it's split between everyone eligible who engaged while it was open. If nobody eligible engaged, the whole pool comes back to you. Basin never takes a cut of pools.

Any post can get a pool after it's posted: an older post of your own, or someone else's post you want more people to see. Tap $ in the post's action bar (it shows a rocket when the post already has a pool running), choose how much $BASIN, and confirm.

• A boost is its own pool. If the post already has a pool running, the boost ends with it, so boosting never restarts the countdown; otherwise it runs for 24 hours. It starts when your $BASIN is locked, and only engagement after that counts, so a boost pays for the attention it brings, not for likes from last week.
• Anyone who already engaged can still earn from it by doing something they haven't done yet: a repost, reply, quote, or follow from the post.
• You can't earn from your own boost, and the post's author never earns from pools on their own post. You can still earn from the other pools on it: the author's pool, and other people's boosts.
• A post can have several pools at once. Its badge adds up everything still open and shows how many boosts it has.
• If nobody engages, the boost comes back to you, and so does anything unclaimed after 30 days. It never goes to the author.

Pools feed each other. Every funded post pays people to engage, that engagement gets the post seen, and the people who earned or got seen fund the next pool.

Each kind of engagement is worth points. Your share of a pool is your points divided by everyone's.

Anyone can earn by engaging while the pool is open (new accounts count too), except the person who made the post. Your engagement counts in full once you do any one of these:

• link your X account (Settings);
• get Verified;
• hold at least 100,000 $BASIN in your Basin wallet.

Until then it counts at 0.1×. That keeps throwaway accounts from taking much of a pool.

The more $BASIN you hold, the more your engagement counts in every pool. $BASIN has a fixed supply of 1,000,000,000, so 1% is 10 million.

• Stacks with Verified. A Verified Whale counts 1.5 × 2.5 = 3.75×. The total never goes above 4×, so big holders can't take over a pool.
• Your balance is checked twice: when you engage and again when the pool pays out. The lower one counts, so tokens passed between accounts during a pool only count once.
• Holding 100,000 $BASIN or more also counts as one of the ways to earn in full, with or without X or Verified.

When a pool you earned from closes, you get a notification. Open Wallet → Rewards and tap Claim, or Claim all.

• Claiming is free. Basin sends the claim for you, so you don't need ETH for gas or to approve anything.
• Rewards only ever go to your own wallet. The contract checks every claim against a fingerprint of the payout list, so nobody else can claim your share or send it somewhere else.
• You have 30 days to claim.

30 days after a pool pays out, anything nobody claimed goes back to the person who funded it. Basin does this automatically every day. You can also do it yourself from Wallet → Rewards → Pools you funded once it's due.

Sign in with any of these. Your first sign-in creates your account:

• X (also links your X account, which lets you earn from pools);
• a wallet you already use, like MetaMask or Rainbow;
• email, with a 6-digit code.

Signing up with X or email gives you a built-in wallet automatically, with no seed phrase to write down. Then you pick a username, name, and profile picture. Use the same sign-in method each time: a different method counts as a different account.

• Where it goes: posts go to Home (your followers and the main feed) unless you pick one of your Basins with the Home button in the composer.
• What you can add: text, up to 5 photos or a video (a post can be just media), more posts to make a thread, a poll, and a $ reward pool (the last button in the composer).
• Polls: tap the chart button, write your question as the post, and add 2 to 6 choices. Pick how long voting stays open (1 hour to 7 days). Everyone gets one vote and can't change it. Voters see the results right after voting, and you can always see them on your own poll. A poll can't have photos or a video.
• Linking to Basin: paste a link to a Basin post and it shows inside your post the way a quote does, not as a link preview. A link to a Stream shows its live card.
• Discover: Search (under Home in the sidebar) shows live and upcoming Streams, coins pumping today, people getting popular, and trending posts. The Trending box on the right links there too.

• You control your wallet. Basin's built-in wallet (made for you when you sign up with X or email) is secured by Privy; Basin can't move your funds.
• Export your private key any time from the Wallet page to use it in another app.
• If you signed in with MetaMask or Rainbow, that wallet is your Basin wallet and every send opens there for you to confirm.
• Basin pays the gas for your Basin wallet, so you never need ETH to claim, fund a pool, or send. With MetaMask or Rainbow, claiming is free but funding and sending need a little ETH for gas.

Basin Verified is $180/year or $18/month (yearly saves $36). Pay in USDG, the Paxos dollar on Robinhood Chain. You get:

• 1.5× reward weight on every pool you engage with
• Write full-length Articles with titles and formatting
• Early access to new features in Labs
• Earn from reward pools without linking X
• Ranked higher in the For You feed and in replies
• Higher posting and engagement limits
• Verified badge on your profile and posts

Launch offer: until Thu, Oct 8, 11:59 PM ET, anyone who isn't Verified yet pays $9/month (50% off) or $81/year (55% off).

Get it on the Verified page (or Settings → Verified). Verified starts as soon as your payment confirms and doesn't renew automatically.

Basins are communities: each has its own feed, profile picture, header, description, links, and members. Anyone can browse Basins, join them, and post in them.

• Posting in a Basin: when you write a post, pick where it goes with the button in the composer: Home, or one of the Basins you've joined. Basin posts also show in the main feed, marked in [Basin] next to the author's name; tap it to open the Basin.
• Creating: for now, only Verified members with Settings → Labs → Beta features on can create a Basin. The first 3 are free, then $15 each.
• Roles: the owner can do everything, including deleting the Basin and appointing admins. Admins edit the Basin and appoint moderators. Moderators hide posts from the Basin and ban members. Nobody can act on someone of equal or higher rank.
• A post hidden from a Basin stays on its author's profile.

Invite your friends to Basin and earn from it. Your link is basin.social/r/yourname and your code is your username; find both on the Invite friends page. Invite as many people as you like.

• When your friend joins: they sign up with your link or code, then either link an X account or hold at least $10 of $BASIN in their wallet for 7 days. When they do, you both get a week of Verified.
• When your friend gets Verified: you earn 20% of every Verified payment they make in their first year, in $BASIN at the price on payout day: $3.60 from every $18 month, $36 from every $180 year. Part of what Basin earns from Verified goes straight back to the people who bring members in.
• Getting paid: referral rewards are paid out automatically every day. They show up in your Rewards (in your wallet) as “Referral rewards”; tap Claim like any other reward. Claiming is free.
• Your link remembers you: after a friend opens your link, it counts for 30 days, even if they sign up later. Signing up shows who invited them, and they can type your code instead. Forgot? They can add your code from the Invite friends page within 3 days of joining.
• Fair play: you can't invite yourself or an account sharing your wallet, who invited someone can't be changed later, and each X account can count for one invite, ever. Referral Verified adds up to at most a year ahead. Fake or farmed accounts don't earn, and we can withhold rewards from abuse.

The Leaderboard (in the sidebar) ranks the people giving and earning the most $BASIN. Search it to find anyone.

• Top distributors: $BASIN put into reward pools that paid out, credited to whoever funded them (boosts count for the booster). Pools that were refunded don't count.
• Top earners: $BASIN earned from reward pools, claimed or not.
• Today, this week, this month, and all time. Boards reset at midnight UTC: daily every day, weekly on Monday, monthly on the 1st. A pool counts when it pays out, not when it's funded.
• Anyone can be on the leaderboard. Every profile also shows how much $BASIN that person has claimed and distributed.

Awards are coming. We're going to start giving daily, weekly, and monthly awards to the top of both boards. Top distributors will get the biggest awards, and top earners will be rewarded too.

• Only Verified members can receive awards. If someone who isn't Verified places, the award goes to the next Verified member on the board.
• Accounts that game the boards (funding their own alts, fake engagement, bots) can be left out of awards.
• We'll announce the details, and when awards start, before the first one is paid.

A Stream is a live voice room: someone hosts, people drop in to listen, and the host brings people up to speak. Find them in Streams in the sidebar, in the Live now row at the top of your feed, in Live Streams on the right, on the Search page, or as a post in the feed with a live card on it. Every Stream shows how many people are listening (or, once it's over, how many joined).

• Listening: anyone can join. Tap Join and listen; the Stream keeps playing while you browse the rest of Basin (a small player sits at the bottom of the screen). On phones, the Streams tab in the bar at the bottom glows green while you're listening; tap it to go back to the room.
• Speaking: tap Raise hand. If the host or a co-host invites you up, your mic unlocks; tap Unmute when you want to talk. Until then your mic can't be heard at all.
• A Stream is a post: it can be liked, reposted, replied to, quoted, and boosted like any other post.
• Chat: everyone in the room can type in the chat beside it. On phones it's tucked into a bar at the bottom showing the latest message and how many you've missed; tap or swipe it up to open it. Links and @mentions are clickable. The host and co-hosts can delete messages, and you can delete your own. When someone boosts the Stream, the chat says so.
• Pins and the wall: the host and co-hosts can pin any message (theirs, a speaker's, or a listener's) to the top of the chat, one at a time. They can also put up to 6 things on the Stream's wall, a row between the speakers and the listeners: Basin posts or any other link (shown with its preview). Paste a link, or tap one someone shared in the chat. Everyone in the room sees changes right away.
• Sound: the headphones button deafens you (you hear nothing, and your mic goes off until you undeafen). The sliders button sets the Stream's volume, your mic volume (with a level meter so you can test it), noise suppression, and which mic and speakers to use. Tap anyone in the room to turn just them up, down, or off; only you hear the difference. Your settings are saved on this device.
• Scheduled Streams: tap RSVP and you'll get a notification when it starts. Everyone who RSVP'd is listed on the Stream's page, so others can see who's going. You're also notified when someone you follow goes live.
• After it ends, the Stream's page lists everyone who joined.
• Sharing: every Stream has its own link (the share button at the top of it). Scheduled Streams have one as soon as they're scheduled, so people can RSVP before it starts.

Hosting is for Verified members. On the Streams page, tap Go live or Schedule (up to 4 days ahead) and fill in the form, or tap the mic in the composer. The title and description are both optional; the description is posted to your feed with the Stream. You can host it at home or in a Basin you've joined.

• Speakers and co-hosts: bring anyone up to speak, move them back to listening, or make them a co-host. Co-hosts can bring people up, move them back, and remove people. Anyone can speak or co-host when invited, Verified or not.
• Co-hosts and invites: in the composer's Stream panel, add co-hosts (up to 10) and invite people by username. They're notified right away, and again when a scheduled Stream goes live. You and your co-hosts can add more later from the Stream's page or Manage Stream in the room.
• If the host disconnects, the Stream keeps going and co-hosts take over: they can end it and change co-hosts until the host is back.
• Removing someone disconnects them, and they can't rejoin. Changed your mind? Open Manage Stream in the room and tap Allow back.
• End Stream closes the room for everyone. To step away without ending it, use the leave button next to it. A scheduled Stream starts when you open it and tap Start now.

A Stream can have a reward pool, just like a post: fund it with the $ in the Stream's room or on its post, or boost it once one is running (a live counter in the room shows how much $BASIN is in it). It works like any pool, with points for the time you spend in the room on top of the usual ones:

• Likes, reposts, replies, quotes, and follows on the Stream's post earn their usual points.
• Listening for at least 10 minutes while the pool is running earns 5 points. If the whole Stream lasted less than 10 minutes, having joined at all counts.
• Speaking (host, co-host, or speaker) earns 10 points instead of the listening points.
• The host can't earn from pools on their own Stream, and whoever funded a boost can't earn from it. Your usual multipliers, and the 0.1× rate before you link X, apply as with any pool.
• It pays out when the Stream ends, not on a 24-hour timer: a few minutes after the host ends it (or everyone leaves), everyone who earned gets their share. A boost only counts listening and engagement from after it was funded. If a Stream somehow never ends, its pools pay out 6 days after they were funded.

• Your IP address stays private. Audio goes through our voice provider's servers (LiveKit), not directly between people, so other listeners and speakers never see where you're connecting from.
• Other people in a Stream see only your Basin username, name, profile picture, and role.
• Blocking works here too: you won't hear or see anyone you've blocked, and people blocked by the host can't join.
• Basin doesn't record Streams, but anyone listening could record what they hear. Talk like you would in public, and never share private keys, seed phrases, or personal details.

Every pool is held by one contract on Robinhood Chain. Its activity is public, so you can check every pool, payout, and claim yourself.

Its source code is verified on RobinScan: the code you can read there is exactly the code that runs. It's open source (MIT) and built on OpenZeppelin's audited libraries.

If Basin ever went offline, your money isn't stuck. If a pool hasn't been closed within 7 days, the person who funded it can take it back directly from the contract.

Two separate keys. The server's key can only close and refund pools. A second key, kept offline, can only replace the server's key, so a leaked server key can be switched off without touching anyone's pools.

The escrow is one contract that holds every reward pool on Basin. It's about 220 lines of Solidity, and this part of the docs walks through it, with the real code next to each step. The code shown here is read from the same file that was deployed, and every block links to the verified source.

A pool moves through these steps in order, and none of them can happen twice:

1. 01

   Fund

   Someone puts $BASIN into a pool for a post. The contract holds it.

2. 02

   Settle

   When the pool closes, Basin publishes who earned what as one fingerprint (a Merkle root).

3. 03

   Claim

   Each earner pulls their own share out, with a proof that their line is in the list.

4. 04

   Return

   Anything left after 30 days goes back to whoever funded it. Never to Basin.

The contract states its own trust model at the top of the file:

10/// @title PoolEscrow11/// @notice One contract holds every post's reward pool, keyed by `poolId`12/// (keccak256 of the post's id). Pools pay out via Merkle pull-claims rather13/// than pushed transfers, so settling a pool is one transaction no matter how14/// many people engaged.15///16/// Trust model:17/// - The settler (the server's hot key) can only (a) commit one Merkle root per18///   pool, or (b) refund an unsettled pool to its own funder. It can never move19///   funds to an arbitrary address.20/// - The owner (a cold wallet or Safe, never the server) can only replace the21///   settler. If the server key leaks, the owner swaps it out; no redeploy.22/// - Total claims are capped at the pool's deposit, so even a bad root can't23///   drain other pools.24/// - `claimed[poolId][account]` is set in the same transaction as the25///   transfer, so a double-claim race (the classic hot-wallet treasury bug)26///   can't happen here.27/// - Anything unclaimed after CLAIM_WINDOW — including rounding dust — goes28///   back to the funder, never to Basin.29contract PoolEscrow is Ownable, ReentrancyGuard {

It's built on OpenZeppelin's libraries for token transfers, Merkle proofs, ownership, and reentrancy protection, rather than writing any of those by hand.

Every pool is a row keyed by a poolId (see pool ids). The contract also remembers who has claimed from each pool, and which address is allowed to settle.

32uint256 public constant CLAIM_WINDOW = 30 days;33/// If the settler never settles a pool (key lost, backend down), the funder34/// can take their money back after this long. Pools settle at 24h normally.35uint256 public constant STALE_AFTER = 7 days;36 37struct Pool {38    address token; // address(0) = native ETH39    address funder;40    uint256 totalDeposited;41    uint256 totalClaimed;42    bytes32 merkleRoot;43    uint64 fundedAt;44    uint64 settledAt;45    bool settled;46    bool closed; // refunded or swept — no further movement possible47}48 49mapping(bytes32 poolId => Pool) public pools;50mapping(bytes32 poolId => mapping(address account => bool)) public claimed;51 52/// The only address that can settle or refund pools.53address public settler;

Funding happens from the funder's own wallet: Basin asks you to approve the amount, then calls fundPool. A pool id can only ever be funded once, by one funder.

76/// @notice Fund a pool with an ERC-20 (Basin token, USDG, or a tokenized equity).77/// Each pool is funded exactly once, by one funder.78function fundPool(bytes32 poolId, address token, uint256 amount) external nonReentrant {79    require(token != address(0), "use fundPoolNative");80    require(amount > 0, "amount must be > 0");81    Pool storage pool = pools[poolId];82    require(pool.funder == address(0), "pool already funded");83 84    pool.token = token;85    pool.funder = msg.sender;86    pool.fundedAt = uint64(block.timestamp);87 88    // Credit what actually arrived, so a fee-on-transfer token can't make89    // the pool promise more than it holds.90    uint256 before = IERC20(token).balanceOf(address(this));91    IERC20(token).safeTransferFrom(msg.sender, address(this), amount);92    uint256 received = IERC20(token).balanceOf(address(this)) - before;93    require(received > 0, "nothing received");94    pool.totalDeposited = received;95 96    emit PoolFunded(poolId, msg.sender, token, received);97}

The contract measures its balance before and after the transfer and credits the difference. A token that takes a fee on transfer can't make a pool promise more than it really holds.

When a pool's 24 hours are up, Basin works out everyone's share (see who earns), puts each (address, amount) into a Merkle tree, and commits the tree's root. That's one transaction whether 3 people earned or 3,000.

112/// @notice Commit the computed distribution as a single Merkle root.113function settlePool(bytes32 poolId, bytes32 merkleRoot) external onlySettler {114    Pool storage pool = pools[poolId];115    require(pool.funder != address(0), "pool not funded");116    require(!pool.settled && !pool.closed, "pool already finalized");117    require(merkleRoot != bytes32(0), "empty root");118 119    pool.merkleRoot = merkleRoot;120    pool.settled = true;121    pool.settledAt = uint64(block.timestamp);122 123    emit PoolSettled(poolId, merkleRoot);124}

Only the settler can call it, only once per pool, and only on a pool that was funded and isn't closed.

To claim, you send your amount and a proof (a few hashes Basin gives you) that your line is in the settled list. This is the whole check:

187function _claim(bytes32 poolId, address account, uint256 amount, bytes32[] calldata proof) internal {188    Pool storage pool = pools[poolId];189    require(pool.settled && !pool.closed, "pool not claimable");190    require(!claimed[poolId][account], "already claimed");191 192    // Matches @openzeppelin/merkle-tree's StandardMerkleTree leaf encoding193    // for ["address", "uint256"] — the settlement job builds the tree with194    // that library, so the two can't drift apart.195    bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(account, amount))));196    require(MerkleProof.verify(proof, pool.merkleRoot, leaf), "invalid proof");197    require(pool.totalClaimed + amount <= pool.totalDeposited, "exceeds pool");198 199    claimed[poolId][account] = true;200    pool.totalClaimed += amount;201    _send(pool.token, account, amount);202 203    emit Claimed(poolId, account, amount);204}

• Your line binds your address to your amount, so nobody can claim your share, and you can't claim a different amount.
• It's marked claimed before the tokens move, in the same transaction, so claiming twice is impossible, even with two transactions racing.
• A pool can't pay out more than it holds, even if a bad list promised more.

Basin pays the gas for claims by calling claimFor on your behalf. The tokens still go to you: the proof is for your address, so whoever sends the transaction can't redirect it.

163/// @notice Claim on someone's behalf. Funds always go to `account` — the164/// leaf binds amount to address — so a relayer can trigger payouts but can165/// never redirect them. Lets Basin run "auto-claim" without custody.166function claimFor(bytes32 poolId, address account, uint256 amount, bytes32[] calldata proof)167    external168    nonReentrant169{170    _claim(poolId, account, amount, proof);171}

There are three ways money goes back to the person who funded a pool, and it can only ever go to them:

139/// @notice Funder escape hatch: reclaim a pool the settler never settled.140function reclaimStale(bytes32 poolId) external nonReentrant {141    Pool storage pool = pools[poolId];142    require(msg.sender == pool.funder, "only funder");143    require(!pool.settled && !pool.closed, "pool already finalized");144    require(block.timestamp >= uint256(pool.fundedAt) + STALE_AFTER, "not stale yet");145 146    pool.closed = true;147    uint256 amount = pool.totalDeposited;148    _send(pool.token, pool.funder, amount);149 150    emit PoolRefunded(poolId, pool.funder, amount);151}

173/// @notice After the claim window, return everything unclaimed (and rounding174/// dust) to the funder. Callable by anyone; funds can only go to the funder.175function sweepUnclaimed(bytes32 poolId) external nonReentrant {176    Pool storage pool = pools[poolId];177    require(pool.settled && !pool.closed, "not sweepable");178    require(block.timestamp >= uint256(pool.settledAt) + CLAIM_WINDOW, "claim window open");179 180    pool.closed = true;181    uint256 remaining = pool.totalDeposited - pool.totalClaimed;182    if (remaining > 0) _send(pool.token, pool.funder, remaining);183 184    emit UnclaimedSwept(poolId, pool.funder, remaining);185}

reclaimStale is the escape hatch: if Basin disappeared tomorrow, every unsettled pool could still be taken back by its funder, straight from the contract.

Two keys have any special power, and each can do exactly one kind of thing:

71/// @notice Owner only: replace the settler (e.g. after its key leaks).72function setSettler(address newSettler) external onlyOwner {73    _setSettler(newSettler);74}

The owner can't give up ownership. That's deliberate: with no owner, a leaked settler key could never be replaced.

153/// @notice Disabled: with no owner, a leaked settler key could never be replaced.154function renounceOwnership() public view override onlyOwner {155    revert("renounce disabled");156}

The contract has a test suite that runs against it with Foundry. Beyond ordinary tests, it checks that:

• each earner is paid exactly their share, and a second claim fails;
• a proof for one person, or from another pool, doesn't work for anyone else;
• random wrong amounts (1,000 tries each run) are always rejected;
• a bad list can't pay out more than was deposited;
• only the settler can settle or refund, and the owner can't do either;
• the escape hatches, refunds, and sweeps only ever pay the funder.

It also runs invariant tests: thousands of random sequences of funding, settling, claiming, refunding, sweeping, and time passing, with these two rules checked after every single step:

138/// Solvency + no leakage: the escrow holds exactly what open pools still139/// owe. Never less (insolvent / drained), never more (funds stuck).140function invariant_balanceEqualsOutstanding() public view {141    uint256 outstanding;142    for (uint256 i; i < handler.poolCount(); i++) {143        (, , uint256 deposited, uint256 claimedAmt, , , , , bool closed) = escrow.pools(handler.poolIds(i));144        assertLe(claimedAmt, deposited, "claimed more than deposited");145        if (!closed) outstanding += deposited - claimedAmt;146    }147    assertEq(token.balanceOf(address(escrow)), outstanding);148}

150/// Money only ever goes to the funder or the two leaf accounts.151function invariant_noThirdPartyReceivesFunds() public view {152    assertEq(token.balanceOf(address(handler)), 0);153    assertEq(token.balanceOf(handler.owner()), 0);154    assertEq(155        token.balanceOf(handler.funder()) + token.balanceOf(handler.alice()) + token.balanceOf(handler.bob())156            + token.balanceOf(address(escrow)),157        type(uint128).max158    );159}

Pools are keyed by a bytes32 id. A post's own pool uses the hash of the post's id (the id in basin.social/post/<id>). Boosts and referral payouts each get their own, so one post can hold many pools.

/** On-chain pool key for a post's own (author) pool. Derived from the post id. */export function poolIdFor(postId: string): `0x${string}` {  return keccak256(toHex(postId));} /** On-chain key for a boost: its own pool row id, so a post can hold many pools. */export function boostPoolIdFor(poolRowId: string): `0x${string}` {  return keccak256(toHex(`boost:${poolRowId}`));} /** A weekly referral payout pool's id on-chain (one per payout). */export function referralPoolIdFor(poolRowId: string): `0x${string}` {  return keccak256(toHex(`referral:${poolRowId}`));}

Everything is public, so you can read any pool straight from the chain. No Basin API is needed. This uses viem:

import { createPublicClient, defineChain, http, keccak256, parseAbi, toHex } from "viem"; const chain = defineChain({  id: 4663,  name: "Robinhood Chain",  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },  rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } },});const client = createPublicClient({ chain, transport: http() }); const ESCROW = "0x1fC0FB0dCCe88E3da5A52A045ED1b5e7801C02ED";const abi = parseAbi([  "function pools(bytes32 poolId) view returns (address token, address funder, uint256 totalDeposited, uint256 totalClaimed, bytes32 merkleRoot, uint64 fundedAt, uint64 settledAt, bool settled, bool closed)",  "function claimed(bytes32 poolId, address account) view returns (bool)",  "function settler() view returns (address)",  "function owner() view returns (address)",]); // A post's own pool: the hash of its id.const poolId = keccak256(toHex("POST_ID")); const [token, funder, deposited, claimedSoFar, root, fundedAt, settledAt, settled, closed] =  await client.readContract({ address: ESCROW, abi, functionName: "pools", args: [poolId] }); const stillInPool = closed ? 0n : deposited - claimedSoFar; // Has this wallet claimed its share yet?const done = await client.readContract({  address: ESCROW, abi, functionName: "claimed", args: [poolId, "0xYourWallet"],});

settler() and owner() show which keys hold the two special powers right now.

Every change emits an event, so you can follow pools without trusting anyone's database:

55event PoolFunded(bytes32 indexed poolId, address indexed funder, address token, uint256 amount);56event PoolSettled(bytes32 indexed poolId, bytes32 merkleRoot);57event PoolRefunded(bytes32 indexed poolId, address indexed funder, uint256 amount);58event Claimed(bytes32 indexed poolId, address indexed account, uint256 amount);59event UnclaimedSwept(bytes32 indexed poolId, address indexed funder, uint256 amount);60event SettlerChanged(address indexed previousSettler, address indexed newSettler);

For example, every claim a wallet has made. The contract was deployed in block 75,982,716, so there's nothing to read before it. The public RPC times out on wide ranges, so read in chunks of a few thousand blocks.

import { parseAbiItem } from "viem"; const logs = await client.getLogs({  address: ESCROW,  event: parseAbiItem("event Claimed(bytes32 indexed poolId, address indexed account, uint256 amount)"),  args: { account: "0xYourWallet" },  fromBlock: 75982716n,  toBlock: 75987716n, // then the next chunk…});

When a call is refused, the transaction reverts with one of these messages:

• Basin will never ask for your password, seed phrase, or private key.
• Only trust $BASIN at the token address above.
• Pool amounts are set by posters. A pool is a reward, not an investment.

See also the Terms and Privacy Policy.