@flayerlabs/gamemode-gate 0.4.3 → 0.5.0

package/src/server.ts

@@ -8,10 +8,12 @@ import type {
   EconomyBalance,
   PresenceState,
   RoundTerms,
+  SpendToken,
   WireEconomyBalance,
   WireRoundTerms,
 } from '@flayerlabs/gamemode-spec/live';
-import { isReactionId, LIVE_PROTOCOL_VERSION } from '@flayerlabs/gamemode-spec/live';
+import { ETH_SPEND_TOKEN, isReactionId, LIVE_PROTOCOL_VERSION } from '@flayerlabs/gamemode-spec/live';
+import type { FlaunchVariant } from './chain/chains.js';
 import { Room, type ScoreAuthority } from './room.js';
 import { CLAIM_AUTHORIZATION_TTL_MS, Claims, isClaimAmount, isClaimRequestId } from './claims.js';
 import { NotSignedIn, Sessions } from './sessions.js';
@@ -42,7 +44,15 @@ interface GateBaseOptions {
   claims: Claims;
   /** How many points a dollar buys. The only economic number anyone sets by hand. */
   pointsPerDollar: number;
+  /** The price of ETH — what an ETH-paired round is priced at. */
   usdPerEth: number;
+  /**
+   * The price of one whole spend token, for a round whose coin is paired with something other
+   * than ETH — or null to refuse the launch as unpriced. Consulted at adoption with the token the
+   * chain reported. Omitted, only native ETH is priced (at `usdPerEth`) and every other pairing is
+   * refused: a gate that guessed a price would be authorising real money on a made-up number.
+   */
+  priceFor?: PriceFor;
   /** 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. */
@@ -85,6 +95,20 @@ interface GateBaseOptions {
   reactionIds?: readonly string[];
 }
 
+/** A price for one whole spend token in dollars, or null when this gate has none for it. */
+export type PriceFor = (token: SpendToken) => Promise<number | null> | number | null;
+
+/** One entry of a gate's announced price list — what launch tooling checks a pairing against. */
+export interface AnnouncedSpendToken {
+  address: `0x${string}`;
+  symbol: string;
+  decimals: number;
+  /** The price this gate will fix rounds on that token at. */
+  usdPerToken: number;
+  /** The per-wallet cap the launch should write, in this token's base units. A decimal string. */
+  walletCap: string;
+}
+
 /** Resolve one immutable rules config after the launch has been verified. */
 export type VerifiedLaunch = Readonly<Omit<Launch, 'poolKey'>> & { readonly poolKey: Readonly<PoolKey> };
 export type ConfigForLaunch<Config> = (launch: VerifiedLaunch) => Promise<Config>;
@@ -118,17 +142,25 @@ export interface GateAnnouncement {
   contracts: {
     positionManager: `0x${string}`;
     spendGatedCalculator: `0x${string}`;
+    /** The approved swap router a paired-token buy goes through. Present on a `v1_3` stack. */
+    poolSwap?: `0x${string}`;
   };
   /** The address launches must name as their trusted signer for this gate to adopt them. */
   signer: `0x${string}`;
   /** May lift the gate early or rotate the signer on-chain; the launch writes it into the pool. */
   settler: `0x${string}`;
-  /** A decimal string — wei does not survive JSON as a number. */
-  walletCapWei: string;
+  /** The per-wallet cap for an ETH-paired launch, in wei. A decimal string — wei does not survive JSON as a number. */
+  walletCap: string;
   roundDurationMs: number;
   minLobbyLeadMs: number;
   gateEndsAtGraceS: number;
-  flaunchVariant: 'legacy11' | 'current9';
+  flaunchVariant: FlaunchVariant;
+  /**
+   * 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[];
   requiresEoa: boolean;
   accepting: boolean;
   /**
@@ -170,22 +202,26 @@ const ADMIT_ALL: Admit = () => ({ ok: true });
 /** What the socket says, which is only the truth when nothing is proxying in front of the gate. */
 const ipOf = (request: FastifyRequest): string | null => request.ip || null;
 
-/** Wei has no JSON form, so terms cross as decimal strings, exactly as the economy balance does. */
+/** Bigint has no JSON form, so terms cross as decimal strings, exactly as the economy balance does. */
 const wireTerms = (terms: RoundTerms): WireRoundTerms => ({
   maxPointsPerPlayer: terms.maxPointsPerPlayer,
-  walletCapWei: terms.walletCapWei.toString(),
-  weiPerPoint: terms.weiPerPoint.toString(),
+  walletCap: terms.walletCap.toString(),
+  unitsPerPoint: terms.unitsPerPoint.toString(),
   pointsPerDollar: terms.pointsPerDollar,
-  usdPerEth: terms.usdPerEth,
+  usdPerSpendToken: terms.usdPerSpendToken,
+  spendToken: terms.spendToken,
 });
 
+/** Only native ETH is priced without being told: everything else needs a `priceFor`. */
+const ethOnly = (usdPerEth: number): PriceFor => (token) => (token.isNative ? usdPerEth : null);
+
 /** The same encoding for the per-player balance, wherever it leaves the process. */
 const wireEconomy = (balance: EconomyBalance): WireEconomyBalance => ({
-  weiPerPoint: balance.weiPerPoint.toString(),
-  earnedWei: balance.earnedWei.toString(),
-  heldWei: balance.heldWei.toString(),
-  spentWei: balance.spentWei.toString(),
-  availableWei: balance.availableWei.toString(),
+  unitsPerPoint: balance.unitsPerPoint.toString(),
+  earned: balance.earned.toString(),
+  held: balance.held.toString(),
+  spent: balance.spent.toString(),
+  available: balance.available.toString(),
   holdExpiresAt: balance.holdExpiresAt,
 });
 
@@ -389,11 +425,27 @@ function createGateRuntime<Config, State, Event, Action, PublicView, PlayerView>
       app.log.error(error);
       return { ok: false, status: 503, message: 'this game is still being prepared' };
     }
+    // The token the chain measures this pool's spend in decides the round's units. A launch this
+    // gate has no price for is refused rather than priced as ETH: on a six-decimal token that guess
+    // authorises a trillion times the intended spend.
+    const spendToken = launch.spendToken ?? ETH_SPEND_TOKEN;
+    let usdPerSpendToken: number | null;
+    try {
+      usdPerSpendToken = await (options.priceFor ?? ethOnly(options.usdPerEth))(spendToken);
+    } catch (error) {
+      app.log.error(error);
+      return { ok: false, status: 503, message: 'this game is still being prepared' };
+    }
+    if (usdPerSpendToken === null || !Number.isFinite(usdPerSpendToken) || usdPerSpendToken <= 0) {
+      app.log.error(`${launch.coinAddress}: no price for spend token ${spendToken.symbol} (${spendToken.address})`);
+      return { ok: false, status: 409, message: `this game is not set up for ${spendToken.symbol} yet` };
+    }
     const economy = resolveEconomy({
       maxPointsPerPlayer,
-      walletCapWei: launch.walletCapWei,
+      walletCap: launch.walletCap,
       pointsPerDollar: options.pointsPerDollar,
-      usdPerEth: options.usdPerEth,
+      usdPerSpendToken,
+      decimals: spendToken.decimals,
     });
     if (!economy.ok) {
       app.log.error(
@@ -409,10 +461,11 @@ function createGateRuntime<Config, State, Event, Action, PublicView, PlayerView>
         config,
         seed: Number(BigInt(launch.poolId) % 2147483647n),
         window: { opensAt: launch.opensAt, closesAt: launch.closesAt },
-        weiPerPoint: economy.economy.weiPerPoint,
+        unitsPerPoint: economy.economy.unitsPerPoint,
         pointsPerDollar: economy.economy.pointsPerDollar,
-        usdPerEth: economy.economy.usdPerEth,
-        walletCapWei: launch.walletCapWei,
+        spendToken,
+        usdPerSpendToken: economy.economy.usdPerSpendToken,
+        walletCap: launch.walletCap,
         maxPointsPerPlayer,
         scoreAuthority,
         poolId: launch.poolId,
@@ -499,22 +552,41 @@ function createGateRuntime<Config, State, Event, Action, PublicView, PlayerView>
    */
   app.get('/stats', async (_request, reply) => {
     void reply.header('access-control-allow-origin', '*');
-    const { rows } = await pool.query<{
-      rounds_total: string;
-      players_total: string;
-      spend_wei_total: string;
-      last_round_at: string | null;
-    }>(
-      `select (select count(*) from rounds)                                   as rounds_total,
-              (select count(distinct player) from balances)                   as players_total,
-              (select coalesce(sum(chain_spent_wei), 0)::text from balances)  as spend_wei_total,
-              (select max(opens_at) from rounds)                              as last_round_at`,
-    );
+    // Spend is summed per spend token: base units of two different tokens do not add. The flat
+    // `spendWeiTotal` keeps its original meaning — wei, across ETH rounds — for dashboards built
+    // against it; `spendByToken` is the honest figure for a gate that runs more than one pairing.
+    const [{ rows }, byToken] = await Promise.all([
+      pool.query<{
+        rounds_total: string;
+        players_total: string;
+        spend_wei_total: string;
+        last_round_at: string | null;
+      }>(
+        `select (select count(*) from rounds)                                   as rounds_total,
+                (select count(distinct player) from balances)                   as players_total,
+                (select coalesce(sum(b.chain_spent_wei), 0)::text
+                   from balances b join rounds r on r.id = b.round_id
+                  where r.spend_decimals = 18)                                  as spend_wei_total,
+                (select max(opens_at) from rounds)                              as last_round_at`,
+      ),
+      pool.query<{ spend_token: string; spend_symbol: string; spend_decimals: number; total: string }>(
+        `select r.spend_token, r.spend_symbol, r.spend_decimals, coalesce(sum(b.chain_spent_wei), 0)::text as total
+           from rounds r left join balances b on b.round_id = r.id
+          group by r.spend_token, r.spend_symbol, r.spend_decimals
+          order by r.spend_token`,
+      ),
+    ]);
     const totals = rows[0]!;
     return {
       roundsTotal: Number(totals.rounds_total),
       playersTotal: Number(totals.players_total),
       spendWeiTotal: totals.spend_wei_total,
+      spendByToken: byToken.rows.map((row) => ({
+        address: row.spend_token,
+        symbol: row.spend_symbol,
+        decimals: Number(row.spend_decimals),
+        total: row.total,
+      })),
       lastRoundAt: totals.last_round_at === null ? null : Number(totals.last_round_at),
     };
   });
@@ -672,7 +744,7 @@ function createGateRuntime<Config, State, Event, Action, PublicView, PlayerView>
         return reply.code(result.refuse === 'award.invalid' ? 400 : 404).send({ refuse: result.refuse });
       }
 
-      // `heldWei` moves on its own when an authorisation expires, so this answer is only true at the
+      // `held` moves on its own when an authorisation expires, so this answer is only true at the
       // moment it is read. Points are monotone; the wei beside them are not.
       const balance = await claims.economyBalance(result.standing.roundId, result.standing.player);
       return reply
@@ -869,11 +941,11 @@ function createGateRuntime<Config, State, Event, Action, PublicView, PlayerView>
       const balance = viewer
         ? await claims.economyBalance(id, viewer)
         : {
-            weiPerPoint: room.terms.weiPerPoint,
-            earnedWei: 0n,
-            heldWei: 0n,
-            spentWei: 0n,
-            availableWei: 0n,
+            unitsPerPoint: room.terms.unitsPerPoint,
+            earned: 0n,
+            held: 0n,
+            spent: 0n,
+            available: 0n,
             holdExpiresAt: null,
           };
       const economy = wireEconomy(balance);

package/src/store.ts

@@ -18,6 +18,15 @@ create table if not exists rounds (
   -- was priced at.
   points_per_dollar double precision not null check (points_per_dollar > 0),
   usd_per_eth       double precision not null check (usd_per_eth > 0),
+  -- The token spend is measured in: the coin's paired token, in whose base units every *_wei column
+  -- of this round is denominated. Defaults describe ETH, which is what every round was before the
+  -- columns existed, so a pre-existing row reads back exactly as it was priced. usd_per_eth holds
+  -- the rate normalised to eighteen decimals (see economy.ts); usd_per_spend_token the token's own
+  -- price, null on rows that predate it (for which usd_per_eth is that price).
+  spend_token    text not null default '0x0000000000000000000000000000000000000000' check (spend_token <> ''),
+  spend_symbol   text not null default 'ETH' check (spend_symbol <> ''),
+  spend_decimals integer not null default 18 check (spend_decimals between 0 and 36),
+  usd_per_spend_token double precision check (usd_per_spend_token > 0),
   max_points_per_player bigint not null check (max_points_per_player > 0),
   score_authority text not null check (score_authority in ('rules', 'external-server')),
   pool_id        text not null,
@@ -68,6 +77,18 @@ alter table rounds alter column score_authority set not null;
 alter table rounds alter column points_per_dollar set not null;
 alter table rounds alter column usd_per_eth set not null;
 
+-- Paired-token rounds (0.5.0). Every earlier round was an ETH round, so the defaults ARE the
+-- backfill: Postgres fills a new not-null column with its default, and ETH/18 is exactly what those
+-- rows were priced in. No guard is needed — nothing here has to be guessed.
+alter table rounds
+  add column if not exists spend_token text not null default '0x0000000000000000000000000000000000000000' check (spend_token <> '');
+alter table rounds
+  add column if not exists spend_symbol text not null default 'ETH' check (spend_symbol <> '');
+alter table rounds
+  add column if not exists spend_decimals integer not null default 18 check (spend_decimals between 0 and 36);
+alter table rounds
+  add column if not exists usd_per_spend_token double precision check (usd_per_spend_token > 0);
+
 create table if not exists balances (
   round_id text not null references rounds(id) on delete cascade,
   player   text not null,