@flayerlabs/gamemode-gate 0.4.3 → 0.5.1

package/dist/store.js.map

@@ -1 +1 @@
-{"version":3,"file":"store.js","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HrB,CAAC;AAEF,MAAM,cAAc,GAAG;;EAErB,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAI,IAAU,EAAE,EAAkC;IACnF,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;IAChC,IAAI,CAAC;QACH,MAAM,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACxB,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QAC5B,MAAM,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACzB,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC7B,CAAC;QAAC,MAAM,CAAC;YACP,+BAA+B;QACjC,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;YAAS,CAAC;QACT,EAAE,CAAC,OAAO,EAAE,CAAC;IACf,CAAC;AACH,CAAC;AAED,sGAAsG;AACtG,MAAM,CAAC,KAAK,UAAU,OAAO,CAAC,IAAU;IACtC,MAAM,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE;QACrC,MAAM,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QAC/B,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAyC,EAAU,EAAE,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC"}
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoJrB,CAAC;AAEF,MAAM,cAAc,GAAG;;EAErB,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAI,IAAU,EAAE,EAAkC;IACnF,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;IAChC,IAAI,CAAC;QACH,MAAM,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACxB,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QAC5B,MAAM,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACzB,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC7B,CAAC;QAAC,MAAM,CAAC;YACP,+BAA+B;QACjC,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;YAAS,CAAC;QACT,EAAE,CAAC,OAAO,EAAE,CAAC;IACf,CAAC;AACH,CAAC;AAED,sGAAsG;AACtG,MAAM,CAAC,KAAK,UAAU,OAAO,CAAC,IAAU;IACtC,MAAM,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE;QACrC,MAAM,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QAC/B,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAyC,EAAU,EAAE,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flayerlabs/gamemode-gate",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "description": "Server-authoritative rooms, economy, admission and registry for Flaunch Game Modes",
   "license": "MIT",
   "author": "Flayer Labs",
@@ -45,7 +45,7 @@
   "dependencies": {
     "@fastify/cors": "^11.3.0",
     "@fastify/websocket": "^11.3.0",
-    "@flayerlabs/gamemode-spec": "^0.4.3",
+    "@flayerlabs/gamemode-spec": "^0.5.1",
     "@types/node": "^22.10.2",
     "@types/pg": "^8.21.0",
     "fastify": "^5.11.3",

package/src/chain/chains.ts

@@ -13,33 +13,106 @@
  * gated on the audit and the multisig handover. Robinhood (4663) is deliberately missing too —
  * that chain is served by the legacy gate, and this library refusing it keeps the two stacks from
  * being pointed at each other by a copied env file.
+ *
+ * One gate serves exactly ONE (positionManager, spendGatedCalculator) pair. The EIP-712 domain of
+ * every authorisation binds it to the calculator address, so a signature minted for one pair is
+ * meaningless to the other — a gate cannot straddle two stacks, and this book records each stack
+ * as its own entry rather than pretending a chain has one.
+ */
+
+/**
+ * Which launch generation the stack's PositionManager belongs to.
+ *
+ * The names match `FlaunchVersion` in `@flaunch/sdk`, because they name the same generations and
+ * two vocabularies for one thing is how a gate ends up configured against the wrong ABI. Each
+ * generation takes a different `flaunch()` struct, and getting it wrong is an ABI revert at launch
+ * time, so it is recorded per stack rather than guessed.
+ *
+ *   v1_2       — the original Base stack. Carries the two fair-launch fields; flETH pairing only.
+ *   multichain — the multichain deployment, with the fair-launch fields removed.
+ *   v1_3       — the current generation, launched through the V1_3 FlaunchZap. The only one that
+ *                can pair a coin with a token other than ETH, and therefore the only one that can
+ *                run a paired-token round.
  */
+export type FlaunchVariant = 'v1_2' | 'multichain' | 'v1_3';
 
 export interface GateDeployment {
   positionManager: `0x${string}`;
   spendGatedCalculator: `0x${string}`;
+  flaunchVariant: FlaunchVariant;
+  /**
+   * The single-pool swap router the calculator has approved, when the stack has one. A paired-token
+   * buy goes through it (ERC20 in, `hookData` carrying the authorisation), and the calculator binds
+   * the buyer to its `msgSender()` — so an unapproved router means every smart-wallet buy reverts.
+   * Required for `v1_3`; boot refuses a paired stack without it.
+   */
+  poolSwap?: `0x${string}`;
   /**
-   * Which `flaunch()` struct the chain's PositionManager takes. V1_2 deployments carry two extra
-   * fair-launch fields ('legacy11'); the newer nine-field shape is 'current9'. Getting this wrong
-   * is an ABI revert at launch time, so it is recorded per chain rather than guessed.
+   * The chain's flETH wrapper. A coin paired with it is an ETH round priced at `USD_PER_ETH`, and
+   * the wrapper is not the zero address, so the gate has to be told which address means "ETH".
    */
-  flaunchVariant: 'legacy11' | 'current9';
+  fleth?: `0x${string}`;
 }
 
+/** The legacy stack per chain — what `deploymentFor(chainId)` answers with no manager named. */
 export const DEPLOYMENTS: Record<number, GateDeployment> = {
   /**
-   * Base Sepolia — the reference chain. Deployed 2026-08-16 (flaunch-contracts
+   * Base Sepolia — the reference chain, V1_2 stack. Deployed 2026-08-16 (flaunch-contracts
    * SpendGatedGate.s.sol); both PositionManager fee-calculator slots were read back holding the
    * dispatcher, and the calculator resolves each pool's own paired token (VPT-13).
    */
   84532: {
     positionManager: '0x4E7cB1e6800a7B297B38BddcecAF9Ca5b6616FDC',
     spendGatedCalculator: '0x8cbbE6b4cFA5Ccf68399Dbf1429d91A21097ebA5',
-    flaunchVariant: 'legacy11',
+    flaunchVariant: 'v1_2',
+    fleth: '0x79FC52701cD4BE6f9Ba9aDC94c207DE37e3314eb',
   },
 };
 
-/** The deployment for a chain, or undefined for one this library has no address book for. */
-export function deploymentFor(chainId: number): GateDeployment | undefined {
-  return DEPLOYMENTS[chainId];
+/**
+ * The paired-token stacks per chain — selected by naming their PositionManager in
+ * `POSITION_MANAGER`.
+ */
+export const PAIRED_DEPLOYMENTS: Record<number, GateDeployment> = {
+  /**
+   * Base Sepolia — the V1_3 v1.3.3 paired-token stack (flaunch-contracts regeneration, deployed
+   * 2026-09-03, blocks 46349133–46349202; `@flaunch/sdk` 0.11.4 launches here). Read back
+   * 2026-09-04: the manager's `feeCalculator()` is the dispatcher
+   * `0xd381f8ea57df43c57cfe6e5b19a0a4700396f28c`, which has this calculator registered; the
+   * calculator grants that dispatcher the PositionManager role and has this PoolSwap approved as a
+   * router. This is the stack that hosts a coin paired with MUSD
+   * (`0xd0B4398976572515a269C6331A143e08a70E9ccC`, six decimals, approved on the retained registry
+   * `0x23cb441d18ca75c6a14964b06806df668d45a1c6`) — and flETH and native ETH pairings too, so a gate
+   * on it serves ETH rounds as well.
+   *
+   * SUPERSEDED, recorded so nobody re-adds it by mistake: the `.vpt2` stack (2026-08-06) —
+   * PositionManager `0x5558e7271ec2e8b2faaf05f0eedab1cd986be5dc`, calculator
+   * `0x2c9127654ded3b6b2ba017e84f44b02cafdf9f55`, PoolSwap `0x62eb5b7b066ff80ce5e32ff1ed42b31c485f716b`.
+   * Its pools keep trading on their own hook and gate, but new paired launches land on the v1.3.3
+   * manager, and router approval is PER calculator: `0x62eb…` is NOT approved on the v1.3.3 gate,
+   * so pointing this entry at the old router would make every smart-wallet buy revert.
+   */
+  84532: {
+    positionManager: '0x8D346f24278C5CD786309161aAC0fC2bbe4c25dc',
+    spendGatedCalculator: '0x54cdcf0bcbc3a33f470e07134c10582f93058a32',
+    flaunchVariant: 'v1_3',
+    poolSwap: '0xf0f388a31a1745a5e2378b812ed51525f70595be',
+    fleth: '0x79FC52701cD4BE6f9Ba9aDC94c207DE37e3314eb',
+  },
+};
+
+/**
+ * The deployment for a chain, or undefined for one this library has no address book for.
+ *
+ * With no manager named, the legacy stack. Naming one selects whichever recorded stack it belongs
+ * to — so `POSITION_MANAGER=0x8D34…` on Base Sepolia picks the paired stack, calculator and router
+ * included, rather than pairing a paired manager with the legacy calculator by accident.
+ */
+export function deploymentFor(chainId: number, positionManager?: `0x${string}` | null): GateDeployment | undefined {
+  if (!positionManager) return DEPLOYMENTS[chainId];
+  const wanted = positionManager.toLowerCase();
+  for (const candidate of [DEPLOYMENTS[chainId], PAIRED_DEPLOYMENTS[chainId]]) {
+    if (candidate && candidate.positionManager.toLowerCase() === wanted) return candidate;
+  }
+  return undefined;
 }

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