@flayerlabs/gamemode-gate 0.4.3 → 0.5.0

package/src/chain/discover.ts

@@ -1,4 +1,5 @@
 import { encodeAbiParameters, keccak256, parseAbi, type PublicClient } from 'viem';
+import { ETH_SPEND_TOKEN, type SpendToken } from '@flayerlabs/gamemode-spec/live';
 
 /**
  * All this needs of a client: the ability to read a contract.
@@ -20,6 +21,12 @@ export type ChainReader = Pick<PublicClient, 'readContract'>;
  * launch's own gate parameters, and that is public state the creator paid to write and nobody else
  * 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.
  */
 
 const poolKeyComponents = [
@@ -39,17 +46,28 @@ export const positionManagerAbi = [
     outputs: [{ name: '', type: 'tuple', components: poolKeyComponents }],
   },
   // The scheduled open of the buy window; 0 once the pool is tradeable.
-  ...parseAbi(['function flaunchesAt(bytes32 _poolId) view returns (uint256)']),
+  ...parseAbi([
+    'function flaunchesAt(bytes32 _poolId) view returns (uint256)',
+    // V1_3 only: the token the pool is paired with. A legacy manager has no such function; a revert
+    // there is read as "flETH", which is the only pairing that generation can produce.
+    'function pairedToken(bytes32 _poolId) view returns (address)',
+  ]),
 ] as const;
 
 export const spendGatedAbi = parseAbi([
   // Four fields. Decoding a four-word return against a shorter ABI is how a check quietly reads the
   // wrong value, so this must match the DEPLOYED calculator rather than the newest source.
-  'function spendGateSettings(bytes32 _poolId) view returns (bool enabled, uint256 walletCapWei, address settler, uint256 endsAt)',
+  'function spendGateSettings(bytes32 _poolId) view returns (bool enabled, uint256 walletCap, address settler, uint256 endsAt)',
   'function trustedPoolKeySigner(bytes32 _poolId) view returns (address signer, bool enabled)',
 ]);
 
-const erc20 = parseAbi(['function name() view returns (string)', 'function symbol() view returns (string)']);
+const erc20 = parseAbi([
+  'function name() view returns (string)',
+  'function symbol() view returns (string)',
+  'function decimals() view returns (uint8)',
+]);
+
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 
 export interface PoolKey {
   currency0: `0x${string}`;
@@ -67,11 +85,17 @@ export interface Launch {
   opensAt: number;
   /** When the gate stops enforcing on chain, in epoch ms. */
   closesAt: number;
-  walletCapWei: bigint;
+  /** In base units of `spendToken`. */
+  walletCap: bigint;
   signer: `0x${string}`;
   name: string;
   symbol: string;
   imageUrl?: string | null;
+  /**
+   * 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.
+   */
+  spendToken?: SpendToken;
 }
 
 /**
@@ -166,7 +190,7 @@ export async function verifyLaunch(
     return refuse('launch.unreadable', true);
   }
 
-  const [enabled, walletCapWei, , endsAt] = settings;
+  const [enabled, walletCap, , endsAt] = settings;
   const [signer, signerEnabled] = trusted;
 
   if (!enabled) return refuse('launch.not_a_game', false);
@@ -174,12 +198,15 @@ export async function verifyLaunch(
   if (!signerEnabled || signer.toLowerCase() !== deployment.signer.toLowerCase()) {
     return refuse('launch.another_signer', false);
   }
-  if (walletCapWei <= 0n) return refuse('launch.no_spending_cap', false);
+  if (walletCap <= 0n) return refuse('launch.no_spending_cap', false);
 
   const opensAt = Number(flaunchesAt) * 1000;
   const closesAt = Number(endsAt) * 1000;
   if (closesAt <= Date.now()) return refuse('launch.already_over', false);
 
+  const spendToken = await resolveSpendToken(client, deployment, memecoin, poolKey, poolId);
+  if (!spendToken) return refuse('launch.paired_unreadable', true);
+
   let name = '';
   let symbol = '';
   try {
@@ -192,7 +219,60 @@ export async function verifyLaunch(
     // display string would be refusing a round for no reason anyone could act on.
   }
 
-  return { ok: true, coinAddress: memecoin, poolId, poolKey, opensAt, closesAt, walletCapWei, signer, name, symbol };
+  return {
+    ok: true,
+    coinAddress: memecoin,
+    poolId,
+    poolKey,
+    opensAt,
+    closesAt,
+    walletCap,
+    signer,
+    name,
+    symbol,
+    spendToken,
+  };
+}
+
+/**
+ * Which token this pool's spend is measured in.
+ *
+ * The calculator measures spend on the pool's PAIRED side, so the gate's cap and allocations must
+ * be in that token's base units — a six-decimal stablecoin priced as if it were wei authorises a
+ * trillion times too much. Asked of the manager first (`pairedToken`, V1_3), and derived from the
+ * pool key when the manager predates the function: the key names two currencies and one of them
+ * is the coin. Decimals are load-bearing, so unlike the coin's cosmetic name an unreadable token
+ * is a refusal — retryable, because an RPC blip is not a statement about the token.
+ */
+async function resolveSpendToken(
+  client: ChainReader,
+  deployment: Deployment,
+  memecoin: `0x${string}`,
+  poolKey: PoolKey,
+  poolId: `0x${string}`,
+): Promise<SpendToken | null> {
+  let paired: `0x${string}`;
+  try {
+    paired = (await client.readContract({
+      address: deployment.positionManager,
+      abi: positionManagerAbi,
+      functionName: 'pairedToken',
+      args: [poolId],
+    })) as `0x${string}`;
+  } catch {
+    paired = poolKey.currency0.toLowerCase() === memecoin.toLowerCase() ? poolKey.currency1 : poolKey.currency0;
+  }
+  if (paired.toLowerCase() === ZERO_ADDRESS) return ETH_SPEND_TOKEN;
+
+  try {
+    const [symbol, decimals] = (await Promise.all([
+      client.readContract({ address: paired, abi: erc20, functionName: 'symbol' }),
+      client.readContract({ address: paired, abi: erc20, functionName: 'decimals' }),
+    ])) as [string, number];
+    return { address: paired, symbol, decimals: Number(decimals), isNative: false };
+  } catch {
+    return null;
+  }
 }
 
 /**

package/src/chain/secure.ts

@@ -1,4 +1,5 @@
-import type { PublicClient } from 'viem';
+import { keccak256, parseAbi, toHex, type PublicClient } from 'viem';
+import type { FlaunchVariant } from './chains.js';
 
 /**
  * The boot-time refusals {@link PayloadSigner}'s doc comment promises.
@@ -16,11 +17,28 @@ const ZERO_KEY = `0x${'00'.repeat(32)}`;
 /** The demo's session-secret fallback, which every copy of this repo shares. */
 export const DEMO_SESSION_SECRET = 'dev-secret-that-is-long-enough-to-pass';
 
+/** `ProtocolRoles.POSITION_MANAGER` in flaunch-contracts: the role a calculator demands of its caller. */
+export const POSITION_MANAGER_ROLE = keccak256(toHex('PositionManager'));
+
+const wiringAbi = parseAbi([
+  'function feeCalculator() view returns (address)',
+  'function registeredCalculators(address) view returns (bool)',
+  'function hasRole(bytes32 role, address account) view returns (bool)',
+  'function approvedRouters(address) view returns (bool)',
+]);
+
 export interface SecureConfig {
   chainId: number;
   signerPrivateKey: string;
   spendGatedCalculator: `0x${string}`;
   sessionSecret: string;
+  /**
+   * When given, the wiring between the manager and the calculator is read back and asserted — see
+   * {@link assertWiring}. Optional so a caller that only wants the key and chain checks keeps them.
+   */
+  positionManager?: `0x${string}`;
+  flaunchVariant?: FlaunchVariant;
+  poolSwap?: `0x${string}`;
 }
 
 export async function assertSecureConfig(client: PublicClient, config: SecureConfig): Promise<void> {
@@ -46,4 +64,71 @@ export async function assertSecureConfig(client: PublicClient, config: SecureCon
   if (!code || code === '0x') {
     throw new Error(`SPEND_GATED_CALCULATOR ${config.spendGatedCalculator} holds no code on chain ${chainId}`);
   }
+
+  if (config.positionManager) await assertWiring(client, config);
+}
+
+/**
+ * The manager must route fees through a dispatcher that knows this 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.
+ */
+async function assertWiring(client: PublicClient, config: SecureConfig): Promise<void> {
+  const manager = config.positionManager!;
+  const calculator = config.spendGatedCalculator;
+
+  let dispatcher: `0x${string}`;
+  try {
+    dispatcher = await client.readContract({ address: manager, abi: wiringAbi, functionName: 'feeCalculator' });
+  } catch {
+    throw new Error(`POSITION_MANAGER ${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),
+  ]);
+  if (!registered) {
+    throw new Error(
+      `the fee dispatcher ${dispatcher} of POSITION_MANAGER ${manager} does not have SPEND_GATED_CALCULATOR ` +
+        `${calculator} registered — its owner must call setCalculatorRegistered(${calculator}, true) before ` +
+        'this gate 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})`,
+    );
+  }
+
+  if (config.flaunchVariant === 'v1_3') {
+    if (!config.poolSwap) {
+      throw new Error('a v1_3 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] })
+      .catch(() => false);
+    if (!approved) {
+      throw new Error(
+        `SPEND_GATED_CALCULATOR ${calculator} has not approved POOL_SWAP ${config.poolSwap} as a router — ` +
+          `its owner must call setApprovedRouter(${config.poolSwap}, true)`,
+      );
+    }
+  }
 }

package/src/claims.ts

@@ -116,8 +116,8 @@ export class Claims {
   }
 
   /** What this player could spend right now. */
-  availableWei(roundId: string, player: PlayerId): Promise<bigint> {
-    return this.ledger.availableWei(roundId, player);
+  available(roundId: string, player: PlayerId): Promise<bigint> {
+    return this.ledger.available(roundId, player);
   }
 
   /** Full authoritative balance for live snapshots. */

package/src/demo.ts

@@ -41,7 +41,7 @@ export interface DemoOptions<Config, State, Event, Action, PublicView, PlayerVie
   lobbyMs?: number;
   roundMs?: number;
   /** The cap a wallet may spend, as a real launch would set on chain. Default 0.025 ETH. */
-  walletCapWei?: bigint;
+  walletCap?: bigint;
   pointsPerDollar?: number;
   usdPerEth?: number;
   roundId?: string;
@@ -83,7 +83,7 @@ export async function createDemoGate<Config, State, Event, Action, PublicView, P
     databaseUrl = process.env.DATABASE_URL ?? 'postgres://postgres:gamemode@127.0.0.1:55439/gamemode',
     lobbyMs = 8_000,
     roundMs = 10 * 60_000,
-    walletCapWei = ETH / 40n,
+    walletCap = ETH / 40n,
     pointsPerDollar = 100,
     usdPerEth = 3_000,
     roundId = 'dev',
@@ -96,9 +96,9 @@ export async function createDemoGate<Config, State, Event, Action, PublicView, P
   const maxPointsPerPlayer = game.rewardBounds(config).maxPointsPerPlayer;
   const economy = resolveEconomy({
     maxPointsPerPlayer,
-    walletCapWei,
+    walletCap,
     pointsPerDollar,
-    usdPerEth,
+    usdPerSpendToken: usdPerEth,
   });
   if (!economy.ok) {
     throw new Error(
@@ -117,10 +117,10 @@ export async function createDemoGate<Config, State, Event, Action, PublicView, P
     config,
     seed: Math.floor(Math.random() * 1_000_000),
     window: { opensAt, closesAt: opensAt + roundMs },
-    weiPerPoint: economy.economy.weiPerPoint,
+    unitsPerPoint: economy.economy.unitsPerPoint,
     pointsPerDollar: economy.economy.pointsPerDollar,
-    usdPerEth: economy.economy.usdPerEth,
-    walletCapWei,
+    usdPerSpendToken: economy.economy.usdPerSpendToken,
+    walletCap,
     maxPointsPerPlayer,
     scoreAuthority: 'rules',
     poolId: DEMO_POOL_ID,
@@ -147,11 +147,11 @@ export async function createDemoGate<Config, State, Event, Action, PublicView, P
       contracts: { positionManager: DEMO_CALCULATOR, spendGatedCalculator: DEMO_CALCULATOR },
       signer: signer.address,
       settler: signer.address,
-      walletCapWei: walletCapWei.toString(),
+      walletCap: walletCap.toString(),
       roundDurationMs: roundMs,
       minLobbyLeadMs: lobbyMs,
       gateEndsAtGraceS: 10,
-      flaunchVariant: 'legacy11',
+      flaunchVariant: 'v1_2',
       requiresEoa: false,
       accepting: true,
       publicLaunchesOpen: true,
@@ -171,7 +171,7 @@ export async function createDemoGate<Config, State, Event, Action, PublicView, P
   app.post('/dev/wallet/buy', (request) => {
     const { maxSpendWei } = request.body as { maxSpendWei: string };
     purchases.push({ maxSpendWei, at: Date.now() });
-    return { spentWei: maxSpendWei };
+    return { spent: maxSpendWei };
   });
 
   return { app, roundId, opensAt, walletAddress: wallet.address, purchases, pool };

package/src/economy.ts

@@ -7,41 +7,68 @@
  * environment variable was wrong, and no code was in a position to notice.
  *
  * So the arithmetic lives here, runs at round creation with the actual values, and refuses. A
- * creator sets one human number — how many points a dollar is worth — and never sees wei.
+ * creator sets one human number — how many points a dollar is worth — and never sees base units.
+ *
+ * Denomination. A pool's spend is measured on chain in its PAIRED token's own base units: wei for
+ * an ETH-paired coin, 10^-6 for a six-decimal stablecoin. Every amount in this package is
+ * therefore base units of the round's spend token, and the arithmetic here is parameterised by
+ * that token's decimals rather than assuming eighteen.
  */
 
-/** 1 ETH in wei. */
+/** The decimals of ETH, which is what every field was denominated in before paired-token rounds. */
+export const ETH_DECIMALS = 18;
+
+/** 1 ETH in wei. Kept as the default `unitsPerToken` so an ETH round is byte-identical to before. */
 const WEI_PER_ETH = 1_000_000_000_000_000_000n;
 
+/** 10^decimals: one whole spend token in its base units. */
+export function unitsPerToken(decimals: number): bigint {
+  return 10n ** BigInt(decimals);
+}
+
 export interface EconomyInput {
   /** The most one player can earn, declared by the game itself via `rewardBounds`. */
   maxPointsPerPlayer: number;
-  /** The pool's on-chain per-wallet ceiling. The chain enforces this whatever we do. */
-  walletCapWei: bigint;
+  /** The pool's on-chain per-wallet ceiling, in base units of the spend token. */
+  walletCap: bigint;
   /** The creator's one knob. 100 means 100 points is worth a dollar. */
   pointsPerDollar: number;
-  usdPerEth: number;
+  /** The market price of one whole spend token, in dollars. For an ETH round this IS the ETH price. */
+  usdPerSpendToken: number;
+  /** Decimals of the spend token. Defaults to 18 — ETH — which is what every older caller meant. */
+  decimals?: number;
 }
 
 export interface Economy {
-  weiPerPoint: bigint;
-  /** What a flawless round pays. Always at or under `walletCapWei`, or this would not exist. */
-  maxPayoutWei: bigint;
+  /** Base units of the spend token per point. */
+  unitsPerPoint: bigint;
+  /** What a flawless round pays. Always at or under `walletCap`, or this would not exist. */
+  maxPayout: bigint;
   /**
-   * The two inputs, returned beside the rate they produced.
+   * The inputs, returned beside the rate they produced.
    *
    * They travel together so a caller cannot persist a rate from one calculation and a dollar
    * figure from another. Both are process-wide settings, so the only place they are true of a
    * particular round is the moment that round's rate was fixed.
    */
   pointsPerDollar: number;
-  usdPerEth: number;
+  /** The market price of one whole spend token — what a display should call the token's price. */
+  usdPerSpendToken: number;
+  /** The spend token's decimals. */
+  decimals: number;
 }
 
 export type EconomyResult =
   | { ok: true; economy: Economy }
   | { ok: false; problem: string; suggestedPointsPerDollar: number };
 
+function resolveInputs(input: EconomyInput): { usdPerSpendToken: number; decimals: number } {
+  return {
+    usdPerSpendToken: input.usdPerSpendToken ?? Number.NaN,
+    decimals: input.decimals ?? ETH_DECIMALS,
+  };
+}
+
 /**
  * Resolve the rate for one round, or refuse with the number that fixes it.
  *
@@ -54,13 +81,25 @@ export type EconomyResult =
  * goes and reads this file.
  */
 export function resolveEconomy(input: EconomyInput): EconomyResult {
-  const { maxPointsPerPlayer, walletCapWei, pointsPerDollar, usdPerEth } = input;
+  const { maxPointsPerPlayer, walletCap, pointsPerDollar } = input;
+  const { usdPerSpendToken, decimals } = resolveInputs(input);
 
   if (!Number.isFinite(pointsPerDollar) || pointsPerDollar <= 0) {
     return { ok: false, problem: 'points per dollar must be a positive number', suggestedPointsPerDollar: 100 };
   }
-  if (!Number.isFinite(usdPerEth) || usdPerEth <= 0) {
-    return { ok: false, problem: 'the ETH price must be a positive number', suggestedPointsPerDollar: pointsPerDollar };
+  if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > 36) {
+    return {
+      ok: false,
+      problem: 'the spend token must have between 0 and 36 decimals',
+      suggestedPointsPerDollar: pointsPerDollar,
+    };
+  }
+  if (!Number.isFinite(usdPerSpendToken) || usdPerSpendToken <= 0) {
+    return {
+      ok: false,
+      problem: 'the spend token price must be a positive number',
+      suggestedPointsPerDollar: pointsPerDollar,
+    };
   }
   if (!Number.isSafeInteger(maxPointsPerPlayer) || maxPointsPerPlayer <= 0) {
     return {
@@ -69,7 +108,7 @@ export function resolveEconomy(input: EconomyInput): EconomyResult {
       suggestedPointsPerDollar: pointsPerDollar,
     };
   }
-  if (walletCapWei <= 0n) {
+  if (walletCap <= 0n) {
     return {
       ok: false,
       problem: 'this launch has no per-wallet spending cap, so nothing can be authorised',
@@ -77,30 +116,31 @@ export function resolveEconomy(input: EconomyInput): EconomyResult {
     };
   }
 
-  // How many points one ETH buys. Checked before it becomes a divisor: `pointsPerDollar` is
-  // guarded as positive above, but a small enough positive value still rounds this product to
+  // How many points one whole token buys. Checked before it becomes a divisor: `pointsPerDollar`
+  // is guarded as positive above, but a small enough positive value still rounds this product to
   // zero — and dividing by it threw `Division by zero` out of the one function whose entire job is
   // to refuse a bad economy with a sentence an operator can act on.
-  const pointsPerEth = Math.round(usdPerEth * pointsPerDollar);
-  if (pointsPerEth <= 0) {
+  const pointsPerToken = Math.round(usdPerSpendToken * pointsPerDollar);
+  if (pointsPerToken <= 0) {
     return {
       ok: false,
-      problem: 'one point would be worth more than a whole ETH, which cannot be what was meant',
+      problem: 'one point would be worth more than a whole spend token, which cannot be what was meant',
       suggestedPointsPerDollar: minimumPointsPerDollar(input),
     };
   }
 
-  const weiPerPoint = WEI_PER_ETH / BigInt(pointsPerEth);
-  if (weiPerPoint <= 0n) {
+  const units = unitsPerToken(decimals);
+  const unitsPerPoint = units / BigInt(pointsPerToken);
+  if (unitsPerPoint <= 0n) {
     return {
       ok: false,
-      problem: 'each point would be worth less than the smallest unit of ETH',
+      problem: 'each point would be worth less than the smallest unit of the spend token',
       suggestedPointsPerDollar: Math.max(1, Math.floor(pointsPerDollar / 1000)),
-      };
+    };
   }
 
-  const maxPayoutWei = BigInt(Math.floor(maxPointsPerPlayer)) * weiPerPoint;
-  if (maxPayoutWei > walletCapWei) {
+  const maxPayout = BigInt(Math.floor(maxPointsPerPlayer)) * unitsPerPoint;
+  if (maxPayout > walletCap) {
     return {
       ok: false,
       problem: 'a perfect round would earn more than this launch lets one wallet spend',
@@ -108,24 +148,36 @@ export function resolveEconomy(input: EconomyInput): EconomyResult {
     };
   }
 
-  return { ok: true, economy: { weiPerPoint, maxPayoutWei, pointsPerDollar, usdPerEth } };
+  return {
+    ok: true,
+    economy: {
+      unitsPerPoint,
+      maxPayout,
+      pointsPerDollar,
+      usdPerSpendToken,
+      decimals,
+    },
+  };
 }
 
 /**
  * The smallest `pointsPerDollar` that keeps a flawless round inside the cap.
  *
  * Rounded up, then nudged until it actually passes: the division that produces it floors, and a
- * value that is correct to the last wei but fails the check is worse than useless in an error
+ * value that is correct to the last unit but fails the check is worse than useless in an error
  * message. Two steps is enough for any input — the loop is a guard against an off-by-one in the
  * rounding, not an iterative search.
  */
 function minimumPointsPerDollar(input: EconomyInput): number {
-  const { maxPointsPerPlayer, walletCapWei, usdPerEth } = input;
+  const { maxPointsPerPlayer, walletCap } = input;
+  const { usdPerSpendToken, decimals } = resolveInputs(input);
   const points = BigInt(Math.floor(maxPointsPerPlayer));
-  const maxWeiPerPoint = walletCapWei / points;
-  if (maxWeiPerPoint <= 0n) return Math.ceil(maxPointsPerPlayer);
+  const maxUnitsPerPoint = walletCap / points;
+  if (maxUnitsPerPoint <= 0n) return Math.ceil(maxPointsPerPlayer);
 
-  let candidate = Math.ceil(Number(WEI_PER_ETH / maxWeiPerPoint) / usdPerEth);
+  const units =
+    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 });
     if (result.ok) return candidate;

package/src/index.ts

@@ -11,10 +11,12 @@ export type {
   Admission,
   AdmissionRequest,
   Admit,
+  AnnouncedSpendToken,
   ConfigForLaunch,
   GameServerGateOptions,
   GateOptions,
   MaxPointsForLaunch,
+  PriceFor,
   VerifiedLaunch,
 } from './server.js';
 export { createTurnstileAdmit } from './turnstile.js';
@@ -28,7 +30,7 @@ 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 { Settlement } from './settlement.js';
-export { resolveEconomy } from './economy.js';
+export { ETH_DECIMALS, resolveEconomy, unitsPerToken } from './economy.js';
 export type { Economy, EconomyInput, EconomyResult } from './economy.js';
 export { migrate } from './store.js';
 export { createDemoGate } from './demo.js';
@@ -62,9 +64,9 @@ export type { VerifiedPlayerJoin, VerifyPlayerJoinTicketOptions } from './player
  * gate (see DEPLOY.md), and the pieces below it stay exported for anyone wiring their own.
  */
 export { startGate, resolveGateEnv } from './main.js';
-export type { ResolvedGateConfig, StartedGate, StartGateOverrides } from './main.js';
+export type { ResolvedGateConfig, SpendTokenPricing, StartedGate, StartGateOverrides } from './main.js';
 export type { GateAnnouncement } from './server.js';
 export { NotSignedIn } from './sessions.js';
-export { DEPLOYMENTS, deploymentFor } from './chain/chains.js';
-export type { GateDeployment } from './chain/chains.js';
-export { assertSecureConfig } from './chain/secure.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';