Termination & Settlement

Every Bazaar market can be wound down without anyone’s permission: when its feed is decommissioned, its asset is delisted, or its price series breaks. This page covers the SDK side of that: reading where a market stands, proposing termination through UMA or an insurer vote, fixing the settlement price (including fetching and proving the archived Pyth Pro updates it needs), settling positions, finalizing, and withdrawing what a terminated market pays.

Use it for a market-status banner, a “propose termination” or “vote” screen for insurers, a withdrawal screen on an ended market, or a bot that settles markets for their tips. The rules themselves (why the cutoff must be 12 hours out, how the chain rule picks its five prices, the settlement waterfall) are in Bazaar’s Termination & Settlement page; this page links to it rather than repeating it.

Everything here is on bz.termination (with bz connected as in Connecting). The termination namespace export has the same functions with a context first, plus the pure helpers and constants (reasonProblem, TerminationCategory, insurerProposalId, …).

How a Market Ends

There are four ways in, and every one of them goes through the same two stages.

1. The cutoff. A UMA claim or an insurer vote schedules a cutoff. Trading, deposits and withdrawals stop 6 seconds before it (LIMBO_LEAD): the market is in limbo.
2. Fixing the price. After the cutoff, anyone calls terminateScheduledPair with the archived Pyth Pro updates that prove the settlement price (the stale-oracle path fixes it directly at the last stored price). This opens the settlement window.
3. Settling. In the window every open position is settled at the fixed price (liquidate on the pair, permissionless, tipped $0.05 per position settled for someone else).
4. Finalizing. Once every position is settled, or 14 days after the fix, anyone calls finalizeTermination. The payout ratios freeze and withdrawals open for good.

Costed Calls

Every builder on this page returns a CostedCall (except terminateScheduledPair, which returns a plan holding one). A CostedCall is a PreparedCall (simulate it and send it as one) with four more fields:

A Cost:

Note the units: a bond’s amount is in USDC’s 6 decimals, while the call’s pullsUsdc is the same bond in 18 decimals, like every other pullsUsdc. Format costs with uma.usdcText, uma.ethText and uma.sharesText, which print the exact amount.

A helper that shows a costed call, sends its approvals, simulates it and sends it:

/** A cost as text, in its own unit. */
function costText(c: uma.Cost): string {
  if (c.unit === "USDC") return uma.usdcText(c.amount);
  if (c.unit === "ETH") return uma.ethText(c.amount);
  if (c.unit === "shares") return uma.sharesText(c.amount);
  return `${formatDecimal(c.amount, c.decimals ?? 18)} of token ${c.token}`;
}

/** Show what a costed call takes, send its approvals, simulate it, then send it. */
async function sendCosted(call: uma.CostedCall): Promise<Receipt> {
  console.log(call.summary);
  for (const c of call.costs) {
    console.log(`${c.label}: ${costText(c)}${c.contingent ? " (worst case)" : ""}. ${c.returned}`);
  }
  for (const r of call.requires) console.log(`Needs: ${r}`);
  for (const n of call.notes) console.log(n);
  // Approvals first (each for the exact amount): the call itself reverts until they land.
  for (const a of call.approvals) await bz.waitForReceipt(await bz.send(window.ethereum, a));
  const sim = await bz.simulate(call);
  if (!sim.ok) throw new CallError(sim.error!.message, sim.error);
  return bz.waitForReceipt(await bz.send(window.ethereum, call));
}

Simulate after the approvals have landed: the call pulls the bond with transferFrom and reverts until the allowance is there. When the wallet already allows the spender more than the bond, no approval is returned, and a note warns that the contract takes what it charges when the call runs, up to that allowance; to cap it at the quote, approve exactly the bond first.

A bond quote read from the chain that is below the contract’s own floor (an RPC answering 0, for example) cannot be right: the builder throws uma.BondQuoteError and builds nothing, since an approval sized to it would be wrong.

Reading Where a Market Stands

const s = await bz.termination.terminationStatus(aapl.address);
console.log(`phase: ${s.phase}`); // live | scheduled | limbo | settling | terminated
if (s.scheduledTerminationTs) console.log(`cutoff ${uma.timeText(s.scheduledTerminationTs)}; trading halts ${uma.timeText(s.haltsAt!)}`);
console.log(s.settlementRule.key, "-", s.settlementRule.meaning);
if (s.settlementPrice !== null) console.log(`settlement price ${formatUnits18(s.settlementPrice)}`);
if (s.finalizeOpensAt !== null) console.log(`finalize opens ${uma.timeText(s.finalizeOpensAt)}`);
for (const tp of s.openProposals.termination) console.log(`UMA claim ${tp.assertionId}: ${tp.categoryName}, cutoff ${uma.timeText(tp.lastTradingTs)}`);
for (const ip of s.openProposals.insurer) console.log(`vote ${ip.id}: ${ip.state}, ${uma.sharesText(ip.yesShares)} yes`);
// Without a subgraph, find the ids in the terminator's logs instead: terminationStatus(pair, { fromBlock }).

terminationStatus(pair, search?) answers in one call. phase is:

The terminator keeps no list of proposals, so openProposals (also callable on its own as openProposals(pair, search?)) finds their ids, then reads each one on chain, so the answer reflects the chain rather than the index. Its source says where the ids came from:

Other reads:

A market snapshot also carries the termination stamps (marketSnapshot(...).termination: the cutoff, the fixed price, the ratios, the bad debt) and a status; see Markets.

Ending a Market Through UMA

Proposing

// Validate as the user types: null means the terminator accepts the text.
const reason = "Delisting announced for 2026-12-01: https://example.com/notice?id=42";
const problem = termination.reasonProblem(reason);
if (problem) console.log(problem); // e.g. 'The character "[" is not allowed: ...'

// The four grounds, with a sentence each for a picker.
for (const [id, info] of Object.entries(termination.TERMINATION_CATEGORY_INFO)) {
  console.log(id, info.name, "-", info.description);
}

try {
  const now = await bz.uma.chainNow(); // the chain's clock, not the browser's
  const call = await bz.termination.proposeTermination({
    pair: aapl.address,
    category: termination.TerminationCategory.AssetCessation,
    lastTradingTs: now + 3 * 86_400, // at least 12 hours out, so UMA's acceptance alone enforces it
    reason,
    from: user!,
  });
  const receipt = await sendCosted(call);
  const { assertionId, insurerProposalId } = bz.termination.proposalIdsFromReceipt(receipt);
  console.log(`claim ${assertionId}; its insurer vote has the same id: ${insurerProposalId}`);
} catch (e) {
  console.error(e instanceof uma.BondQuoteError ? e.message : errorMessage(e));
}

proposeTermination(args) posts a claim to UMA’s Optimistic Oracle that the market should end.

The categories (termination.TERMINATION_CATEGORY_INFO has a name and a description of each, for a picker):

Market moves of any size are not grounds.

The reason. The terminator splices reason into the claim UMA’s voters read, between fences that its charset makes unforgeable, so it accepts only letters, digits, space and . , & / - : ? = # % _ ~ + (enough for evidence URLs). Every other character, including square brackets and anything non-ASCII, is refused. termination.reasonProblem(reason) returns why a reason would be refused, or null, so a form can check it as the user types. The claim names the market by its pair id and feed ids; the reason cannot change which market it is about.

The bond. The terminator pulls requiredTerminationBond() (at least 1,000 USDC) from the proposer and posts it to UMA as the assertion bond. UMA returns it when the claim is accepted, and pays it to the disputer if UMA’s voters reject the claim. The call’s costs has the bond, and its approvals the USDC approval for the terminator when the allowance is short. If UMA’s acceptance schedules the market, the proposer also earns 0.1% of its insurance fund, at most $100, claimable on the market with claimFees.

The cutoff. It must be at least 2 hours out (plus slackSeconds). Acceptance alone enforces it as proposed only when it is at least 12 hours out (UMA’s liveness), so prefer that. A nearer cutoff is met as proposed only if insurers vote it through an hour before it; otherwise the claim is accepted after it and the cutoff moves to 7 seconds after acceptance (MIN_CUTOFF_LEAD), and the call’s notes say so. For an event that has already happened, propose the earliest cutoff accepted. Once a UMA cutoff is in force, a new claim must name an earlier one. Filing also opens an insurer vote on the same cutoff, under the claim’s assertion id (its window opens 14 days before the cutoff, or at filing).

proposalIdsFromReceipt(receipt) reads the claim’s assertionId (and the insurer vote it opened, insurerProposalId, which is the same id) from the receipt’s terminator events.

The builder refuses up front, with an InputError: a market the terminator does not know, one already ended or with its price fixed, a category outside 1 to 4, a cutoff too soon or not earlier than the UMA cutoff in force, an invalid reason, and UMA’s identifier being off its live whitelist (claims are closed until Bazaar’s identifier upgrade completes; see UMA Disputes & Governance). The insurer-vote and stale-oracle paths still work then.

Settling the Claim

async function settleClaim(assertionId: `0x${string}`): Promise<string> {
  const st = await bz.uma.assertionStatus(assertionId, { home: "terminator" });
  console.log(uma.ASSERTION_PHASE_TEXT[st.phase]);
  if (st.phase === "liveness") return `It can be settled from ${uma.timeText(st.canSettleAt!)}.`;
  if (st.phase !== "settleable" && st.phase !== "disputed") return "Nothing to settle.";
  const call = await bz.termination.settleTerminationProposal({ assertionId, from: user! });
  // A disputed claim settles only once UMA's voters have ruled: the simulation says whether they have.
  await sendCosted(call);
  const tp = await bz.termination.terminationProposal(assertionId);
  return tp?.resolved ? "Settled." : "Not resolved yet.";
}

settleTerminationProposal({ assertionId, from? }) settles the assertion on the oracle it was made on and applies the verdict: an accepted claim schedules the market (or pulls its cutoff earlier, or caps an insurer schedule’s samples); a rejected one leaves the market alone and ends the claim’s vote. It costs only gas, and anyone may send it.

It refuses an unknown or resolved claim, and one still inside UMA’s liveness. A disputed claim settles only after UMA’s voters have ruled; until then the call reverts, so simulate it. Use bz.uma.assertionStatus(id, { home: "terminator" }) to show where the claim stands (liveness with canSettleAt, settleable, disputed, settledTrue, settledFalse), and see UMA Disputes & Governance for disputing a claim and previewing a DVM ruling.

Insurer Votes

An insurer vote ends a market when yes-votes from matured insurance shares reach 60% of the vote’s share snapshot, and someone executes it at least one hour before its cutoff. Every UMA claim opens one; an insurer can also file a bare proposal with no claim behind it.

A Bare Proposal

// A bare proposal: a cutoff 2 hours to 14 days out, a fixed 1,000 USDC bond, no UMA claim behind it.
const now = await bz.uma.chainNow();
const proposal = await bz.termination.proposeInsurerTermination({ pair: aapl.address, cutoffTs: now + 2 * 86_400, from: user! });
const receipt = await sendCosted(proposal);
const id = bz.termination.proposalIdsFromReceipt(receipt).insurerProposalId!;

proposeInsurerTermination({ pair, cutoffTs, from, slackSeconds? }) posts a fixed 1,000 USDC bond (INSURER_TERMINATION_BOND_USDC), held by the terminator until the vote resolves: refunded if the vote schedules the market, is preempted by an earlier cutoff, is voided by a drained fund, or fails having reached 60%; forfeited to the market’s insurance fund if it fails short of 60%.

The cutoff must be 2 hours to 14 days out and earlier than any cutoff the market already carries, and the proposer must hold shares deposited at least 4 days ago. Proposing does not vote the proposer’s shares. A bare vote settles under the chain rule, so its yes-voters pay a levy (below) unless the vote meets a cutoff UMA accepted. The id is fixed by the second the proposal lands; read it with proposalIdsFromReceipt(receipt).insurerProposalId (or compute it with termination.insurerProposalId(pair, proposer, timestamp)).

Voting

try {
  const vote = await bz.termination.voteForInsurerTermination({ pair: aapl.address, id, shares: parseUnits18("100"), from: user! });
  // costs: the lock on the voted shares, and (contingent) the worst-case levy if this vote ends the market.
  for (const c of vote.costs) console.log(`${c.label}: ${uma.sharesText(c.amount)}${c.contingent ? " at worst" : ""}. ${c.returned}`);
  await sendCosted(vote);
} catch (e) {
  console.error(errorMessage(e));
}

voteForInsurerTermination({ pair, id, shares, from }) votes yes with shares (18 decimals). Votes are never withdrawn. The same shares may back several proposals, up to 8 live ones per wallet on a market (INSURER_MAX_LIVE_VOTES, enforced by the contract and listed in requires).

Only shares held now that were deposited at least 4 days before the vote window opened count (termination.maturityCutoff(windowOpenTs) gives that instant), less what the wallet has already voted on this proposal. The builder refuses more than that, with the limit in the message.

The call’s costs describe what voting puts at stake:

• a lock: the voted shares cannot be withdrawn from the insurance fund until the proposal’s cutoff or the market’s, whichever is first (a failed proposal releases them sooner only while the market has no cutoff); if this vote ends the market and its outcome is costed, until 13 days after the settlement price is fixed (INSURER_POST_FIX_LOCK);
• a levy, contingent, at its worst case: shares forfeited at redemption to Bazaar’s bug bounty address if this vote ends the market.

The notes also say how many shares the vote needs, how many it has with yours, and whether yours meet the threshold. termination.OUTCOME_TEXT has a sentence for each outcome.

Executing

async function executeVote(voteId: Hex): Promise<string> {
  const call = await bz.termination.executeInsurerTermination({ pair: aapl.address, id: voteId, from: user! });
  // outcome: "schedule" | "preempted" | "voided" | "failedRefund" | "failedForfeit"
  console.log(call.outcome, call.notes[0]);
  await sendCosted(call);
  return call.outcome;
}

console.log(await executeVote(id).catch(errorMessage));
// The levy an unjudged outcome would charge, for a vote that ended at 70% yes:
console.log(`${termination.unjudgedLevyBp(1_000n, 700n)} bp`); // 1500 bp: half the 30% that did not vote yes

A vote takes effect only when someone executes it. executeInsurerTermination({ pair, id, from? }) resolves it; anyone may send it, and it costs only gas. Its extra outcome field (and notes[0]) says what it will do now:

A claim-backed vote’s bond is UMA’s, so none of these moves one. The builder refuses an unknown or resolved vote, and one still open below its threshold (the contract reverts until the vote reaches 60% or its latch closes).

Reading Votes

const p = await bz.termination.insurerProposal(id);
if (p) {
  console.log(`${p.state}: ${uma.sharesText(p.yesShares)} of ${uma.sharesText(p.thresholdShares)} needed`);
  console.log(`voting ${uma.timeText(p.windowOpenTs)} to ${uma.timeText(p.votingClosesAt)}; cutoff ${uma.timeText(p.cutoffTs)}`);
  console.log(p.claimBacked ? "Backed by a UMA claim." : "A bare vote: it settles under the chain rule.");
}
const mine = await bz.termination.getLockedShares({ pair: aapl.address, user: user! });
console.log(`your shares locked by live votes: ${uma.sharesText(mine)}`);

insurerProposal(id) returns the vote with its state judged at the chain’s time:

Its other fields: proposer, proposalTs, shareEpoch, cutoffTs, windowOpenTs, votingClosesAt (the cutoff less one hour), yesShares, snapshotTotalShares and snapshotTaken (the snapshot is taken at the first touch once the window is open), thresholdShares and thresholdMet, claimBacked, resolved, scheduled, costed, verdict/verdictName, outcome/outcomeName/outcomeText, and levyBp (stamped with the outcome).

getInsurerVote({ pair, voter, id }) is the shares a voter has in one vote, and getLockedShares({ pair, user }) the shares voted into live proposals, which an insurance withdrawal cannot take (the exit plan reports them as lockedForVoting).

Fixing the Settlement Price

Stale Oracle

try {
  // Only for a market whose oracle has been silent for more than 21 days.
  await simulateAndSend(await bz.termination.terminateStalePair({ pair: aapl.address, from: user! }));
} catch (e) {
  console.log(errorMessage(e)); // e.g. "pair: This market stored a price within the last 21 days: ..."
}

terminateStalePair({ pair, from? }) ends a market that has stored no price for more than 21 days (ORACLE_DEAD_THRESHOLD) at its last stored price, or at a nominal price of 1 when it never stored one (then aged from its creation). Anyone may call it; it pays nothing and costs only gas. The pair’s own stored price is the evidence: a pair stores one whenever a call lands on it with a fresh update, so one refreshPrice restarts the 21 days.

It refuses a market the terminator does not know, one with its price fixed, one whose vote-set cutoff has passed (that market settles through terminateScheduledPair, whose own fallback reaches the stored price), and one that stored a price within 21 days, with the time the path opens.

At a Scheduled Cutoff

const plan = await bz.termination.terminateScheduledPair({ pair: aapl.address, from: user! });
if (plan.call) {
  console.log(`settles under ${plan.under} at ${formatUnits18(plan.settlementPrice!)} with ${plan.updates.length} update(s)`);
  for (const n of plan.call.notes) console.log(n);
  // Already simulated as `from`; its value is the Pyth fee (plan.call.costs), any excess refunded.
  await bz.waitForReceipt(await bz.send(window.ethereum, plan.call));
} else {
  console.log(plan.reason);
  for (const a of plan.attempts) console.log(`${a.under}: ${a.ok ? "accepted" : a.reason}`);
  if (plan.retryAt !== null) console.log(`try again from ${uma.timeText(plan.retryAt)}`);
}

terminateScheduledPair({ pair, from, fetchTick?, estimateGas? }) fixes a scheduled market’s price with archived Pyth Pro updates. Pyth keeps no prices on chain, so every settlement price is submitted as a signed update and verified on the spot. All of them come from Pyth’s one-second channel (fixed_rate@1000ms), which issues one update per second, stamped on the second, and whose archive serves the update for any past second: the connection’s price source fetches them (atTick; without a Pyth Pro source the builder throws ConnectError). It returns a ScheduledSettlementPlan whose call is one the contract accepted in simulation as from, or null with the reason.

It reads settlementRule(pair), whose fields are:

and builds the set the rule needs:

Finding a chain sample. termination.chainSample fetches the update stamped at the target. If its price was generated at or after the target, that one update is the sample. If not, the feed was quiet there, and since a price’s generation time never goes backwards from one second to the next, the first second with a new price is found by doubling the step from the target and then bisecting: a reopen days later takes a few dozen requests. The targets cannot be computed ahead, so the five samples are searched in sequence, and the last exists only once its price does, at least 40 minutes after the cutoff. A sample that would land past latestPublishTs, or that the feed has not produced yet, makes the builder return no call and say so.

Proving the set. Each set is verified by calling the pair’s oracle exactly as the terminator does (fetchPriceAtTick or fetchChainedMedian, as from, with the fee), and only a set the oracle accepts is offered. The price it returns is the plan’s settlementPrice. This matters once the stored-price fallback is open: the terminator then settles at the stored price instead of reverting on a refused set, so the contract’s simulation alone would accept bad updates and the call would be labelled with a price it does not fix.

Verdicts. settlementRule cannot see a verdict UMA’s DVM has reached on the claim behind a vote until someone records it, but terminateScheduledPair records it itself. For a disputed claim the builder previews the DVM’s ruling (uma.previewSettlement) and builds that rule’s set: UMA’s rule if the claim was upheld (whose 12-hour grace starts at this recording, so no fallback yet), the chain rule if not. When the ruling cannot be previewed, it builds both sets and returns the one the contract accepts. A claim still in its liveness returns no call, with retryAt set to the end of the liveness.

The last resort. Past lastResortTs, a call with no updates settles the market at its stored price, for good (12 hours after the cutoff or the verdict under UMA’s rule; 21 days after the cutoff under the chain rule, or 12 hours after a capping UMA cutoff, termination.chainLastResort). It is tried only when no proven set is accepted, and when it is offered depends on storedPrice:

The plan:

The builder throws an InputError for a market the terminator does not know, one with its price fixed, one with no cutoff, and one whose cutoff has not passed yet. Updates are fetched with termination.tickFetcher(source); pass fetchTick (a TickFetcher: (feedIds, second) => Promise<ProUpdate | null>) to use another archive. The building blocks are exported too: tickPrints, chainSample, chainPrints, settlementPrint, generatedAtOrAfter, and SettlementPrintError for an update that cannot be fetched or a sample that cannot be proven, whose kind is "absent" or "unreachable" as in attempts. A price at or below zero, at the cutoff or in a chain sample, cannot settle the market: the oracle refuses it.

No keeper job fixes prices on its own; the keeper’s operator can run terminateStalePair and terminateScheduledPair as manual operations (see Manual Operations).

The Settlement Window

Once the price is fixed, trading, ADL, deposits and all withdrawals stay frozen while every open position is settled at it. Settling is the pair’s liquidate(accounts, []): anyone may call it, with no price update and no ETH, and settling someone else’s position earns a $0.05 tip, claimable with claimFees. Settling your own is free (a position also settles on its owner’s first withdrawal after finalize).

The SDK has no builder for this call; encode it with the pair’s codec:

// The SDK has no builder for settling positions in the settlement window: encode the pair's
// liquidate(accounts, []) directly. No price update and no ETH; each position you settle for
// someone else earns a $0.05 tip, claimable with claimFees.
async function settleOpenPositions(): Promise<void> {
  const accounts: Address[] = [];
  let after: string | null = null;
  do {
    const page = await bz.history.positions({ pair: aapl.address, openOnly: true, first: 1000, after });
    accounts.push(...page.items.map((p) => p.account));
    after = page.next;
  } while (after);
  for (let i = 0; i < accounts.length; i += 100) {
    const batch = accounts.slice(i, i + 100); // the keeper's default batch for this job
    await simulateAndSend({
      action: "liquidate",
      to: aapl.address,
      data: pairCodec().encode("liquidate", batch, []),
      value: 0n,
      from: user!,
      summary: `Settle ${batch.length} position(s) at the settlement price`,
    });
  }
}
if (s.phase === "settling") await settleOpenPositions();

The sample finds open positions in Bazaar’s subgraph (bz.history.positions, see History). The keeper’s terminalSettlement job does the same from its own index, then finalizes; see The Jobs.

Finalizing

try {
  await simulateAndSend(await bz.termination.finalizeTermination({ pair: aapl.address, from: user! }));
} catch (e) {
  console.log(errorMessage(e)); // e.g. positions still open before the 14-day escape hatch
}

finalizeTermination({ pair, from? }) retires the vault’s inherited inventory and freezes the payout ratios. Anyone may call it once every position is settled (open interest is zero) or, as the escape hatch, 14 days after the fix (TERMINAL_SETTLEMENT_ESCAPE); it costs only gas. It refuses a market with no price fixed, one already finalized, and one with positions still open before the escape hatch (with the time it opens).

Finalizing through the escape hatch with positions open is allowed, but a bankrupt position settled afterwards can lower the ratios for everyone still in, and insurance redemptions wait until those positions are settled. Settle first when you can.

Withdrawing After Termination

const ent = await bz.termination.getTerminalEntitlement({ pair: aapl.address, account: user! });
if (!ent.finalized) {
  console.log("Not finalized yet: the payout ratios are not frozen.");
} else if (ent.payout > 0n) {
  console.log(`principal ratio ${formatUnits18(ent.principalRatio * 100n, 2)}%, profit ratio ${formatUnits18(ent.profitRatio * 100n, 2)}%`);
  console.log(`withdrawing everything pays ${formatUnits18(ent.payout, 2)} USDC`);
  // withdrawCollateral takes collateral units; the largest amount it accepts is the preview's maximum.
  const w = await bz.previews.previewWithdrawal(aapl.address, user!);
  await simulateAndSend(await bz.trade.withdrawCollateral(aapl.address, user!, w.maxWithdrawable));
}
// Tips and rewards (settlement tips, a UMA proposer's reward) are claimed separately:
await simulateAndSend(await bz.trade.claimFees(aapl.address, user!));

getTerminalEntitlement({ pair, account }) reads what the market pays an account:

Before finalize the ratios, and so the payout, read 0: show that as “not frozen yet”, not “worthless”. A position still open is not included until it is settled.

Withdraw with bz.trade.withdrawCollateral(pair, user, amount) as on a live market. The amount is in collateral units, the first withdrawal credits the registered claim into collateral, and the wallet receives the amount times the principal ratio; the call’s summary says what it pays, and a withdrawal that would pay nothing is refused. bz.previews.previewWithdrawal(pair, user) returns the largest amount accepted (maxWithdrawable) and the entitlement (terminal). Settlement tips and a UMA proposer’s reward are separate, in the fee balance (claimFees). Insurance LPs redeem through the insurance exit.

Events

termination.decodeTerminatorLog(log) decodes a terminator log (or returns null for another contract’s), and termination.TERMINATOR_EVENT_TEXT has a sentence for each event, for an activity feed. Every UMA claim ends in exactly one of TerminationProposalAccepted, TerminationScheduleRefused, TerminationProposalSuperseded or TerminationProposalRejected. For indexed history (terminationProposals, insurerProposals, insurerVotes, insurerLevies, pairTerminations, terminalRatioUpdates) see History. Live Updates reads the terminator’s logs alongside each watched market’s.

Constants

These are on the termination namespace; LIMBO_LEAD, ORACLE_DEAD_THRESHOLD, TERMINAL_SETTLEMENT_ESCAPE, SETTLEMENT_SAMPLE_COUNT and SETTLEMENT_SAMPLE_SPACING are exported at the top level. See Units & Constants.

What Can Go Wrong

Builder refusals are InputErrors naming the argument; errorMessage(e) gives the sentence. A BondQuoteError, a SettlementPrintError, a SubgraphError or a ConnectError carries its own message: show that (errorMessage does not recognize them). Reverts a simulation can show:

Related

• Insurance: LP shares, which vote, and redeeming after termination.
• UMA Disputes & Governance: disputing a claim, previewing a ruling, the identifier upgrade.
• Listing Markets: the other UMA flow, with the same CostedCall shape.
• Termination & Settlement in Bazaar’s docs.