Quotes and freshness

​

What a quote is

import { settlementIdentity, type MarketView } from '@rekt/1000x';

export function isSignedQuoteMarket(market: MarketView): boolean {
  const s = settlementIdentity(market);
  // `vendor` is 'benchmark' on a market priced by a signed quote, and `pull` is true:
  // the price is posted in the caller's own transaction, never read from an account.
  return s.vendor === 'benchmark' && s.pull;
}

​

The transaction shape

0  ed25519 precompile          the signed 80-byte quote and its signatures
1  settle | stamp_book | ...   yours: reads the instruction immediately before it
2  ComputeBudget  setComputeUnitLimit
3  ComputeBudget  setComputeUnitPrice

• The ed25519 instruction must be immediately before yours. The program reads the instruction at relative index −1 and refuses anything that is not the ed25519 program. The indices are exported as BENCHMARK_QUOTED_LAYOUT ({ ed25519: 0, instruction: 1 }).
• The signature records point at their own instruction. Every offset in the precompile names the precompile itself, so its absolute position does not matter; only its adjacency to yours does. An instruction you add goes in front of index 0 or after the compute-budget pair, never between the quote and your instruction.
• Your instruction carries the Instructions sysvar as its remaining account. That is how the program reaches the precompile. pricingRemainingAccounts(market) returns exactly that list for a market priced by a signed quote. Do not pass market.feeds as accounts: feeds[0] is a feed id, not an account.
• composeBenchmarkTransaction builds this order and submitBenchmarkQuoted sends it. The sender evaluates the protocol gates you hand it, composes, signs, measures the signed bytes, checks the distinct-signer count against market.minSignatures, simulates, and only then sends. dryRun: true stops before the send.

​

What the program checks

​

The one rule that explains every refusal

import { freshnessWindowMs, type ConfigView, type MarketView } from '@rekt/1000x';

// Two governed values, multiplied in one place. Use the result to size timeouts and to explain a
// refusal, never to price anything.
export function freshnessBudget(
  market: MarketView,
  config: ConfigView,
): { slots: number; approxMs: number } {
  return { slots: market.maxOracleAgeSlots, approxMs: freshnessWindowMs(config.params, market) };
}

​

6007 — NoFreshPrice

​

What it is not

• Not a failed trade. Nothing moved. No collateral left the wallet, no position opened, no position closed. The only cost is the network fee for the attempt.
• Not a fault in your code. A quote has a fixed number of slots to survive between being signed and being read. Losing that race sometimes is the normal operating condition.
• Not something a wider client-side staleness window fixes. The chain re-proves freshness at execution. Accepting older quotes on your side only buys more reverts.

​

What to do about it

import { ProgramRefusal, programErrorCode } from '@rekt/1000x';

/**
 * Retry a quoted send. `attempt` must obtain a new quote and re-compose: it is a whole attempt,
 * not a resend. `slotMs` is `slotMs(config.params)`, read live.
 */
export async function withFreshQuote<T>(
  attempt: () => Promise<T>,
  slotMs: number,
  attempts = 3,
): Promise<T> {
  let last: unknown;
  for (let i = 0; i < attempts; i += 1) {
    try {
      return await attempt();
    } catch (e) {
      last = e;
      const code = e instanceof ProgramRefusal ? e.info.code : programErrorCode(e);
      // 6007 is the only code worth spinning on here. Everything else is a state or a bug.
      if (code !== 6007) throw e;
      // One slot, not a backoff. Waiting longer makes the next quote no fresher.
      await new Promise((r) => setTimeout(r, slotMs));
    }
  }
  throw last;
}

​

Three failures, counted separately

​

Which instructions carry a quote

​

Closing a position

• A position that reaches its barrier, its rung or either clock does not need the trader. Those four reasons are permissionless, so they land without the owner signing. Nobody is paid to submit them: what is permissionless is the right to close, not a reward.
• A trader’s own timer (userTimerS at open) turns “close it at this time” into a clock that anyone may prove. Offer it.

​

Related refusals