@flayerlabs/gamemode-gate 0.4.3 → 0.5.0

package/src/ledger.ts

@@ -37,12 +37,12 @@ export interface BalanceKey {
 
 interface LedgerState {
   points: bigint;
-  weiPerPoint: bigint;
+  unitsPerPoint: bigint;
   capWei: bigint;
   opensAt: number;
   closesAt: number;
   /** Authorisations still outstanding: issued, not yet expired, fate unknown. */
-  heldWei: bigint;
+  held: bigint;
   /** What the chain says has actually been spent. */
   chainSpentWei: bigint;
   /**
@@ -60,9 +60,9 @@ interface LedgerState {
  * wallet spend. Issuing past the second does not overspend — the chain refuses it — it mints a
  * signature that reverts at the swap, which to a player is indistinguishable from being robbed.
  */
-function availableFrom({ points, weiPerPoint, capWei, heldWei, chainSpentWei }: LedgerState): bigint {
-  const earnedWei = points * weiPerPoint;
-  const ceiling = earnedWei < capWei ? earnedWei : capWei;
+function availableFrom({ points, unitsPerPoint, capWei, held, chainSpentWei }: LedgerState): bigint {
+  const earned = points * unitsPerPoint;
+  const ceiling = earned < capWei ? earned : capWei;
 
   // Spent-on-chain PLUS still-outstanding, never the larger of the two.
   //
@@ -74,7 +74,7 @@ function availableFrom({ points, weiPerPoint, capWei, heldWei, chainSpentWei }:
   //
   // Adding them double-counts a hold whose swap has already landed, until that hold expires. That
   // errs towards authorising too little, which is the direction that costs nobody anything.
-  const available = ceiling - (chainSpentWei + heldWei);
+  const available = ceiling - (chainSpentWei + held);
   return available > 0n ? available : 0n;
 }
 
@@ -186,11 +186,11 @@ export class Ledger {
    *
    * Never allowed to go backwards: a read from a lagging node must not undo what a later one saw.
    */
-  async recordChainSpend(roundId: string, player: PlayerId, spentWei: bigint): Promise<boolean> {
+  async recordChainSpend(roundId: string, player: PlayerId, spent: bigint): Promise<boolean> {
     const result = await this.pool.query(
       `update balances set chain_spent_wei = greatest(chain_spent_wei, $3)
        where round_id = $1 and player = $2 and chain_spent_wei < $3`,
-      [roundId, player, spentWei.toString()],
+      [roundId, player, spent.toString()],
     );
     return result.rowCount === 1;
   }
@@ -227,23 +227,23 @@ export class Ledger {
     return [...unique.values()];
   }
 
-  async availableWei(roundId: string, player: PlayerId): Promise<bigint> {
-    return (await this.economyBalance(roundId, player)).availableWei;
+  async available(roundId: string, player: PlayerId): Promise<bigint> {
+    return (await this.economyBalance(roundId, player)).available;
   }
 
   /** The authoritative balance snapshot, derived from the same state and ceiling as `claim`. */
   async economyBalance(roundId: string, player: PlayerId): Promise<EconomyBalance> {
     const state = await this.readState(this.pool, roundId, player);
     if (!state) {
-      return { weiPerPoint: 0n, earnedWei: 0n, heldWei: 0n, spentWei: 0n, availableWei: 0n, holdExpiresAt: null };
+      return { unitsPerPoint: 0n, earned: 0n, held: 0n, spent: 0n, available: 0n, holdExpiresAt: null };
     }
 
     return {
-      weiPerPoint: state.weiPerPoint,
-      earnedWei: state.points * state.weiPerPoint,
-      heldWei: state.heldWei,
-      spentWei: state.chainSpentWei,
-      availableWei: availableFrom(state),
+      unitsPerPoint: state.unitsPerPoint,
+      earned: state.points * state.unitsPerPoint,
+      held: state.held,
+      spent: state.chainSpentWei,
+      available: availableFrom(state),
       // Seconds on the way in, because that is what the contract checks against; milliseconds on
       // the way out, because that is what a browser counts down with.
       holdExpiresAt: state.holdExpiresAtSeconds === null ? null : state.holdExpiresAtSeconds * 1000,
@@ -285,11 +285,11 @@ export class Ledger {
     return {
       points: toBigInt(balance.rows[0]?.points),
       chainSpentWei: toBigInt(balance.rows[0]?.chain_spent_wei),
-      weiPerPoint: toBigInt(row.wei_per_point),
+      unitsPerPoint: toBigInt(row.wei_per_point),
       capWei: toBigInt(row.wallet_cap_wei),
       opensAt: Number(row.opens_at),
       closesAt: Number(row.closes_at),
-      heldWei: toBigInt(held.rows[0]?.total),
+      held: toBigInt(held.rows[0]?.total),
       holdExpiresAtSeconds: earliest == null ? null : Number(earliest),
     };
   }

package/src/main.ts

@@ -1,8 +1,9 @@
 import pg from 'pg';
-import { createPublicClient, http, isAddress, type PublicClient } from 'viem';
+import { createPublicClient, http, isAddress, parseAbi, type PublicClient } from 'viem';
 import type { FastifyInstance } from 'fastify';
 import type { GameModule } from '@flayerlabs/gamemode-spec';
-import { createGate, type GateAnnouncement } from './server.js';
+import type { SpendToken } from '@flayerlabs/gamemode-spec/live';
+import { createGate, type AnnouncedSpendToken, type GateAnnouncement, type PriceFor } from './server.js';
 import { Ledger } from './ledger.js';
 import { Claims } from './claims.js';
 import { Sessions } from './sessions.js';
@@ -44,16 +45,31 @@ export interface ResolvedGateConfig {
   port: number;
   deployment: GateDeployment;
   /** Announced to launch tooling; the creator's launch writes it into the pool. */
-  walletCapWei: bigint;
+  walletCap: bigint;
   roundDurationMs: number;
   minLobbyLeadMs: number;
   gateEndsAtGraceS: number;
   pointsPerDollar: number;
+  /** The price of ETH; what ETH-paired rounds are priced at. Fractional values are fine. */
   usdPerEth: number;
+  /**
+   * The non-ETH paired tokens this gate will run rounds on, with the price it fixes them at and the
+   * per-wallet cap a launch on them should write. Keyed by lowercase address. Anything not here is
+   * refused at adoption — the gate does not guess a token's price.
+   */
+  spendTokens: ReadonlyMap<string, SpendTokenPricing>;
   /** May lift the gate early or rotate the signer on-chain. Defaults to the signing key's address. */
   settler: `0x${string}` | null;
 }
 
+export interface SpendTokenPricing {
+  address: `0x${string}`;
+  /** Dollars per whole token. */
+  usdPerToken: number;
+  /** Per-wallet cap for a launch on this token, in its base units. */
+  walletCap: bigint;
+}
+
 function required(env: Env, name: string): string {
   const value = env[name];
   if (!value) throw new Error(`${name} is not set — the gate refuses to guess it`);
@@ -68,6 +84,54 @@ function integer(env: Env, name: string, fallback: number): number {
   return value;
 }
 
+/** A price or a rate: positive, finite, and allowed to be fractional — a dollar stablecoin is 1.0. */
+function positiveNumber(env: Env, name: string, fallback: number): number {
+  const raw = env[name];
+  if (raw === undefined || raw === '') return fallback;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`${name} must be a positive number`);
+  return value;
+}
+
+/**
+ * `SPEND_TOKENS`: a JSON array of `{ address, usdPerToken, walletCap }`.
+ *
+ * Only what the chain cannot tell us: the price, and the cap the operator wants launches on this
+ * token to carry. Symbol and decimals are read from the token itself at boot — an operator-typed
+ * decimals is the exact mistake this whole feature exists to make impossible.
+ */
+function spendTokens(env: Env): ReadonlyMap<string, SpendTokenPricing> {
+  const raw = env['SPEND_TOKENS'];
+  const out = new Map<string, SpendTokenPricing>();
+  if (raw === undefined || raw.trim() === '') return out;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error('SPEND_TOKENS must be a JSON array of { address, usdPerToken, walletCap }');
+  }
+  if (!Array.isArray(parsed)) throw new Error('SPEND_TOKENS must be a JSON array');
+  for (const entry of parsed as unknown[]) {
+    const value = (entry ?? {}) as Record<string, unknown>;
+    // Casing is not checked: operators paste addresses from explorers and configs in every case,
+    // and a rejected checksum here would read as "wrong address" for a right one.
+    if (typeof value.address !== 'string' || !isAddress(value.address, { strict: false })) {
+      throw new Error('SPEND_TOKENS: every entry needs an address');
+    }
+    const usdPerToken = Number(value.usdPerToken);
+    if (!Number.isFinite(usdPerToken) || usdPerToken <= 0) {
+      throw new Error(`SPEND_TOKENS: ${value.address} needs a positive usdPerToken`);
+    }
+    if (typeof value.walletCap !== 'string' || !/^[1-9][0-9]*$/.test(value.walletCap)) {
+      throw new Error(`SPEND_TOKENS: ${value.address} needs walletCap as a decimal string of base units`);
+    }
+    const key = value.address.toLowerCase();
+    if (out.has(key)) throw new Error(`SPEND_TOKENS lists ${value.address} twice`);
+    out.set(key, { address: value.address as `0x${string}`, usdPerToken, walletCap: BigInt(value.walletCap) });
+  }
+  return out;
+}
+
 function address(env: Env, name: string): `0x${string}` | null {
   const raw = env[name];
   if (raw === undefined || raw === '') return null;
@@ -88,23 +152,31 @@ function address(env: Env, name: string): `0x${string}` | null {
  *   GATE_ORIGIN              required; this gate's own public https origin (the SIWE audience)
  *   ALLOWED_ORIGINS          required; comma-separated origins that may call this gate
  *   PORT                     default 8790
- *   POSITION_MANAGER         optional address-book override
+ *   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
- *   FLAUNCH_VARIANT          optional; only meaningful alongside the overrides
+ *   POOL_SWAP                optional address-book override; required for a v1_3 stack
+ *   FLETH                    optional address-book override; the chain's flETH wrapper
+ *   FLAUNCH_VARIANT          optional; v1_2, multichain or v1_3
  *   SETTLER                  optional; defaults to the signing key's own address
- *   WALLET_CAP_WEI           default 0.025 ETH
+ *   WALLET_CAP_WEI           default 0.025 ETH; the cap for ETH-paired launches
  *   ROUND_MS                 default 90000
  *   MIN_LOBBY_LEAD_MS        default 60000
  *   GATE_ENDS_AT_GRACE_S     default 10
  *   POINTS_PER_DOLLAR        default 100
- *   USD_PER_ETH              default 3000
+ *   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.
  */
 export function resolveGateEnv(env: Env): ResolvedGateConfig {
   const chainId = Number(required(env, 'CHAIN_ID'));
   if (!Number.isSafeInteger(chainId) || chainId <= 0) throw new Error('CHAIN_ID must be a positive integer');
 
-  const recorded = deploymentFor(chainId);
-  const positionManager = address(env, 'POSITION_MANAGER') ?? recorded?.positionManager ?? null;
+  const namedManager = address(env, 'POSITION_MANAGER');
+  // Naming a manager picks the recorded stack it belongs to — calculator and router with it — so a
+  // paired manager is never paired with the legacy calculator by a half-edited env file.
+  const recorded = deploymentFor(chainId, namedManager);
+  const positionManager = namedManager ?? recorded?.positionManager ?? null;
   const spendGatedCalculator = address(env, 'SPEND_GATED_CALCULATOR') ?? recorded?.spendGatedCalculator ?? null;
   if (!positionManager || !spendGatedCalculator) {
     throw new Error(
@@ -113,10 +185,20 @@ export function resolveGateEnv(env: Env): ResolvedGateConfig {
     );
   }
   const variantOverride = env['FLAUNCH_VARIANT'];
-  if (variantOverride !== undefined && variantOverride !== 'legacy11' && variantOverride !== 'current9') {
-    throw new Error(`FLAUNCH_VARIANT must be legacy11 or current9, not ${variantOverride}`);
+  if (
+    variantOverride !== undefined &&
+    variantOverride !== 'v1_2' &&
+    variantOverride !== 'multichain' &&
+    variantOverride !== 'v1_3'
+  ) {
+    throw new Error(`FLAUNCH_VARIANT must be v1_2, multichain or v1_3, not ${variantOverride}`);
   }
-  const flaunchVariant = variantOverride ?? recorded?.flaunchVariant ?? 'legacy11';
+  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');
+  }
+  const fleth = address(env, 'FLETH') ?? recorded?.fleth ?? null;
 
   const signerPrivateKey = required(env, 'SIGNER_PRIVATE_KEY');
   if (!/^0x[0-9a-fA-F]{64}$/.test(signerPrivateKey)) {
@@ -150,17 +232,50 @@ export function resolveGateEnv(env: Env): ResolvedGateConfig {
     gateOrigin: required(env, 'GATE_ORIGIN'),
     allowedOrigins,
     port: integer(env, 'PORT', 8790),
-    deployment: { positionManager, spendGatedCalculator, flaunchVariant },
-    walletCapWei: BigInt(env['WALLET_CAP_WEI'] ?? 25_000_000_000_000_000n.toString()),
+    deployment: {
+      positionManager,
+      spendGatedCalculator,
+      flaunchVariant,
+      ...(poolSwap ? { poolSwap } : {}),
+      ...(fleth ? { fleth } : {}),
+    },
+    walletCap: BigInt(env['WALLET_CAP_WEI'] ?? 25_000_000_000_000_000n.toString()),
     roundDurationMs: integer(env, 'ROUND_MS', 90_000),
     minLobbyLeadMs: integer(env, 'MIN_LOBBY_LEAD_MS', 60_000),
     gateEndsAtGraceS: integer(env, 'GATE_ENDS_AT_GRACE_S', 10),
     pointsPerDollar: integer(env, 'POINTS_PER_DOLLAR', 100),
-    usdPerEth: integer(env, 'USD_PER_ETH', 3_000),
+    usdPerEth: positiveNumber(env, 'USD_PER_ETH', 3_000),
+    spendTokens: spendTokens(env),
     settler: address(env, 'SETTLER'),
   };
 }
 
+const erc20 = parseAbi(['function symbol() view returns (string)', 'function decimals() view returns (uint8)']);
+
+/** Whether a paired token is ETH by another name: native, or the chain's flETH wrapper. */
+function isEthEquivalent(token: SpendToken, fleth: `0x${string}` | undefined): boolean {
+  return token.isNative || (fleth !== undefined && token.address.toLowerCase() === fleth.toLowerCase());
+}
+
+/**
+ * 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.
+ */
+function priceList(config: ResolvedGateConfig, override: PriceFor | undefined): PriceFor {
+  return async (token) => {
+    if (override) {
+      const quoted = await override(token);
+      if (quoted !== null) return quoted;
+    }
+    const listed = config.spendTokens.get(token.address.toLowerCase());
+    if (listed) return listed.usdPerToken;
+    if (isEthEquivalent(token, config.deployment.fleth)) return config.usdPerEth;
+    return null;
+  };
+}
+
 export interface StartedGate {
   app: FastifyInstance;
   port: number;
@@ -175,6 +290,11 @@ export interface StartGateOverrides {
   client?: PublicClient;
   /** False builds and checks everything but never binds a port. */
   listen?: boolean;
+  /**
+   * A price source consulted before `SPEND_TOKENS` — an oracle, or a test's constant. Answering
+   * null defers to the env list; a token neither knows is refused at adoption.
+   */
+  priceProvider?: PriceFor;
 }
 
 export async function startGate<Config, State, Event, Action, PublicView, PlayerView>(
@@ -183,13 +303,14 @@ export async function startGate<Config, State, Event, Action, PublicView, Player
   overrides: StartGateOverrides = {},
 ): Promise<StartedGate> {
   const config = resolveGateEnv(overrides.env ?? process.env);
+  const maxPointsPerPlayer = game.rewardBounds(gameConfig).maxPointsPerPlayer;
 
   // The same refusal the demo makes: an economy that cannot pay out is caught before anyone plays.
   const economy = resolveEconomy({
-    maxPointsPerPlayer: game.rewardBounds(gameConfig).maxPointsPerPlayer,
-    walletCapWei: config.walletCapWei,
+    maxPointsPerPlayer,
+    walletCap: config.walletCap,
     pointsPerDollar: config.pointsPerDollar,
-    usdPerEth: config.usdPerEth,
+    usdPerSpendToken: config.usdPerEth,
   });
   if (!economy.ok) {
     throw new Error(
@@ -203,8 +324,46 @@ export async function startGate<Config, State, Event, Action, PublicView, Player
     signerPrivateKey: config.signerPrivateKey,
     spendGatedCalculator: config.deployment.spendGatedCalculator,
     sessionSecret: config.sessionSecret,
+    positionManager: config.deployment.positionManager,
+    flaunchVariant: config.deployment.flaunchVariant,
+    ...(config.deployment.poolSwap ? { poolSwap: config.deployment.poolSwap } : {}),
   });
 
+  // Each listed spend token: read what the chain says it is, and refuse an economy that does not
+  // fit its cap now, at boot, rather than at the first launch somebody has already paid for.
+  const announcedSpendTokens: AnnouncedSpendToken[] = [];
+  for (const pricing of config.spendTokens.values()) {
+    let symbol: string;
+    let decimals: number;
+    try {
+      [symbol, decimals] = await Promise.all([
+        client.readContract({ address: pricing.address, abi: erc20, functionName: 'symbol' }),
+        client.readContract({ address: pricing.address, abi: erc20, functionName: 'decimals' }).then(Number),
+      ]);
+    } catch {
+      throw new Error(`SPEND_TOKENS: ${pricing.address} does not answer symbol()/decimals() on chain ${config.chainId}`);
+    }
+    const fit = resolveEconomy({
+      maxPointsPerPlayer,
+      walletCap: pricing.walletCap,
+      pointsPerDollar: config.pointsPerDollar,
+      usdPerSpendToken: pricing.usdPerToken,
+      decimals,
+    });
+    if (!fit.ok) {
+      throw new Error(
+        `That economy does not work for ${symbol}: ${fit.problem}. Try ${fit.suggestedPointsPerDollar} points per dollar.`,
+      );
+    }
+    announcedSpendTokens.push({
+      address: pricing.address,
+      symbol,
+      decimals,
+      usdPerToken: pricing.usdPerToken,
+      walletCap: pricing.walletCap.toString(),
+    });
+  }
+
   const pool = new pg.Pool({ connectionString: config.databaseUrl });
   await migrate(pool);
 
@@ -217,14 +376,16 @@ export async function startGate<Config, State, Event, Action, PublicView, Player
     contracts: {
       positionManager: config.deployment.positionManager,
       spendGatedCalculator: config.deployment.spendGatedCalculator,
+      ...(config.deployment.poolSwap ? { poolSwap: config.deployment.poolSwap } : {}),
     },
     signer: signer.address,
     settler,
-    walletCapWei: config.walletCapWei.toString(),
+    walletCap: config.walletCap.toString(),
     roundDurationMs: config.roundDurationMs,
     minLobbyLeadMs: config.minLobbyLeadMs,
     gateEndsAtGraceS: config.gateEndsAtGraceS,
     flaunchVariant: config.deployment.flaunchVariant,
+    ...(announcedSpendTokens.length > 0 ? { spendTokens: announcedSpendTokens } : {}),
     requiresEoa: false,
     accepting: true,
     publicLaunchesOpen: true,
@@ -237,6 +398,7 @@ export async function startGate<Config, State, Event, Action, PublicView, Player
     config: gameConfig,
     pointsPerDollar: config.pointsPerDollar,
     usdPerEth: config.usdPerEth,
+    priceFor: priceList(config, overrides.priceProvider),
     sessions: new Sessions(config.sessionSecret, config.signInDomain, config.gateOrigin),
     claims: new Claims(pool, ledger, signer),
     discovery: new Discovery(client, {

package/src/room.ts

@@ -1,7 +1,7 @@
 import type { Pool } from 'pg';
 import { Round } from '@flayerlabs/gamemode-spec/round';
 import type { Award, Command, Decision, GameModule, PlayerId, Refusal, RoundWindow } from '@flayerlabs/gamemode-spec';
-import type { LaunchContext, RoundTerms } from '@flayerlabs/gamemode-spec/live';
+import { ETH_SPEND_TOKEN, type LaunchContext, type RoundTerms, type SpendToken } from '@flayerlabs/gamemode-spec/live';
 import { isRefusal } from '@flayerlabs/gamemode-spec';
 import { inTransaction, toBigInt } from './store.js';
 
@@ -52,10 +52,13 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
       config: Config;
       seed: number;
       window: RoundWindow;
-      weiPerPoint: bigint;
-      walletCapWei: bigint;
+      unitsPerPoint: bigint;
+      walletCap: bigint;
       pointsPerDollar: number;
-      usdPerEth: number;
+      /** The token spend is measured in. Defaults to ETH — a flETH- or ETH-paired round. */
+      spendToken?: SpendToken;
+      /** The market price of one whole spend token, in dollars, at adoption. */
+      usdPerSpendToken: number;
       maxPointsPerPlayer: number;
       scoreAuthority: ScoreAuthority;
       poolId: string;
@@ -86,28 +89,39 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
       closesAt: round.window.closesAt,
       booksCloseAt,
     });
+    const spendToken: SpendToken = Object.freeze({ ...(round.spendToken ?? ETH_SPEND_TOKEN) });
     const terms: RoundTerms = Object.freeze({
       maxPointsPerPlayer: round.maxPointsPerPlayer,
-      walletCapWei: round.walletCapWei,
-      weiPerPoint: round.weiPerPoint,
+      walletCap: round.walletCap,
+      unitsPerPoint: round.unitsPerPoint,
       pointsPerDollar: round.pointsPerDollar,
-      usdPerEth: round.usdPerEth,
+      usdPerSpendToken: round.usdPerSpendToken,
+      spendToken,
     });
     const started = Round.start(game, round.config, round.seed, round.window);
+    // The columns keep their original wei-flavoured names while the API does not. Renaming them
+    // would be a migration with no reader outside this file, so the divergence is deliberate:
+    // wei_per_point is unitsPerPoint, wallet_cap_wei is walletCap, and usd_per_spend_token is
+    // usdPerSpendToken. usd_per_eth is a legacy column, written for provenance only.
     await pool.query(
       `insert into rounds (
          id, game_id, wei_per_point, 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,
          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, 0)`,
+       ) values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, 0)`,
       [
         round.id,
         game.id,
-        round.weiPerPoint.toString(),
-        round.walletCapWei.toString(),
+        round.unitsPerPoint.toString(),
+        round.walletCap.toString(),
         round.pointsPerDollar,
-        round.usdPerEth,
+        round.usdPerSpendToken,
+        spendToken.address.toLowerCase(),
+        spendToken.symbol,
+        spendToken.decimals,
+        round.usdPerSpendToken,
         round.maxPointsPerPlayer,
         round.scoreAuthority,
         round.poolId,
@@ -155,12 +169,17 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
       wallet_cap_wei: string;
       points_per_dollar: number;
       usd_per_eth: number;
+      spend_token: string;
+      spend_symbol: string;
+      spend_decimals: number;
+      usd_per_spend_token: number | null;
       max_points_per_player: string;
       score_authority: ScoreAuthority;
       game_id: string;
     }>(
       `select state, seq, pool_id, opens_at, closes_at, books_close_at, wei_per_point,
               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
        from rounds where id = $1`,
@@ -183,10 +202,18 @@ export class Room<Config, State, Event, Action, PublicView, PlayerView> {
     });
     const terms: RoundTerms = Object.freeze({
       maxPointsPerPlayer: Number(row.max_points_per_player),
-      walletCapWei: toBigInt(row.wallet_cap_wei),
-      weiPerPoint: toBigInt(row.wei_per_point),
+      walletCap: toBigInt(row.wallet_cap_wei),
+      unitsPerPoint: toBigInt(row.wei_per_point),
       pointsPerDollar: Number(row.points_per_dollar),
-      usdPerEth: Number(row.usd_per_eth),
+      spendToken: Object.freeze({
+        address: row.spend_token,
+        symbol: row.spend_symbol,
+        decimals: Number(row.spend_decimals),
+        isNative: row.spend_token.toLowerCase() === ETH_SPEND_TOKEN.address,
+      }),
+      // usd_per_eth is the legacy column: on a row written before the spend-token columns existed
+      // it holds that round's ETH price, which is exactly its spend token's price.
+      usdPerSpendToken: row.usd_per_spend_token === null ? Number(row.usd_per_eth) : Number(row.usd_per_spend_token),
     });
     return new Room(
       pool,