@flayerlabs/gamemode-gate 0.5.6 → 0.6.0

package/src/chain/discover.ts

@@ -1,5 +1,6 @@
 import { encodeAbiParameters, keccak256, parseAbi, type PublicClient } from 'viem';
 import { ETH_SPEND_TOKEN, type SpendToken } from '@flayerlabs/gamemode-spec/live';
+import { checkPositionManagerWiring, type PositionManagerWiring } from './secure.js';
 
 /**
  * All this needs of a client: the ability to read a contract.
@@ -22,11 +23,15 @@ export type ChainReader = Pick<PublicClient, 'readContract'>;
  * can forge. So adoption needs no API key and no allowlist — anyone may ask, and the chain decides.
  * That single property is what makes third-party games permissionless.
  *
- * A gate serves exactly one (PositionManager, calculator) pair and adopts only coins launched on
- * THAT manager: `poolKey(coin)` is asked of the configured manager alone, so a coin on a superseded
- * generation of hooks (which keeps trading on its own gate) reads back as not a launch here. That
- * is deliberate — the EIP-712 domain binds every authorisation to the calculator, so a coin this
- * gate cannot sign for must not be given a room by it.
+ * A gate serves one calculator and adopts a coin on ANY PositionManager wired to it. The coin
+ * names its own manager (`Memecoin.flaunch()` is the launch ERC721, whose `positionManager()` is
+ * the hook), and that manager is accepted when its fee wiring routes to the gate's calculator —
+ * the same three reads boot makes of the primary manager, made here per manager and cached. There
+ * is no list: wiring a new manager to the dispatcher on chain is what approves it. A coin on a
+ * manager wired to some OTHER calculator is refused for good — the EIP-712 domain binds every
+ * authorisation to the calculator, so a coin this gate cannot sign for must not be given a room
+ * by it — and every later read (`poolKey`, `flaunchesAt`, `pairedToken`) is asked of the coin's
+ * own manager, never the configured one.
  */
 
 const poolKeyComponents = [
@@ -37,6 +42,12 @@ const poolKeyComponents = [
   { name: 'hooks', type: 'address' },
 ] as const;
 
+/** What a coin knows about its own launch: `flaunch()` is the ERC721 that minted it. */
+const memecoinAbi = parseAbi(['function flaunch() view returns (address)']);
+
+/** The launch ERC721 (`Flaunch`, `AnyFlaunch`) names the PositionManager that hooks its pools. */
+const flaunchAbi = parseAbi(['function positionManager() view returns (address)']);
+
 export const positionManagerAbi = [
   {
     type: 'function',
@@ -91,6 +102,11 @@ export interface Launch {
   name: string;
   symbol: string;
   imageUrl?: string | null;
+  /**
+   * The PositionManager the coin was launched on — the pool's hook — resolved from the coin
+   * itself. Absent only from hand-built launches (demos, tests), where it means the primary one.
+   */
+  positionManager?: `0x${string}`;
   /**
    * The token spend is measured in: the coin's paired token, read from the manager. Absent only
    * from hand-built launches (demos, tests), where it means ETH.
@@ -115,12 +131,122 @@ export interface Refused {
 export type LaunchCheck = ({ ok: true } & Launch) | Refused;
 
 export interface Deployment {
+  /**
+   * The primary manager: what boot asserted and `/config` announces. Adoption does not require a
+   * coin to be on it — see {@link verifyLaunch} — but it is the one manager known wired before any
+   * coin arrives, so its wiring is never asked of the chain again.
+   */
   positionManager: `0x${string}`;
   spendGatedCalculator: `0x${string}`;
   /** The signer this gate holds. A launch naming anyone else is not ours to run. */
   signer: `0x${string}`;
 }
 
+/**
+ * Whether a manager's fee wiring routes to a calculator. {@link checkPositionManagerWiring} is the
+ * one implementation; this is its shape, so a test can stand in for the chain.
+ */
+export type WiringCheck = (
+  client: ChainReader,
+  wiring: { positionManager: `0x${string}`; spendGatedCalculator: `0x${string}` },
+) => Promise<PositionManagerWiring>;
+
+/**
+ * Remembers which managers are wired to this gate's calculator, so the three wiring reads happen
+ * once per manager rather than once per coin.
+ *
+ * A yes is kept for the life of the process: wiring is a one-time owner action, and un-wiring a
+ * manager with live pools would also strand every coin already adopted on it, so nothing is lost
+ * by not re-asking. A no is kept a minute — long enough that a coin page polling an unwired
+ * manager is not a lever on the RPC, short enough that the owner wiring it up sees the gate follow.
+ */
+export class WiringCache {
+  private readonly verdicts = new Map<string, { verdict: PositionManagerWiring; until: number }>();
+  private readonly inFlight = new Map<string, Promise<PositionManagerWiring>>();
+
+  constructor(
+    private readonly check: WiringCheck = checkPositionManagerWiring,
+    private readonly now: () => number = Date.now,
+    private readonly negativeHoldMs = 60_000,
+  ) {}
+
+  async isWired(
+    client: ChainReader,
+    positionManager: `0x${string}`,
+    spendGatedCalculator: `0x${string}`,
+  ): Promise<PositionManagerWiring> {
+    const key = positionManager.toLowerCase();
+    const cached = this.verdicts.get(key);
+    if (cached && cached.until > this.now()) return cached.verdict;
+
+    const existing = this.inFlight.get(key);
+    if (existing) return existing;
+
+    const flight = this.check(client, { positionManager, spendGatedCalculator })
+      .then((verdict) => {
+        const until = verdict.ok ? Number.POSITIVE_INFINITY : this.now() + this.negativeHoldMs;
+        this.verdicts.set(key, { verdict, until });
+        return verdict;
+      })
+      .finally(() => this.inFlight.delete(key));
+    this.inFlight.set(key, flight);
+    return flight;
+  }
+
+  /** A fresh cache that already trusts the primary manager, which boot asserted before any coin arrived. */
+  static trusting(positionManager: `0x${string}`): WiringCache {
+    const cache = new WiringCache();
+    cache.trust(positionManager);
+    return cache;
+  }
+
+  /** Record a manager known wired without asking — the primary one, which boot already asserted. */
+  trust(positionManager: `0x${string}`, dispatcher: `0x${string}` = ZERO_ADDRESS): void {
+    this.verdicts.set(positionManager.toLowerCase(), {
+      verdict: { ok: true, dispatcher },
+      until: Number.POSITIVE_INFINITY,
+    });
+  }
+}
+
+/**
+ * Which PositionManager a coin was launched on, from the coin itself.
+ *
+ * Two reads: `Memecoin.flaunch()` names the launch ERC721 that minted the coin, and that contract's
+ * `positionManager()` names the hook. Both are public state written at launch, so the answer is the
+ * coin's and cannot be steered by whoever offers it for adoption. Null when the CONTRACT says no —
+ * an address with no code, or one that is not a Flaunch coin, answers `flaunch()` with no data.
+ * An RPC that did not answer is not a statement about the coin, so that is thrown to the caller
+ * rather than folded into null.
+ */
+export async function resolvePositionManager(
+  client: ChainReader,
+  memecoin: `0x${string}`,
+): Promise<`0x${string}` | null> {
+  let flaunch: `0x${string}`;
+  try {
+    flaunch = (await client.readContract({ address: memecoin, abi: memecoinAbi, functionName: 'flaunch' })) as `0x${string}`;
+  } catch (error) {
+    if (isMissingFunction(error)) return null;
+    throw error;
+  }
+  if (!flaunch || flaunch.toLowerCase() === ZERO_ADDRESS) return null;
+
+  let manager: `0x${string}`;
+  try {
+    manager = (await client.readContract({
+      address: flaunch,
+      abi: flaunchAbi,
+      functionName: 'positionManager',
+    })) as `0x${string}`;
+  } catch (error) {
+    if (isMissingFunction(error)) return null;
+    throw error;
+  }
+  if (!manager || manager.toLowerCase() === ZERO_ADDRESS) return null;
+  return manager;
+}
+
 export function poolIdOf(key: PoolKey): `0x${string}` {
   return keccak256(
     encodeAbiParameters(
@@ -142,11 +268,28 @@ export async function verifyLaunch(
   client: ChainReader,
   deployment: Deployment,
   memecoin: `0x${string}`,
+  wiring: WiringCache = WiringCache.trusting(deployment.positionManager),
 ): Promise<LaunchCheck> {
+  // The coin's own manager first. A coin the protocol has never heard of has no `flaunch()`, which
+  // is still "not yet": the coin page loads the instant a launch is submitted, before the chain has
+  // caught up, and that must not be remembered as "no".
+  let positionManager: `0x${string}` | null;
+  try {
+    positionManager = await resolvePositionManager(client, memecoin);
+  } catch {
+    return refuse('launch.unreadable', true);
+  }
+  if (!positionManager) return refuse('launch.not_flaunched', true);
+
+  // Approval is a fact about the chain: is this manager's fee wiring routed to OUR calculator? A
+  // manager wired elsewhere is another gate's, permanently — no amount of waiting rewires it.
+  const wired = await wiring.isWired(client, positionManager, deployment.spendGatedCalculator);
+  if (!wired.ok) return refuse('launch.unapproved_position_manager', false);
+
   let poolKey: PoolKey;
   try {
     poolKey = (await client.readContract({
-      address: deployment.positionManager,
+      address: positionManager,
       abi: positionManagerAbi,
       functionName: 'poolKey',
       args: [memecoin],
@@ -164,9 +307,8 @@ export async function verifyLaunch(
 
   let settings: readonly [boolean, bigint, `0x${string}`, bigint];
   let trusted: readonly [`0x${string}`, boolean];
-  let flaunchesAt: bigint;
   try {
-    [settings, trusted, flaunchesAt] = (await Promise.all([
+    [settings, trusted] = (await Promise.all([
       client.readContract({
         address: deployment.spendGatedCalculator,
         abi: spendGatedAbi,
@@ -179,17 +321,27 @@ export async function verifyLaunch(
         functionName: 'trustedPoolKeySigner',
         args: [poolId],
       }),
-      client.readContract({
-        address: deployment.positionManager,
-        abi: positionManagerAbi,
-        functionName: 'flaunchesAt',
-        args: [poolId],
-      }),
-    ])) as [typeof settings, typeof trusted, bigint];
+    ])) as [typeof settings, typeof trusted];
   } catch {
     return refuse('launch.unreadable', true);
   }
 
+  // The window's open is the manager's to report. A manager that is wired but has no
+  // `flaunchesAt` is a generation this gate has no round model for — a permanent fact about the
+  // contract, not an outage, so it is refused as unsupported rather than as unreadable and retried
+  // forever.
+  let flaunchesAt: bigint;
+  try {
+    flaunchesAt = (await client.readContract({
+      address: positionManager,
+      abi: positionManagerAbi,
+      functionName: 'flaunchesAt',
+      args: [poolId],
+    })) as bigint;
+  } catch (error) {
+    return refuse(isMissingFunction(error) ? 'launch.unsupported_position_manager' : 'launch.unreadable', !isMissingFunction(error));
+  }
+
   const [enabled, walletCap, , endsAt] = settings;
   const [signer, signerEnabled] = trusted;
 
@@ -204,7 +356,7 @@ export async function verifyLaunch(
   const closesAt = Number(endsAt) * 1000;
   if (closesAt <= Date.now()) return refuse('launch.already_over', false);
 
-  const spendToken = await resolveSpendToken(client, deployment, memecoin, poolKey, poolId);
+  const spendToken = await resolveSpendToken(client, positionManager, memecoin, poolKey, poolId);
   if (!spendToken) return refuse('launch.paired_unreadable', true);
 
   let name = '';
@@ -231,9 +383,38 @@ export async function verifyLaunch(
     name,
     symbol,
     spendToken,
+    positionManager,
   };
 }
 
+/**
+ * Did a read fail because the contract has no such function, rather than because the chain did
+ * not answer? viem reports the former as a call that returned no data or reverted at the
+ * contract (`ContractFunctionZeroDataError`, `ContractFunctionRevertedError`); a transport
+ * failure looks nothing like it, and a `view` that exists does not revert on a pool id.
+ */
+function isMissingFunction(error: unknown): boolean {
+  const seen = new Set<unknown>();
+  let current: unknown = error;
+  while (current && typeof current === 'object' && !seen.has(current)) {
+    seen.add(current);
+    const name = (current as { name?: unknown }).name;
+    if (
+      name === 'ContractFunctionZeroDataError' ||
+      name === 'AbiDecodingZeroDataError' ||
+      name === 'ContractFunctionRevertedError'
+    ) {
+      return true;
+    }
+    const message = (current as { message?: unknown }).message;
+    if (typeof message === 'string' && /returned no data|zero data|function (selector )?was not (recognized|found)/i.test(message)) {
+      return true;
+    }
+    current = (current as { cause?: unknown }).cause;
+  }
+  return false;
+}
+
 /**
  * Which token this pool's spend is measured in.
  *
@@ -246,7 +427,7 @@ export async function verifyLaunch(
  */
 async function resolveSpendToken(
   client: ChainReader,
-  deployment: Deployment,
+  positionManager: `0x${string}`,
   memecoin: `0x${string}`,
   poolKey: PoolKey,
   poolId: `0x${string}`,
@@ -254,7 +435,7 @@ async function resolveSpendToken(
   let paired: `0x${string}`;
   try {
     paired = (await client.readContract({
-      address: deployment.positionManager,
+      address: positionManager,
       abi: positionManagerAbi,
       functionName: 'pairedToken',
       args: [poolId],
@@ -278,7 +459,7 @@ async function resolveSpendToken(
 /**
  * Verification with a memory, because every coin-page view asks.
  *
- * Unmemoised, each call costs five chain reads against one endpoint from one address — which is a
+ * Unmemoised, each call costs seven chain reads against one endpoint from one address — which is a
  * free denial-of-service lever, and public endpoints rate-limit long before a launch does.
  *
  * A positive verdict is cached until the window closes, because a launch that qualifies cannot
@@ -288,12 +469,22 @@ async function resolveSpendToken(
 export class Discovery {
   private readonly verdicts = new Map<string, { verdict: LaunchCheck; until: number }>();
   private readonly inFlight = new Map<string, Promise<LaunchCheck>>();
+  /**
+   * Which managers are wired to this gate's calculator, remembered per manager. The primary one is
+   * trusted from the start: boot asserted it, and asking again would be the only three reads that
+   * could never answer differently.
+   */
+  readonly wiring: WiringCache;
 
   constructor(
     private readonly client: ChainReader,
     private readonly deployment: Deployment,
     private readonly now: () => number = Date.now,
-  ) {}
+    wiring: WiringCache = new WiringCache(checkPositionManagerWiring, now),
+  ) {
+    this.wiring = wiring;
+    this.wiring.trust(deployment.positionManager);
+  }
 
   async verify(memecoin: `0x${string}`): Promise<LaunchCheck> {
     const key = memecoin.toLowerCase();
@@ -305,7 +496,7 @@ export class Discovery {
     const existing = this.inFlight.get(key);
     if (existing) return existing;
 
-    const flight = verifyLaunch(this.client, this.deployment, memecoin)
+    const flight = verifyLaunch(this.client, this.deployment, memecoin, this.wiring)
       .then((verdict) => {
         this.verdicts.set(key, { verdict, until: this.now() + this.holdFor(verdict) });
         return verdict;

package/src/chain/secure.ts

@@ -69,57 +69,101 @@ export async function assertSecureConfig(client: PublicClient, config: SecureCon
 }
 
 /**
- * The manager must route fees through a dispatcher that knows this calculator, and the calculator
+ * The verdict of {@link checkPositionManagerWiring}: wired, with the dispatcher the manager routes
+ * through, or not, with a reason written for the operator who has to fix it.
+ */
+export type PositionManagerWiring =
+  | { ok: true; dispatcher: `0x${string}` }
+  | { ok: false; reason: string };
+
+/**
+ * Is this manager's fee wiring routed to this calculator?
+ *
+ * The manager must route fees through a dispatcher that knows the calculator, and the calculator
  * must accept calls from that dispatcher. Both are one-time owner actions on chain, and a stack
  * missing either ADOPTS launches whose swaps never reach the gate: the pool trades ungated while
  * the gate believes it is enforcing a cap. That is the whole failure this function refuses.
  *
- * A paired stack additionally needs its PoolSwap approved as a router, because a paired buy arrives
- * through it and the calculator binds a smart wallet's buyer identity to an approved router's
- * `msgSender()` — unapproved, every such buy reverts at the swap.
+ * It is also how a manager is APPROVED for a gate. The gate never holds a list of managers: a coin
+ * offered for adoption names its own manager, and the manager is accepted when these three reads
+ * say its fees reach the gate's calculator. Wiring a new manager to the dispatcher on chain is the
+ * approval, and needs no gate release. Boot asks the same question of the primary manager.
  */
-async function assertWiring(client: PublicClient, config: SecureConfig): Promise<void> {
-  const manager = config.positionManager!;
-  const calculator = config.spendGatedCalculator;
+export async function checkPositionManagerWiring(
+  client: Pick<PublicClient, 'readContract'>,
+  wiring: { positionManager: `0x${string}`; spendGatedCalculator: `0x${string}` },
+): Promise<PositionManagerWiring> {
+  const manager = wiring.positionManager;
+  const calculator = wiring.spendGatedCalculator;
 
   let dispatcher: `0x${string}`;
   try {
-    dispatcher = await client.readContract({ address: manager, abi: wiringAbi, functionName: 'feeCalculator' });
+    dispatcher = (await client.readContract({
+      address: manager,
+      abi: wiringAbi,
+      functionName: 'feeCalculator',
+    })) as `0x${string}`;
   } catch {
-    throw new Error(`POSITION_MANAGER ${manager} does not answer feeCalculator() — is it a Flaunch PositionManager?`);
+    return { ok: false, reason: `${manager} does not answer feeCalculator() — is it a Flaunch PositionManager?` };
   }
 
   const [registered, hasRole] = await Promise.all([
-    client.readContract({
-      address: dispatcher,
-      abi: wiringAbi,
-      functionName: 'registeredCalculators',
-      args: [calculator],
-    }).catch(() => false),
-    client.readContract({
-      address: calculator,
-      abi: wiringAbi,
-      functionName: 'hasRole',
-      args: [POSITION_MANAGER_ROLE, dispatcher],
-    }).catch(() => false),
+    client
+      .readContract({
+        address: dispatcher,
+        abi: wiringAbi,
+        functionName: 'registeredCalculators',
+        args: [calculator],
+      })
+      .catch(() => false),
+    client
+      .readContract({
+        address: calculator,
+        abi: wiringAbi,
+        functionName: 'hasRole',
+        args: [POSITION_MANAGER_ROLE, dispatcher],
+      })
+      .catch(() => false),
   ]);
   if (!registered) {
-    throw new Error(
-      `the fee dispatcher ${dispatcher} of POSITION_MANAGER ${manager} does not have SPEND_GATED_CALCULATOR ` +
+    return {
+      ok: false,
+      reason:
+        `the fee dispatcher ${dispatcher} of PositionManager ${manager} does not have the spend-gated calculator ` +
         `${calculator} registered — its owner must call setCalculatorRegistered(${calculator}, true) before ` +
-        'this gate can serve launches on that manager',
-    );
+        'a gate on that calculator can serve launches on that manager',
+    };
   }
   if (!hasRole) {
-    throw new Error(
-      `SPEND_GATED_CALCULATOR ${calculator} has not granted the PositionManager role to the dispatcher ${dispatcher} ` +
-        `— its admin must call grantRole(${POSITION_MANAGER_ROLE}, ${dispatcher})`,
-    );
+    return {
+      ok: false,
+      reason:
+        `the spend-gated calculator ${calculator} has not granted the PositionManager role to the dispatcher ` +
+        `${dispatcher} — its admin must call grantRole(${POSITION_MANAGER_ROLE}, ${dispatcher})`,
+    };
   }
+  return { ok: true, dispatcher };
+}
+
+/**
+ * Boot's assertion about the PRIMARY manager: {@link checkPositionManagerWiring}, thrown rather
+ * than returned, because a gate whose own address book is unwired must not come up at all.
+ *
+ * A paired stack additionally needs its PoolSwap approved as a router, because a paired buy arrives
+ * through it and the calculator binds a smart wallet's buyer identity to an approved router's
+ * `msgSender()` — unapproved, every such buy reverts at the swap.
+ */
+async function assertWiring(client: PublicClient, config: SecureConfig): Promise<void> {
+  const calculator = config.spendGatedCalculator;
+  const wiring = await checkPositionManagerWiring(client, {
+    positionManager: config.positionManager!,
+    spendGatedCalculator: calculator,
+  });
+  if (!wiring.ok) throw new Error(`POSITION_MANAGER: ${wiring.reason}`);
 
-  if (config.flaunchVariant === 'v1_3') {
+  if (config.flaunchVariant === 'v1_3' || config.flaunchVariant === 'any_v1_3') {
     if (!config.poolSwap) {
-      throw new Error('a v1_3 stack needs POOL_SWAP — the router a paired-token buy goes through');
+      throw new Error(`a ${config.flaunchVariant} stack needs POOL_SWAP — the router a paired-token buy goes through`);
     }
     const approved = await client
       .readContract({ address: calculator, abi: wiringAbi, functionName: 'approvedRouters', args: [config.poolSwap] })

package/src/index.ts

@@ -27,8 +27,8 @@ export type { BalanceKey, Claim, ClaimResult } from './ledger.js';
 export { CLAIM_AUTHORIZATION_TTL_MS } from './claims.js';
 export { PayloadSigner, encodeHookData } from './chain/signer.js';
 export type { SignedPayload } from './chain/signer.js';
-export { Discovery, poolIdOf, verifyLaunch } from './chain/discover.js';
-export type { ChainReader, Deployment, Launch, LaunchCheck, PoolKey, Refused } from './chain/discover.js';
+export { Discovery, WiringCache, poolIdOf, resolvePositionManager, verifyLaunch } from './chain/discover.js';
+export type { ChainReader, Deployment, Launch, LaunchCheck, PoolKey, Refused, WiringCheck } from './chain/discover.js';
 export { Settlement } from './settlement.js';
 export { Standings } from './standings.js';
 export { ETH_DECIMALS, resolveEconomy, unitsPerToken } from './economy.js';
@@ -66,12 +66,13 @@ export type { VerifiedPlayerJoin, VerifyPlayerJoinTicketOptions } from './player
  */
 export { startGate, resolveGateEnv } from './main.js';
 export type { ResolvedGateConfig, SpendTokenPricing, StartedGate, StartGateOverrides } from './main.js';
-export type { GateAnnouncement, ServedGateAnnouncement } from './server.js';
+export type { GateAnnouncement, PositionManagerPolicy, ServedGateAnnouncement } from './server.js';
 export { GATE_MARKER, GATE_VERSION } from './version.js';
 export { NotSignedIn } from './sessions.js';
 export { DEPLOYMENTS, PAIRED_DEPLOYMENTS, deploymentFor } from './chain/chains.js';
 export type { FlaunchVariant, GateDeployment } from './chain/chains.js';
-export { POSITION_MANAGER_ROLE, assertSecureConfig } from './chain/secure.js';
+export { POSITION_MANAGER_ROLE, assertSecureConfig, checkPositionManagerWiring } from './chain/secure.js';
+export type { PositionManagerWiring } from './chain/secure.js';
 export { RegistryPrices, minimumWalletCap, withHeadroom } from './chain/registry-prices.js';
 export type { AnnounceOptions, RegistryPricesOptions, RegistryQuote, RegistryReader } from './chain/registry-prices.js';
 

package/src/main.ts

@@ -163,9 +163,11 @@ function address(env: Env, name: string): `0x${string}` | null {
  *   POSITION_MANAGER         optional; selects a recorded stack on the chain (the legacy one when
  *                            unset), or overrides the address for a chain with no address book
  *   SPEND_GATED_CALCULATOR   optional address-book override
- *   POOL_SWAP                optional address-book override; required for a v1_3 stack
+ *   POOL_SWAP                optional address-book override; required for a v1_3 or any_v1_3 stack
  *   FLETH                    optional address-book override; the chain's flETH wrapper
- *   FLAUNCH_VARIANT          optional; v1_2, multichain or v1_3
+ *   FLAUNCH_VARIANT          optional; v1_2, multichain, v1_3 or any_v1_3 — the PRIMARY manager's
+ *                            generation. Adoption is not limited to it: any manager wired to the
+ *                            calculator is served (see chain/discover.ts)
  *   SETTLER                  optional; defaults to the signing key's own address
  *   WALLET_CAP_WEI           default 0.025 ETH; the cap for ETH-paired launches
  *   ROUND_MS                 default 90000
@@ -200,14 +202,16 @@ export function resolveGateEnv(env: Env): ResolvedGateConfig {
     variantOverride !== undefined &&
     variantOverride !== 'v1_2' &&
     variantOverride !== 'multichain' &&
-    variantOverride !== 'v1_3'
+    variantOverride !== 'v1_3' &&
+    variantOverride !== 'any_v1_3'
   ) {
-    throw new Error(`FLAUNCH_VARIANT must be v1_2, multichain or v1_3, not ${variantOverride}`);
+    throw new Error(`FLAUNCH_VARIANT must be v1_2, multichain, v1_3 or any_v1_3, not ${variantOverride}`);
   }
   const flaunchVariant = variantOverride ?? recorded?.flaunchVariant ?? 'v1_2';
   const poolSwap = address(env, 'POOL_SWAP') ?? recorded?.poolSwap ?? null;
-  if (flaunchVariant === 'v1_3' && !poolSwap) {
-    throw new Error('a v1_3 stack needs POOL_SWAP — the approved router a paired-token buy goes through');
+  // Both V1_3 generations take paired buys through the approved router.
+  if ((flaunchVariant === 'v1_3' || flaunchVariant === 'any_v1_3') && !poolSwap) {
+    throw new Error(`a ${flaunchVariant} stack needs POOL_SWAP — the approved router a paired-token buy goes through`);
   }
   const fleth = address(env, 'FLETH') ?? recorded?.fleth ?? null;
 
@@ -409,6 +413,7 @@ export async function startGate<Config, State, Event, Action, PublicView, Player
     minLobbyLeadMs: config.minLobbyLeadMs,
     gateEndsAtGraceS: config.gateEndsAtGraceS,
     flaunchVariant: config.deployment.flaunchVariant,
+    positionManagerPolicy: 'wired-to-calculator',
     ...(announcedSpendTokens.length > 0 ? { spendTokens: announcedSpendTokens } : {}),
     ...(pairedTokenRegistry ? { pairedTokenRegistry } : {}),
     requiresEoa: false,

package/src/room.ts

@@ -42,6 +42,12 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
     readonly terms: RoundTerms,
     readonly scoreAuthority: ScoreAuthority,
     private seq: number,
+    /**
+     * The PositionManager the coin was launched on, as the gate resolved it at adoption. Null for
+     * rounds adopted before the gate recorded it (below 0.6.0), and for demo and mock rooms. Kept
+     * off `LaunchContext`, which is the wire type games receive.
+     */
+    readonly positionManager: string | null = null,
   ) {}
 
   static async create<Config, State, Event, Action, PublicView, PlayerView>(
@@ -68,6 +74,7 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
         name?: string;
         symbol?: string;
         imageUrl?: string | null;
+        positionManager?: string | null;
       };
     },
   ): Promise<Room<Config, State, Event, Action, PublicView, PlayerView>> {
@@ -109,8 +116,8 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
          spend_token, spend_symbol, spend_decimals, usd_per_spend_token,
          max_points_per_player, score_authority,
          pool_id, opens_at, closes_at, books_close_at,
-         coin_address, coin_name, coin_symbol, coin_image_url, state, seq
-       ) values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, 0)`,
+         coin_address, coin_name, coin_symbol, coin_image_url, position_manager, state, seq
+       ) values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, 0)`,
       [
         round.id,
         game.id,
@@ -132,6 +139,7 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
         launch.name,
         launch.symbol,
         launch.imageUrl,
+        round.launch?.positionManager?.toLowerCase() ?? null,
         serialise(game.id, started.snapshot()),
       ],
     );
@@ -145,6 +153,7 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
       terms,
       round.scoreAuthority,
       0,
+      round.launch?.positionManager?.toLowerCase() ?? null,
     );
   }
 
@@ -165,6 +174,7 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
       coin_name: string;
       coin_symbol: string;
       coin_image_url: string | null;
+      position_manager: string | null;
       wei_per_point: string;
       wallet_cap_wei: string;
       points_per_dollar: number;
@@ -181,7 +191,7 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
               wallet_cap_wei, points_per_dollar, usd_per_eth,
               spend_token, spend_symbol, spend_decimals, usd_per_spend_token,
               max_points_per_player, score_authority, game_id,
-              coin_address, coin_name, coin_symbol, coin_image_url
+              coin_address, coin_name, coin_symbol, coin_image_url, position_manager
        from rounds where id = $1`,
       [id],
     );
@@ -225,6 +235,7 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
       terms,
       row.score_authority,
       row.seq,
+      row.position_manager,
     );
   }