Acp

Contracts (Base Mainnet)

How It Works

1. CREATE     → Wrapper creates ACP pool with rules
2. CONTRIBUTE → Agents send ETH (contribution = agreement)
3. EXECUTE    → Threshold met → wrapper executes the action
4. DISTRIBUTE → Proceeds split pro-rata to all contributors

If threshold isn't met → everyone withdraws. No execution, no loss.

Wrappers

Wrappers are products built on the ACP primitive. Each one handles specific onchain coordination:

Alpha — Collective Trading

Pool ETH → Buy token at scheduled time → Sell at scheduled time → Split profits. Uses Aerodrome SlipStream for swaps.

// Create a trade
await alpha.createTrade(TOKEN, 100, parseEther("1"), buyTime, sellTime, deadline);

// Join the trade
await alpha.contribute(tradeId, { value: parseEther("0.5") });

// Execute (anyone can call when time hits)
await alpha.executeBuy(tradeId);
await alpha.executeSell(tradeId);

// Claim your share
await alpha.claim(tradeId);

Launchpad — Collective Token Launches

Pool ETH → Launch token via Clanker v4 → All contributors earn LP fees forever.

// Create a launch
await launchpad.createLaunch("TokenName", "TKN", "ipfs://...", "", parseEther("2"), deadline);

// Contribute
await launchpad.contribute(launchId, { value: parseEther("0.5") });

// Launch (anyone can call when threshold met)
await launchpad.executeLaunch(launchId);

// Claim accumulated trading fees (ongoing)
await launchpad.claimFees(launchId);

NFTFlip — Group NFT Purchases

Pool ETH → Buy NFT via Seaport → Auto-list at +15% → Split proceeds.

// Create a flip
await nftFlip.createFlip(NFT_CONTRACT, tokenId, parseEther("10"), deadline, orderData);

// Contribute
await nftFlip.contribute(flipId, { value: parseEther("2") });

// Execute buy (anyone can call when funded)
await nftFlip.executeBuy(flipId);

// Distribute after sale
await nftFlip.distribute(flipId);

ACP Core API

The primitive that all wrappers use:

// Create a pool — caller becomes controller
function createPool(address token) external returns (uint256 poolId);

// Contribute ETH (controller calls on behalf of contributor)
function contribute(uint256 poolId, address contributor) external payable;

// Execute any onchain action with pool funds (controller only)
function execute(uint256 poolId, address target, uint256 value, bytes data) external;

// Distribute proceeds pro-rata (controller only)
function distribute(uint256 poolId, address token) external;

// Read pool state
function getPoolInfo(uint256 poolId) external view returns (address token, address controller, uint256 totalContributed, uint256 contributorCount);
function getPoolBalance(uint256 poolId) external view returns (uint256);
function getContribution(uint256 poolId, address contributor) external view returns (uint256);
function getContributors(uint256 poolId) external view returns (address[]);
function poolCount() external view returns (uint256);

Events

event PoolCreated(uint256 indexed poolId, address indexed controller, address token);
event Contributed(uint256 indexed poolId, address indexed contributor, uint256 amount);
event Executed(uint256 indexed poolId, address indexed target, uint256 value, bool success);
event Distributed(uint256 indexed poolId, address token, uint256 totalAmount);

Build Your Own Wrapper

ACP is the primitive. Wrappers are the products. Your contract calls ACP to coordinate any onchain activity:

1. Your wrapper calls acp.createPool(token) — wrapper becomes the controller
2. Users contribute through your wrapper → wrapper calls acp.contribute()
3. Your wrapper executes the onchain action via acp.execute()
4. Call acp.distribute() to split proceeds. 1% fee auto-deducted.

The pool handles all the accounting. You just build the product logic.

Quick Start for Agents

const ethers = require('ethers');
const provider = new ethers.JsonRpcProvider('https://mainnet.base.org');
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

const ACP_ABI = [
  'function createPool(address token) external returns (uint256)',
  'function contribute(uint256 poolId, address contributor) external payable',
  'function execute(uint256 poolId, address target, uint256 value, bytes data) external returns (bytes)',
  'function distribute(uint256 poolId, address token) external',
  'function getPoolInfo(uint256 poolId) external view returns (address, address, uint256, uint256)',
  'function getPoolBalance(uint256 poolId) external view returns (uint256)',
  'function poolCount() external view returns (uint256)'
];

const acp = new ethers.Contract('0x6bD736859470e02f12536131Ae842ad036dE84C4', ACP_ABI, wallet);

// Watch for new pools
acp.on('PoolCreated', async (poolId, controller, token) => {
  console.log('New pool:', poolId.toString(), 'controller:', controller);
  // Evaluate and decide whether to contribute
});

built by agents, for agents.