@flayerlabs/gamemode-gate 0.5.5 → 0.6.0

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/economy.ts

@@ -81,6 +81,16 @@ function resolveInputs(input: EconomyInput): { usdPerSpendToken: number; decimal
  * goes and reads this file.
  */
 export function resolveEconomy(input: EconomyInput): EconomyResult {
+  return evaluate(input, true);
+}
+
+/**
+ * The check itself. `suggest` is false while {@link minimumPointsPerDollar} is probing candidates:
+ * a refusal there must not go looking for a suggestion of its own, or a cap one unit short of
+ * fitting recurses until the stack gives out — which is how this function once took a gate down at
+ * boot instead of printing the number that fixes it.
+ */
+function evaluate(input: EconomyInput, suggest: boolean): EconomyResult {
   const { maxPointsPerPlayer, walletCap, pointsPerDollar } = input;
   const { usdPerSpendToken, decimals } = resolveInputs(input);
 
@@ -125,7 +135,7 @@ export function resolveEconomy(input: EconomyInput): EconomyResult {
     return {
       ok: false,
       problem: 'one point would be worth more than a whole spend token, which cannot be what was meant',
-      suggestedPointsPerDollar: minimumPointsPerDollar(input),
+      suggestedPointsPerDollar: suggest ? minimumPointsPerDollar(input) : pointsPerDollar,
     };
   }
 
@@ -144,7 +154,7 @@ export function resolveEconomy(input: EconomyInput): EconomyResult {
     return {
       ok: false,
       problem: 'a perfect round would earn more than this launch lets one wallet spend',
-      suggestedPointsPerDollar: minimumPointsPerDollar(input),
+      suggestedPointsPerDollar: suggest ? minimumPointsPerDollar(input) : pointsPerDollar,
     };
   }
 
@@ -179,7 +189,7 @@ function minimumPointsPerDollar(input: EconomyInput): number {
     Number.isSafeInteger(decimals) && decimals >= 0 && decimals <= 36 ? unitsPerToken(decimals) : WEI_PER_ETH;
   let candidate = Math.ceil(Number(units / maxUnitsPerPoint) / usdPerSpendToken);
   for (let i = 0; i < 3; i++) {
-    const result = resolveEconomy({ ...input, pointsPerDollar: candidate });
+    const result = evaluate({ ...input, pointsPerDollar: candidate }, false);
     if (result.ok) return candidate;
     candidate += 1;
   }

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,15 @@ 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';
 
 export { createGateReadiness } from './readiness.js';
 export type { GateReadinessOptions } from './readiness.js';

package/src/main.ts

@@ -15,6 +15,7 @@ import { migrate } from './store.js';
 import { resolveEconomy } from './economy.js';
 import { deploymentFor, type GateDeployment } from './chain/chains.js';
 import { assertSecureConfig } from './chain/secure.js';
+import { RegistryPrices } from './chain/registry-prices.js';
 
 /**
  * A production gate from an environment, assembled and checked.
@@ -59,6 +60,12 @@ export interface ResolvedGateConfig {
    * refused at adoption — the gate does not guess a token's price.
    */
   spendTokens: ReadonlyMap<string, SpendTokenPricing>;
+  /**
+   * Percent added over the smallest cap a flawless round fits under when the gate sizes a cap for a
+   * registry-priced pairing (`/config/spend-tokens/:address`). Prices move between the quote and the
+   * launch; this is the room left for that.
+   */
+  pairedTokenCapHeadroomPercent: number;
   /** May lift the gate early or rotate the signer on-chain. Defaults to the signing key's address. */
   settler: `0x${string}` | null;
 }
@@ -156,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
@@ -167,7 +176,10 @@ function address(env: Env, name: string): `0x${string}` | null {
  *   POINTS_PER_DOLLAR        default 100
  *   USD_PER_ETH              default 3000; fractional allowed
  *   SPEND_TOKENS             optional JSON array of { address, usdPerToken, walletCap } — the non-ETH
- *                            paired tokens this gate runs rounds on. Unlisted tokens are refused.
+ *                            paired tokens this gate runs rounds on. Pins a price the registry
+ *                            would otherwise quote; tokens neither here nor approved on the
+ *                            manager's PairedTokenRegistry are refused.
+ *   PAIRED_TOKEN_CAP_HEADROOM_PERCENT  default 25; headroom on caps sized for registry-priced pairings
  */
 export function resolveGateEnv(env: Env): ResolvedGateConfig {
   const chainId = Number(required(env, 'CHAIN_ID'));
@@ -190,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;
 
@@ -247,6 +261,7 @@ export function resolveGateEnv(env: Env): ResolvedGateConfig {
     pointsPerDollar: integer(env, 'POINTS_PER_DOLLAR', 100),
     usdPerEth: positiveNumber(env, 'USD_PER_ETH', 3_000),
     spendTokens: spendTokens(env),
+    pairedTokenCapHeadroomPercent: integer(env, 'PAIRED_TOKEN_CAP_HEADROOM_PERCENT', 25),
     settler: address(env, 'SETTLER'),
   };
 }
@@ -262,9 +277,11 @@ function isEthEquivalent(token: SpendToken, fleth: `0x${string}` | undefined): b
  * The price list a running gate answers adoption with.
  *
  * An override (an oracle, a test) is asked first; the env map second; ETH and its wrapper are the
- * operator's `USD_PER_ETH`; anything else is unpriced and the launch is refused.
+ * operator's `USD_PER_ETH`; then the manager's own PairedTokenRegistry, which prices every token the
+ * protocol has approved through the calculator it was registered with. Only a token none of them
+ * know is unpriced, and that launch is refused — it could not have been launched either.
  */
-function priceList(config: ResolvedGateConfig, override: PriceFor | undefined): PriceFor {
+function priceList(config: ResolvedGateConfig, override: PriceFor | undefined, registry: RegistryPrices): PriceFor {
   return async (token) => {
     if (override) {
       const quoted = await override(token);
@@ -273,7 +290,7 @@ function priceList(config: ResolvedGateConfig, override: PriceFor | undefined):
     const listed = config.spendTokens.get(token.address.toLowerCase());
     if (listed) return listed.usdPerToken;
     if (isEthEquivalent(token, config.deployment.fleth)) return config.usdPerEth;
-    return null;
+    return registry.priceFor(token);
   };
 }
 
@@ -365,6 +382,16 @@ export async function startGate<Config, State, Event, Action, PublicView, Player
     });
   }
 
+  // Every pairing the protocol approves, priced by the calculator it was registered with. The
+  // registry is read from the manager, so nothing is configured and nothing goes stale when a new
+  // token is approved: the next launch on it is adopted like any other.
+  const registryPrices = new RegistryPrices(client, {
+    positionManager: config.deployment.positionManager,
+    ...(config.deployment.fleth ? { fleth: config.deployment.fleth } : {}),
+    usdPerEth: config.usdPerEth,
+  });
+  const pairedTokenRegistry = await registryPrices.registryAddress();
+
   const pool = new pg.Pool({ connectionString: config.databaseUrl });
   await migrate(pool);
 
@@ -386,7 +413,9 @@ 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,
     accepting: true,
     publicLaunchesOpen: true,
@@ -399,7 +428,17 @@ export async function startGate<Config, State, Event, Action, PublicView, Player
     config: gameConfig,
     pointsPerDollar: config.pointsPerDollar,
     usdPerEth: config.usdPerEth,
-    priceFor: priceList(config, overrides.priceProvider),
+    priceFor: priceList(config, overrides.priceProvider, registryPrices),
+    announceSpendToken: async (address) => {
+      // An operator-pinned token is announced exactly as pinned; anything else is the registry's word.
+      const pinned = announcedSpendTokens.find((entry) => entry.address.toLowerCase() === address.toLowerCase());
+      if (pinned) return pinned;
+      return registryPrices.announce(address, {
+        maxPointsPerPlayer,
+        pointsPerDollar: config.pointsPerDollar,
+        headroomPercent: config.pairedTokenCapHeadroomPercent,
+      });
+    },
     sessions: new Sessions(config.sessionSecret, config.signInDomain, config.gateOrigin),
     claims: new Claims(pool, ledger, signer),
     discovery: new Discovery(client, {

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,
     );
   }
 

package/src/server.ts

@@ -1,6 +1,7 @@
 import Fastify, { type FastifyInstance, type FastifyReply, type FastifyRequest } from 'fastify';
 import websocket from '@fastify/websocket';
 import cors from '@fastify/cors';
+import { isAddress } from 'viem';
 import type { Pool } from 'pg';
 import type { Command, GameModule, PlayerId } from '@flayerlabs/gamemode-spec';
 import { isRefusal } from '@flayerlabs/gamemode-spec';
@@ -58,6 +59,13 @@ interface GateBaseOptions {
    * refused: a gate that guessed a price would be authorising real money on a made-up number.
    */
   priceFor?: PriceFor;
+  /**
+   * Serves `GET /config/spend-tokens/:address`: the announced entry for one paired token — price,
+   * symbol, decimals and the per-wallet cap a launch on it should write — or null to answer 404 for
+   * a token this gate will not run rounds on. Lets launch tooling check any pairing before a coin
+   * is paid for, without the gate having listed it in `/config` up front.
+   */
+  announceSpendToken?: (address: `0x${string}`) => Promise<AnnouncedSpendToken | null>;
   /** Verifies from the chain that a coin really is a game launch. */
   discovery?: Discovery;
   /** Keeps the ledger's view of spending level with the chain's. */
@@ -140,6 +148,12 @@ export interface GameServerGateOptions extends GateBaseOptions {
   gameServerOrigins?: readonly string[];
 }
 
+/**
+ * How a gate decides which PositionManagers it adopts coins from. One value today; the type exists
+ * so a client can compare rather than test for presence, and so a later policy has a name.
+ */
+export type PositionManagerPolicy = 'wired-to-calculator';
+
 /**
  * The gate's public identity, in the exact shape the flaunch frontend's `GateServerConfig` already
  * parses — served this way so the page that builds launches needs no second config type.
@@ -161,13 +175,27 @@ export interface GateAnnouncement {
   roundDurationMs: number;
   minLobbyLeadMs: number;
   gateEndsAtGraceS: number;
+  /** The generation of the PRIMARY manager in `contracts.positionManager`; not a limit on adoption. */
   flaunchVariant: FlaunchVariant;
+  /**
+   * How this gate decides which PositionManagers it adopts coins from. `'wired-to-calculator'`
+   * means any manager whose fee wiring routes to `contracts.spendGatedCalculator`, derived from the
+   * coin itself at adoption; `contracts.positionManager` is then the primary manager, not the only
+   * one. A gate that omits the field (below 0.6.0) adopts coins on `contracts.positionManager` only.
+   */
+  positionManagerPolicy?: PositionManagerPolicy;
   /**
    * The non-ETH paired tokens this gate will run rounds on, each with the cap a launch on it should
    * write. Absent or empty means ETH pairings only. Launch tooling refuses a pairing that is not
    * listed here, which is the fail-closed answer for a gate that has not been told the token's price.
    */
   spendTokens?: AnnouncedSpendToken[];
+  /**
+   * The manager's PairedTokenRegistry, when it has one. Its presence means this gate prices every
+   * token the registry approves, not only `spendTokens`: ask `/config/spend-tokens/:address` for the
+   * entry of any pairing before building a launch on it.
+   */
+  pairedTokenRegistry?: `0x${string}`;
   requiresEoa: boolean;
   accepting: boolean;
   /**
@@ -498,12 +526,17 @@ function createGateRuntime<Config, State, Event, Action, PublicView, PlayerView>
           name: launch.name,
           symbol: launch.symbol,
           imageUrl: launch.imageUrl ?? null,
+          positionManager: launch.positionManager ?? null,
         },
       });
     } catch (error) {
       app.log.error(error);
       return { ok: false, status: 503, message: 'this game is still being prepared' };
     }
+    app.log.info(
+      `${launch.coinAddress}: adopted ${launch.symbol || 'coin'} on position manager ` +
+        `${launch.positionManager ?? 'primary'} (pool ${launch.poolId}, ${spendToken.symbol})`,
+    );
     rooms.set(launch.poolId, room);
     return { ok: true, room, created: true };
   }
@@ -686,6 +719,22 @@ function createGateRuntime<Config, State, Event, Action, PublicView, PlayerView>
       const served: ServedGateAnnouncement = { ...announce(), gateVersion: GATE_VERSION };
       return served;
     });
+    if (options.announceSpendToken) {
+      const announceSpendToken = options.announceSpendToken;
+      app.get<{ Params: { address: string } }>('/config/spend-tokens/:address', async (request, reply) => {
+        void reply.header('access-control-allow-origin', '*');
+        // A quote moves with the market and an approval can be revoked; nothing here may be cached
+        // past the response.
+        void reply.header('cache-control', 'no-store');
+        const { address } = request.params;
+        if (!isAddress(address, { strict: false })) {
+          return reply.code(400).send({ message: 'not a token address' });
+        }
+        const entry = await announceSpendToken(address as `0x${string}`);
+        if (!entry) return reply.code(404).send({ message: 'this gate does not run rounds on that token' });
+        return entry;
+      });
+    }
   }
 
   app.post('/session/challenge', async (request) => {

package/src/store.ts

@@ -89,6 +89,12 @@ alter table rounds
 alter table rounds
   add column if not exists usd_per_spend_token double precision check (usd_per_spend_token > 0);
 
+-- Any wired PositionManager (0.6.0). The manager a round's coin was launched on, as the gate
+-- resolved it from the coin at adoption. Null on rounds adopted before the gate recorded it, and on
+-- demo and mock rounds; nothing reads it back for gameplay, it is provenance for the operator.
+alter table rounds
+  add column if not exists position_manager text check (position_manager <> '');
+
 create table if not exists balances (
   round_id text not null references rounds(id) on delete cascade,
   player   text not null,

package/src/version.ts

@@ -1,5 +1,5 @@
 // Generated by scripts/write-version.mjs from package.json at build time. Do not edit.
 /** The published version of @flayerlabs/gamemode-gate, as a literal so it survives any bundler. */
-export const GATE_VERSION: string = "0.5.5";
+export const GATE_VERSION: string = "0.6.0";
 /** `@flayerlabs/gamemode-gate@<version>`: the text a build of this package can be searched for. */
-export const GATE_MARKER: string = "@flayerlabs/gamemode-gate@0.5.5";
+export const GATE_MARKER: string = "@flayerlabs/gamemode-gate@0.6.0";