How onchain token buyback pools work

01 / THE BASICS

How a pool works

Two different assets: the project token is what participants deposit; the payment asset is what they receive. The pool does not buy from a DEX or guarantee a market price.

The pool list and totals cover all live networks. Use the list's chain filter to narrow the results. The top-right network selector controls your wallet, not which pools you can browse. Each pool belongs to its own chain; a mismatched wallet shows a switch-network prompt, and transactions require the pool's network. Connecting a wallet alone never switches networks or sends a transaction.

02 / PROJECT TEAMS

Create and fund a pool

1. Choose the project token holders will deposit and the payment asset they will receive. You can use supported shortcuts or enter token contract addresses.
2. Enter the advertised net buyback budget. The Factory collects a gross payment that covers this budget and the effective fee for the payment asset and buyback target. At 5%, a 1,000 USDG net budget requires about 1,052.631579 USDG gross. On RH, paying with BBC or buying BBC currently has a 0% fee; BSC has no BBC policy. Native network gas is separate.
3. Choose the participation window (at most 24 hours), optional per-wallet minimum and maximum, and whether purchased project tokens go back to you or to the burn address after close. These pool settings cannot be changed later.
4. Review token addresses, approvals and wallet prompts. Once the creation transaction confirms, share the pool link with holders.

On V3.8 and newer pools, each addition independently chooses whether its purchased-token share goes to the burn address. The default is off, regardless of the original pool setting. This choice cannot be changed after funding; non-burning funders retain token-claim rights indefinitely. If nobody participates, all recorded funders may claim their share of the unused net payment budget. Use the funding action: ordinary transfers do not record funders or burn choices.

On RH and BSC V3.10, choose whether anyone can add funding (default) or only the pool creator. This rule cannot change after creation and does not restrict selling into the pool or claiming. Historical pools keep their original rules.

Check transfer behavior first. Tokens that charge transfer fees, rebase, pause transfers or restrict recipients may not work as expected. Test with a small pool before committing a larger budget.

03 / TOKEN HOLDERS

Participate and claim

1. Open a live pool on the selected Robinhood Chain or BNB Smart Chain network. Verify the project token address, payment asset, budget, deadline and wallet limits. A completed pool no longer accepts deposits.
2. Connect your wallet and enter the amount. ERC-20 tokens may require approval before depositing. New native ETH (RH) and BNB (BSC) target pools accept a direct deposit without token approval; use the pool's deposit action, not an ordinary wallet transfer.
3. Confirm the deposit. Your estimated share may change as other wallets participate; the final payout is determined only after the pool closes.
4. After close, return to the pool detail page and claim with the same wallet. You can claim once; there is no need to wait for every other participant.

Deposits cannot be cancelled or withdrawn. Do not participate unless you understand the token you are handing over and the payment asset you will receive. Keep enough native ETH (RH) or BNB (BSC) for approval, deposit and claim gas.

04 / READING THE INTERFACE

Prices, status and data

Buyback price

Budget divided by total project tokens deposited. It is an estimate while deposits are open; the final average is known only at close. If nobody deposits, no price is formed.

Vs. market

Compares the estimated or final buyback price with a current DEX market snapshot, not the price when the pool opened or closed. The comparison may move after a pool ends and is hidden when reliable market data is unavailable.

Pool status

Scheduled pools have not opened; live pools accept deposits until the end time; completed pools accept claims, not new deposits. An ended pool may still have unclaimed payouts.

Participant data

Pool totals and wallet activity come from onchain events and a read-only index. A newly confirmed transaction may take a short time to appear; contract state controls what you can actually claim.

Market comparisons are informational only. They are not an execution quote, guaranteed return or investment recommendation.

Use Buyback with an AI agent

For read-only pool lookup, give an agent that can open public URLs the public pool overview. It covers Robinhood Chain and BNB Smart Chain without a wallet, account or API key.

Read https://buyback.cafe/api/v1/overview and list the live BNB Smart Chain Buyback pools. Include each deposit-token contract address, payment asset, budget, deadline and pool link. Do not initiate a transaction.

In the response, networks[] identifies each chain. A pool's buyToken is the token participants deposit; payToken is the asset they may receive. Use effectiveRewardAmount for its current budget and start/end for timing. Amounts use token base units; verify the asset's decimals for that chain before showing a human-readable amount, or label the raw value as base units. Check each network's ready and indexedAtBlock/lastSuccessAt, plus the top-level partial flag. The index may trail onchain transactions.

Agent instructions on GitHub provide reusable field definitions and pool links. The repository also has an optional BSC adapter for preparing unsigned deposit and claim calls. Publishing these instructions does not add Buyback to Binance AI's built-in tools. Verify live contract state and obtain the wallet owner's confirmation before any transaction.

Network availability

Robinhood Chain and BNB Smart Chain are live on V3.10.0. Each chain has separate contracts and indexes. New pools can buy back native ETH on RH or native BNB on BSC. Historical pools keep their original rules. X Layer, Base, Ethereum and Arc remain unavailable until their deployments are verified.

Arc amount precision: Arc's native gas asset is USDC with 18 decimals. The bridged ERC-20 USDC at 0x3600000000000000000000000000000000000000 uses 6 decimals. Integrations must never treat them as the same asset representation.

Buyback Factories · V3.10.0

BSC Factory: 0x8ed655c529004E7db3F46304140e5880aC09991B (chain 56). BSC uses BNB for gas and has no BBC or voting deployment. Both Factory entry addresses are upgradeable; existing pools remain immutable. The following details and code examples use RH unless specified.

Chain ID

4663

Factory contract

0x3CF0cFAda3a3CdE38Cb622fEf8923a5f71a86C9C

Explorer

View contract ↗

Contract release

3.10.0 on RH and BSC. Protocol generation remains V3 and both Factory addresses are unchanged. Earlier pools retain their original contracts and claim rules. Mainnet small-value acceptance remains pending; the contracts have not received an independent third-party audit.

Platform fee

Default 5%, configurable by the official administrator from 0–5% per payment asset or target token, including timed discounts. New ordinary pools use the lower rate. On RH, paying with BBC or buying BBC currently pays 0%. Read effectiveBuybackFeeBps(paymentToken, buybackToken) and feeForBuyback(paymentToken, buybackToken, grossAmount); participants pay no additional platform claim fee.

Fee-funded buybacks

50% of protocol fees actually collected is designated for treasury buybacks. At the default 5% fee, that equals 2.5% of gross funding (about 2.63% of the net pool budget); a discounted or 0% fee produces a smaller amount or none. The Factory sends the full fee to feeRecipient: it does not split the fee or execute this treasury buyback automatically. A separate treasury transaction is required.

Maximum duration

24 hours (86,400 seconds), enforced by the Factory.

Creation flow

1. Connect

   Connect to Robinhood Chain, use the Factory address above and check paused() == false.

2. Choose assets

   Choose separate payment and project-token addresses. Read token decimals and convert all amounts to base units. For a native target on V3.9, use buybackToken = ZeroAddress and 18 decimals. Native payment plus native target, or wrapped-native payment plus native target, is rejected.

3. Set the window

   Set a budget, per-wallet minimum/maximum (use 0 for no limit), and a time window of no more than 24 hours. The pool opens at startTime; for prompt creation, use the latest chain timestamp plus a short confirmation margin.

4. Calculate funding

   Choose the gross payment amount, including the fee. Call feeForBuyback(paymentToken, buybackToken, grossAmount); the new pool's initial seller budget is gross minus fee. For an ERC-20 payment, approve the Factory for the gross amount. Native ETH or BNB payment uses paymentToken = ZeroAddress.

5. Create the pool

   Call createContributorPool(config, quotedFee, allowPublicFunding); config.rewardAmount is the gross amount. Use true to permit public additions. Native ETH or BNB payment requires exactly that gross amount as transaction value. The quoted fee is a transaction ceiling; re-quote if the fee changes before confirmation.

6. Record the result

   Wait for confirmation, decode PoolCreated, and save the emitted pool address. Use your own idempotency key so retries do not create duplicate funded pools.

Burn choice is permanent for each contribution. On V3.8 and newer pools, the creator chooses for the initial funding and each later funder chooses separately, with burning off by default for additions. A burning share goes to 0x000000000000000000000000000000000000dEaD after close; other funders may claim their shares. Burning does not necessarily reduce ERC-20 totalSupply.

Call from a partner contract

The live Factory is permissionless for pool creation: an EOA or another smart contract may call its public creation methods directly. There is no partner whitelist, account or API key. The Factory can be paused for new pools by its owner; already-created pools retain their own rules.

The immediate caller becomes the creator and first funder. If your contract calls the Factory, the pool records your contract, not its caller. Purchased-token and empty-pool refund claims accrue to that contract. It must expose authorized recovery functions and be able to receive native ETH when appropriate.

The same caller rule applies to participation. If an adapter contract calls a pool's deposit, the pool credits that adapter address; claim pays the adapter, and per-wallet limits apply to the adapter as one wallet. For individual holder records and claims, have each holder call the pool directly. An adapter that deposits for others must implement and secure its own internal accounting and payout logic.

For scheduled or threshold-based campaigns, your contract or offchain automation decides when to submit creation. Buyback does not custody partner signing keys or run partner triggers. Use a unique campaign ID, explicit spending controls and an event-based confirmation record so retries do not fund duplicate pools.

Embed a pool in your product

The read-only card shows the onchain-funded budget, token, status and participant count. Replace POOL_ADDRESS with the address from PoolCreated. Clicking the card's button opens the official pool page; your site never handles participant transactions.

<iframe
  title="Buyback pool"
  src="https://buyback.cafe/embed/pool?address=POOL_ADDRESS"
  width="420" height="270" loading="lazy"
  style="max-width:100%;border:0"
></iframe>

Only the card route permits embedding on HTTPS sites. Pool data comes from the public read-only indexer and refreshes automatically. Your product can also link directly to https://buyback.cafe/pool?address=POOL_ADDRESS.

Scheduled starts and triggers

To fund a pool now and open participation later, pass a future startTime. The Factory transfers the net budget and fee at creation; the pool accepts deposits only from its start time. Funders may add payment before endTime. The window must remain within 24 hours.

To fund a pool later, create recurring pools, or start only when a treasury reaches a threshold, your own scheduler must check the condition and submit each creation transaction. Buyback does not currently host a funding-threshold rule engine or hold project signing keys. Use a dedicated funding source, spending caps, onchain balance rechecks and an idempotency key for each planned pool.

Minimal ethers v6 example

This RH example uses an ERC-20 buyback target and allows public funding. Pass in a signer from your own secure key manager. All amount arguments below are already converted to token base units (bigint). For a native target, use the zero-address sentinel and check the wrapped-native restrictions described above.

import { Contract, ZeroAddress, getAddress } from "ethers";

const factoryAddress = "0x3CF0cFAda3a3CdE38Cb622fEf8923a5f71a86C9C";
const factoryAbi = [
  "function paused() view returns (bool)",
  "function feeForBuyback(address,address,uint256) view returns (uint256)",
  "function createContributorPool((address paymentToken,address buybackToken,uint256 rewardAmount,uint256 minPerWallet,uint256 maxPerWallet,uint64 startTime,uint64 endTime,bool burnPurchasedTokens) config,uint256 maxPlatformFee,bool allowPublicFunding) payable returns (uint256,address)",
  "event PoolCreated(uint256 indexed poolId,address indexed pool,address indexed creator,address paymentToken,bool nativePayment,address buybackToken,uint256 rewardAmount,uint256 platformFee,uint256 minPerWallet,uint256 maxPerWallet,uint64 startTime,uint64 endTime)"
];
const erc20Abi = [
  "function allowance(address,address) view returns (uint256)",
  "function approve(address,uint256) returns (bool)"
];

export async function createAutomatedBuyback({
  signer, paymentToken, buybackToken, grossAmount,
  minPerWallet = 0n, maxPerWallet = 0n,
  durationMinutes, startTime, burnPurchasedTokens = false
}) {
  const provider = signer.provider;
  if (!provider || (await provider.getNetwork()).chainId !== 4663n)
    throw Error("Connect a signer on Robinhood Chain");
  paymentToken = getAddress(paymentToken);
  buybackToken = getAddress(buybackToken);
  if (paymentToken === buybackToken || buybackToken === ZeroAddress)
    throw Error("Choose distinct payment and project tokens");
  if (grossAmount <= 0n || minPerWallet < 0n || maxPerWallet < 0n ||
      (maxPerWallet !== 0n && maxPerWallet < minPerWallet))
    throw Error("Invalid budget or wallet limits");
  if (!Number.isInteger(durationMinutes) || durationMinutes < 1 || durationMinutes > 1440)
    throw Error("Duration must be 1–1440 minutes");

  const factory = new Contract(factoryAddress, factoryAbi, signer);
  if (await factory.paused())
    throw Error("Buyback Factory is paused");
  const fee = await factory.feeForBuyback(paymentToken, buybackToken, grossAmount);
  if (fee >= grossAmount) throw Error("Gross amount must exceed the fee");
  if (paymentToken !== ZeroAddress) {
    const payment = new Contract(paymentToken, erc20Abi, signer);
    const owner = await signer.getAddress();
    if ((await payment.allowance(owner, factoryAddress)) < grossAmount)
      await (await payment.approve(factoryAddress, grossAmount)).wait();
  }
  const latest = await provider.getBlock("latest");
  const start = startTime === undefined ? latest.timestamp + 60 : Number(startTime);
  if (!Number.isSafeInteger(start) || start < latest.timestamp + 60)
    throw Error("Start time must allow at least 60 seconds for confirmation");
  const end = start + durationMinutes * 60;
  const config = [paymentToken, buybackToken, grossAmount,
    minPerWallet, maxPerWallet, start, end, burnPurchasedTokens];
  const tx = await factory[
    "createContributorPool((address,address,uint256,uint256,uint256,uint64,uint64,bool),uint256,bool)"
  ](
    config, fee, true, paymentToken === ZeroAddress ? { value: grossAmount } : {}
  );

  const receipt = await tx.wait();
  const created = receipt.logs
    .filter(log => log.address.toLowerCase() === factoryAddress.toLowerCase())
    .map(log => { try { return factory.interface.parseLog(log); } catch { return null; } })
    .find(event => event?.name === "PoolCreated");
  if (!created) throw Error("PoolCreated event missing; inspect transaction receipt");
  return { poolId: created.args.poolId, pool: created.args.pool,
    netBudget: grossAmount - fee, txHash: receipt.hash };
}

The automation wallet must hold the payment asset and native ETH for gas. Keep signing keys in a key manager or private deployment environment, never in source code or browser storage. Use a dedicated RPC with a fallback for production jobs.

After the pool closes

Participants claim payment in proportion to their deposited project tokens. Anyone may settle purchased tokens after close. If the pool is not burning them, each recorded funder then calls claimPurchasedTokens() for a gross-funding-weighted share. If nobody deposited project tokens, anyone can make the empty-pool refund available, then each funder calls claimEmptyPoolRefund().

Previously created pools keep their original rules. Factory upgrades do not change already-created pool contracts. The contracts have not been independently audited; start with a small pool and verify both token contracts before automating larger budgets.

06 / GOOD TO KNOW

Frequently asked questions

Risk boundary: the contracts have not been independently audited. Verify contract and token addresses, understand irreversible deposits and token-transfer restrictions, and start with a small amount.