Partner Integration

If you run a deploy panel, sniping bot, Telegram client, or anything else that brings users to Stroid, you can earn a share of every swap fee on the tokens you launch. The launchpad records a partner address next to each token at launch, and from then on a configurable cut of every swap fee on that token routes to your wallet — automatically, forever.

Becoming a partner

There is no on-chain self-registration. You cannot make yourself a partner by sending a transaction; the launchpad won't recognise you and your attributed launches will earn nothing.

To get set up, contact the Stroid team on Telegram: t.me/stroidfun. Once approved, the team will register your wallet on-chain through the multisig, after which every token you launch under that wallet starts earning you protocol fees on the very next swap.

Things to know before reaching out:

• Your share is configured at registration time. The Stroid team will discuss the rate with you when you sign up.

Attributing a launch

Once your wallet is registered, attribution is trivial: pass it as the partner field in LaunchOpts when calling launchStroidDotFun. That's it. From that moment on the token routes a slice of every swap fee to you.

const opts = {
  creatorRecipients: [],
  customFeeBps:  0,
  partner:       '0xYourPartnerWallet…',   // ← attribution
  sqrtPriceTier: 0,
};

await walletClient.writeContract({
  address: LAUNCHPAD,
  abi: LAUNCHPAD_ABI,
  functionName: 'launchStroidDotFun',
  args: [name, symbol, metadataURI, salt, opts],
  value: creationFee + devBuy,
});

What if the launcher doesn't want to set a partner?

You still have to pass the partner field — Solidity doesn't let you omit struct fields, so every key on LaunchOpts is mandatory in the call regardless of whether you're using that feature. The way you say "no partner" is to pass the zero address:

partner: '0x0000000000000000000000000000000000000000'

The launch goes through normally and the swap fees that would've gone to a partner just stay in the protocol slice. This is exactly what every regular launch on stroid.fun/create does by default.

Same rule for the other LaunchOpts fields. creatorRecipients, customFeeBps, and sqrtPriceTier are also required by Solidity — you cannot omit them, period. If you don't want to use one of those features, pass its "do nothing" value:

• creatorRecipients: [] → empty array. 100% of the creator share goes to whoever sent the launch tx
• customFeeBps: 0 → required to be 0. The custom-fee feature is disabled at the protocol level, so any non-zero value reverts the launch transaction. Every launch uses the global tier schedule.
• sqrtPriceTier: 0 → default ~1 ETH virtual LP starting liquidity

So the absolute-minimum "I just want a token, no partner, no custom anything" opts — with every required field present — is:

const opts = {
  creatorRecipients: [],
  customFeeBps:  0,
  partner:       '0x0000000000000000000000000000000000000000',
  sqrtPriceTier: 0,
};

Checking what you can claim

Your earnings sit on the fee hook as a single ETH balance — one number across every token you've ever launched under your wallet. To check it, read ethOwed(yourPartnerWallet):

const owed = await publicClient.readContract({
  address: FEEHOOK_V3,
  abi: ABI,
  functionName: 'ethOwed',
  args: [yourPartnerWallet],
});
console.log('claimable:', owed, 'wei');

The number bumps up automatically inside every swap on every token you've launched — you don't need to scan logs or loop over tokens, it's just one balance.

Claiming

Send a single claim() tx from your partner wallet:

to     = FEEHOOK_V3  (0x0d62529346ac2c61f5c0582210D01214687bc0CC)
value  = 0
data   = selector(claim())
chainId = 1

It transfers your full claimable balance to the calling wallet, resets the balance to 0, and you're done. Reverts with nothing to claim if the balance is 0.

Worked example (viem)

import {
  createPublicClient,
  createWalletClient,
  defineChain,
  http,
} from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

const mainnet = defineChain({
  id: 1,
  name: 'Ethereum',
  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
  rpcUrls: { default: { http: ['https://eth.llamarpc.com'] } },
});

const publicClient = createPublicClient({ chain: mainnet, transport: http() });
const account = privateKeyToAccount(process.env.PARTNER_PRIVATE_KEY as `0x${string}`);
const walletClient = createWalletClient({ account, chain: mainnet, transport: http() });

const FEEHOOK = '0x0d62529346ac2c61f5c0582210D01214687bc0CC' as const;

const ABI = [
  {
    name: 'ethOwed',
    type: 'function',
    stateMutability: 'view',
    inputs: [{ name: 'who', type: 'address' }],
    outputs: [{ name: '', type: 'uint256' }],
  },
  {
    name: 'claim',
    type: 'function',
    stateMutability: 'nonpayable',
    inputs: [],
    outputs: [{ name: 'amount', type: 'uint256' }],
  },
] as const;

// 1. Read what you can claim.
const owed = await publicClient.readContract({
  address: FEEHOOK,
  abi: ABI,
  functionName: 'ethOwed',
  args: [account.address],
});
console.log('claimable:', owed, 'wei');

if (owed === 0n) {
  console.log('nothing to claim yet');
  return;
}

// 2. Claim it.
const hash = await walletClient.writeContract({
  address: FEEHOOK,
  abi: ABI,
  functionName: 'claim',
});
const receipt = await publicClient.waitForTransactionReceipt({ hash });
console.log('claimed in block', receipt.blockNumber);

In-app shortcut

You don't have to wire any of this yourself. Open Claim Partner Fees, connect your partner wallet, and it shows your claimable balance and sends the claim transaction through your wallet — done.

ABI fragment

[
  {
    "name": "ethOwed",
    "type": "function",
    "stateMutability": "view",
    "inputs": [{ "name": "who", "type": "address" }],
    "outputs": [{ "name": "", "type": "uint256" }]
  },
  {
    "name": "claim",
    "type": "function",
    "stateMutability": "nonpayable",
    "inputs": [],
    "outputs": [{ "name": "amount", "type": "uint256" }]
  }
]

Common issues