Events

What to index, and where it comes from.

Factory#

`TokenLaunched`#

Deployed today — legacy signature#

As checked on 10 September 2026, the factories on both mainnet and Sepolia emit the signature below. There is no feeShare field in these logs.

event TokenLaunched(
    string name,
    string uri,
    string symbol,
    address indexed curve,
    address indexed token,
    uint256 targetRaise,
    address quoteToken,
    address creator,
    IInkCurve.BondingCurve curveState
);

Upcoming creator-fee contracts — not deployed#

The creator-fee upgrade adds an indexed feeShare address:

event TokenLaunched(
    string name,
    string uri,
    string symbol,
    address indexed curve,
    address indexed token,
    uint256 targetRaise,
    address quoteToken,
    address creator,
    IInkCurve.BondingCurve curveState,
    address indexed feeShare
);

In this upgraded signature, feeShare is address(0) when the launch configured no split. Neither network has executed the upgrade yet, but Sepolia has it queued and will switch signatures before mainnet does — so an indexer covering both needs the legacy and upgraded topics live at the same time.

Adding this field changes topic 0, even though the event name is unchanged. An indexer filtering only the upgraded signature misses legacy launches. Keep both signatures when backfilling across an upgrade, and decode according to the topic. factoryAbi in SDK 0.2.0 describes the upgraded event; for legacy logs, define the legacy event explicitly. launchedFrom(hashOrReceipt) already handles both signatures, but does not provide an event subscription.

For example, subscribe to the currently deployed legacy event:

import { parseAbi } from "viem";

const legacyLaunchAbi = parseAbi([
  "struct BondingCurve { uint256 realBaseReserves; uint256 realQuoteReserves; uint256 virtualBaseReserves; uint256 virtualQuoteReserves; }",
  "event TokenLaunched(string name, string uri, string symbol, address indexed curve, address indexed token, uint256 targetRaise, address quoteToken, address creator, BondingCurve curveState)",
]);

const unwatch = publicClient.watchContractEvent({
  address: FACTORY,
  abi: legacyLaunchAbi,
  eventName: "TokenLaunched",
  onLogs: (logs) => {
    for (const log of logs) console.log(log.args.token, log.args.curve);
  },
});

`PoolCreated`#

event PoolCreated(address indexed token, bytes32 indexed poolId, uint160 sqrtPriceX96);

Emitted at launch, when the pool key is reserved — long before it holds liquidity.

Configuration#

Event	Emitted by
`PlatformFeeUpdated(uint256 newFee)`	Legacy `setPlatformFee` — no timelock
`PlatformFeeUpdated(uint256 newFee, uint256 feeSharePercent)`	Upcoming creator-fee `setPlatformFee` — no timelock; different topic from legacy
`PlatformFeeWalletUpdated(address newWallet)`	`setPlatformFeeWallet` — after a 2-day notice
`PlatformFeeWalletChangeProposed(address newWallet, uint256 executableAt)`	The proposal that starts that notice
`HookUpdated(address newHook)`	`setHook`
`HookChangeProposed(address newHook, uint256 executableAt)`	The proposal
`CurrencyAdded(address currency, uint256 maxRaise)`	A quote asset enabled
`CurrencyRemoved(address currency)`	A quote asset disabled
`CurveImplementationUpgraded(address newImplementation)`	Beacon upgrade executed
`CurveUpgradeProposed(address newImplementation, uint256 executableAt)`	Beacon upgrade queued
`FactoryUpgradeProposed(address newImplementation, uint256 executableAt)`	Factory upgrade queued
`Upgraded(address indexed implementation)`	Factory upgrade executed (ERC-1967)
`Paused(address)` / `Unpaused(address)`	Launches blocked / unblocked

A queued change can also be withdrawn, and each proposal has a matching cancel:

Event	Meaning
`FactoryUpgradeCancelled(address newImplementation)`	A queued factory upgrade was dropped
`CurveUpgradeCancelled(address newImplementation)`	A queued beacon upgrade was dropped
`HookChangeCancelled(address newHook)`	A queued hook change was dropped
`PlatformFeeWalletChangeCancelled(address newWallet)`	A queued fee-wallet change was dropped

The …Proposed events are the useful ones for anyone who wants warning before a change lands. Each carries executableAt, a Unix timestamp.

For "is anything queued right now?", read the state instead of replaying logs — these getters are the authoritative answer and cost one call each:

const factoryAbi = parseAbi([
  "function pendingFactoryUpgrade() view returns (address, uint256)",
  "function pendingCurveUpgrade() view returns (address, uint256)",
  "function pendingHook() view returns (address, uint256)",
  "function pendingPlatformFeeWallet() view returns (address, uint256)",
]);

Each returns the proposed value and its executableAt, zeroed when nothing is queued.

Curve#

`TokenBought` / `TokenSold`#

event TokenBought(
    uint256 indexed amount, address indexed buyer,
    uint256 amountOut, uint256 timestamp, BondingCurve curve
);

event TokenSold(
    uint256 indexed amount, address indexed buyer,
    uint256 amountOut, uint256 timestamp, BondingCurve curve
);

Both carry the full post-trade curve state, so an indexer can track reserves and price without re-reading the contract after every trade.

For TokenBought, amount is the gross quote actually spent — which is less than what the buyer offered when the buy was capped.

`TokenMigrated`#

event TokenMigrated(
    address indexed token,
    address indexed hook,
    PoolKey poolKey,
    uint256 quoteRaised,
    uint256 baseForPool,
    uint256 timestamp,
    BondingCurve curve
);

The curve has closed and seeded its pool. Carries the whole pool key, so a consumer can address the pool from this event alone.

Fee delivery#

Event	Meaning
`FeePaymentDeferred(address indexed recipient, uint256 amount)`	A fee push failed; booked as claimable rather than reverting the trade
`FeesWithdrawn(address indexed recipient, address indexed to, uint256 amount)`	A deferred balance was claimed
`DustSwept(address indexed to, uint256 baseAmount, uint256 quoteAmount)`	Donated balance forwarded at migration
`PoolSeeded(address indexed token, bytes32 indexed poolId, uint160 sqrtPriceX96, uint256 amount0, uint256 amount1)`	The pool has been created and funded. `poolId` is `keccak256` of the pool key — the only identifier a v4 pool has
`PoolKeyUnresolved(address indexed token)`	Declared for the case where the factory cannot resolve the key at migration, so `TokenMigrated` carries a zeroed one. No path in the deployed curve emits it; treat it as reserved

Hook#

Deployed today#

As checked on 10 September 2026, the hooks on both networks emit exactly these three. Note that none of them carries a curve — the hook accounts per currency, not per launch.

event SwapFeeAccrued(address indexed currency, uint256 amount);
event FeesSwept(address indexed recipient, address indexed currency, uint256 amount);
event PoolLpFeeUpdated(bytes32 indexed poolId, uint24 newFee);

Event	Meaning
`SwapFeeAccrued`	A swap fee was taken and is being held. Not paid yet.
`FeesSwept`	A `sweep(currency)` sent the hook's whole balance of that currency to the platform fee wallet
`PoolLpFeeUpdated`	A pool's dynamic LP fee changed

Upcoming creator-fee hook — not deployed#

The creator-fee upgrade replaces the hook. Its events add the curve and split the sweep, and every one of them is a different topic 0 from the versions above:

event SwapFeeAccrued(Currency indexed currency, address indexed curve, uint256 amount);

event FeesSwept(
    address indexed recipient,
    Currency indexed currency,
    address indexed curve,
    uint256 platformFee,
    uint256 creatorFee
);

event PlatformSweepDeferred(
    address indexed recipient, Currency indexed currency, address indexed curve, uint256 amount
);

event SwapFeeUpdated(uint256 newFee);

The indexed markers are load-bearing for a consumer even though they do not affect topic 0 — that hash covers the parameter types alone. They decide which arguments arrive as topics and which as data, so a parseAbi definition that drops them decodes the right event into the wrong fields. SwapFeeAccrued, FeesSwept and PlatformSweepDeferred each index three parameters here, which is the ceiling — a fourth is not possible alongside topic 0 — while the deployed hook indexes one and two respectively.

Currency is a value type over address, so it is plain address in the ABI and in a parseAbi string; only internalType preserves the name.

The hook is swapped by pointer, not upgraded in place, so its address changes too — watch HookUpdated on the factory and switch decoders on the log's own address and topic rather than on a block height.

FeeShare#

Upcoming creator-fee contracts — not deployed on either network as of 10 September 2026. These events apply only to launches with a FeeShare after that upgrade. See Availability.

Event	Meaning
`FeesSynced(uint256 amount, uint256 totalClaimable, address currency)`	Quote arrived and was credited across the split
`FeesClaimed(address receiver, uint256 amount, address currency)`	A claimer withdrew
`FeeShareConfigUpdated(FeeShareConfig[] config)`	The split was replaced
`FeeShareHookChanged(address newHook)`	The accepted fee source changed

FeesSynced reports what was actually distributed, which can be a few wei below the amount delivered — each claimer's share rounds down, and the remainder stays in the contract rather than being revisited.

Watching a launch, end to end#

import { parseAbiItem } from "viem";

const unwatch = publicClient.watchEvent({
  address: curve,
  event: parseAbiItem(
    "event TokenBought(uint256 indexed amount, address indexed buyer, " +
    "uint256 amountOut, uint256 timestamp, " +
    "(uint256,uint256,uint256,uint256) curve)"
  ),
  onLogs: (logs) => {
    for (const log of logs) {
      const [realBase] = log.args.curve!;
      if (realBase === 0n) console.log("migrating");
    }
  },
});

Or use the exported ABIs instead of hand-written signatures:

import { curveAbi } from "@tidepool-launchpad/sdk";

publicClient.watchContractEvent({ address: curve, abi: curveAbi, eventName: "TokenBought", onLogs });