@flayerlabs/gamemode-gate 0.5.6 → 0.7.0

package/src/chain/discover.ts

@@ -1,5 +1,6 @@
 import { encodeAbiParameters, keccak256, parseAbi, type PublicClient } from 'viem';
 import { ETH_SPEND_TOKEN, type SpendToken } from '@flayerlabs/gamemode-spec/live';
+import { checkPositionManagerWiring, type PositionManagerWiring } from './secure.js';
 
 /**
  * All this needs of a client: the ability to read a contract.
@@ -22,11 +23,15 @@ export type ChainReader = Pick<PublicClient, 'readContract'>;
  * 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.
+ * A gate serves one calculator and adopts a coin on ANY PositionManager wired to it. The coin
+ * names its own manager (`Memecoin.flaunch()` is the launch ERC721, whose `positionManager()` is
+ * the hook), and that manager is accepted when its fee wiring routes to the gate's calculator —
+ * the same three reads boot makes of the primary manager, made here per manager and cached. There
+ * is no list: wiring a new manager to the dispatcher on chain is what approves it. A coin on a
+ * manager wired to some OTHER calculator is refused for good — 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 — and every later read (`poolKey`, `flaunchesAt`, `pairedToken`) is asked of the coin's
+ * own manager, never the configured one.
  */
 
 const poolKeyComponents = [
@@ -37,6 +42,12 @@ const poolKeyComponents = [
   { name: 'hooks', type: 'address' },
 ] as const;
 
+/** What a coin knows about its own launch: `flaunch()` is the ERC721 that minted it. */
+const memecoinAbi = parseAbi(['function flaunch() view returns (address)']);
+
+/** The launch ERC721 (`Flaunch`, `AnyFlaunch`) names the PositionManager that hooks its pools. */
+const flaunchAbi = parseAbi(['function positionManager() view returns (address)']);
+
 export const positionManagerAbi = [
   {
     type: 'function',
@@ -91,6 +102,11 @@ export interface Launch {
   name: string;
   symbol: string;
   imageUrl?: string | null;
+  /**
+   * The PositionManager the coin was launched on — the pool's hook — resolved from the coin
+   * itself. Absent only from hand-built launches (demos, tests), where it means the primary one.
+   */
+  positionManager?: `0x${string}`;
   /**
    * 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.
@@ -115,12 +131,122 @@ export interface Refused {
 export type LaunchCheck = ({ ok: true } & Launch) | Refused;
 
 export interface Deployment {
+  /**
+   * The primary manager: what boot asserted and `/config` announces. Adoption does not require a
+   * coin to be on it — see {@link verifyLaunch} — but it is the one manager known wired before any
+   * coin arrives, so its wiring is never asked of the chain again.
+   */
   positionManager: `0x${string}`;
   spendGatedCalculator: `0x${string}`;
   /** The signer this gate holds. A launch naming anyone else is not ours to run. */
   signer: `0x${string}`;
 }
 
+/**
+ * Whether a manager's fee wiring routes to a calculator. {@link checkPositionManagerWiring} is the
+ * one implementation; this is its shape, so a test can stand in for the chain.
+ */
+export type WiringCheck = (
+  client: ChainReader,
+  wiring: { positionManager: `0x${string}`; spendGatedCalculator: `0x${string}` },
+) => Promise<PositionManagerWiring>;
+
+/**
+ * Remembers which managers are wired to this gate's calculator, so the three wiring reads happen
+ * once per manager rather than once per coin.
+ *
+ * A yes is kept for the life of the process: wiring is a one-time owner action, and un-wiring a
+ * manager with live pools would also strand every coin already adopted on it, so nothing is lost
+ * by not re-asking. A no is kept a minute — long enough that a coin page polling an unwired
+ * manager is not a lever on the RPC, short enough that the owner wiring it up sees the gate follow.
+ */
+export class WiringCache {
+  private readonly verdicts = new Map<string, { verdict: PositionManagerWiring; until: number }>();
+  private readonly inFlight = new Map<string, Promise<PositionManagerWiring>>();
+
+  constructor(
+    private readonly check: WiringCheck = checkPositionManagerWiring,
+    private readonly now: () => number = Date.now,
+    private readonly negativeHoldMs = 60_000,
+  ) {}
+
+  async isWired(
+    client: ChainReader,
+    positionManager: `0x${string}`,
+    spendGatedCalculator: `0x${string}`,
+  ): Promise<PositionManagerWiring> {
+    const key = positionManager.toLowerCase();
+    const cached = this.verdicts.get(key);
+    if (cached && cached.until > this.now()) return cached.verdict;
+
+    const existing = this.inFlight.get(key);
+    if (existing) return existing;
+
+    const flight = this.check(client, { positionManager, spendGatedCalculator })
+      .then((verdict) => {
+        const until = verdict.ok ? Number.POSITIVE_INFINITY : this.now() + this.negativeHoldMs;
+        this.verdicts.set(key, { verdict, until });
+        return verdict;
+      })
+      .finally(() => this.inFlight.delete(key));
+    this.inFlight.set(key, flight);
+    return flight;
+  }
+
+  /** A fresh cache that already trusts the primary manager, which boot asserted before any coin arrived. */
+  static trusting(positionManager: `0x${string}`): WiringCache {
+    const cache = new WiringCache();
+    cache.trust(positionManager);
+    return cache;
+  }
+
+  /** Record a manager known wired without asking — the primary one, which boot already asserted. */
+  trust(positionManager: `0x${string}`, dispatcher: `0x${string}` = ZERO_ADDRESS): void {
+    this.verdicts.set(positionManager.toLowerCase(), {
+      verdict: { ok: true, dispatcher },
+      until: Number.POSITIVE_INFINITY,
+    });
+  }
+}
+
+/**
+ * Which PositionManager a coin was launched on, from the coin itself.
+ *
+ * Two reads: `Memecoin.flaunch()` names the launch ERC721 that minted the coin, and that contract's
+ * `positionManager()` names the hook. Both are public state written at launch, so the answer is the
+ * coin's and cannot be steered by whoever offers it for adoption. Null when the CONTRACT says no —
+ * an address with no code, or one that is not a Flaunch coin, answers `flaunch()` with no data.
+ * An RPC that did not answer is not a statement about the coin, so that is thrown to the caller
+ * rather than folded into null.
+ */
+export async function resolvePositionManager(
+  client: ChainReader,
+  memecoin: `0x${string}`,
+): Promise<`0x${string}` | null> {
+  let flaunch: `0x${string}`;
+  try {
+    flaunch = (await client.readContract({ address: memecoin, abi: memecoinAbi, functionName: 'flaunch' })) as `0x${string}`;
+  } catch (error) {
+    if (isMissingFunction(error)) return null;
+    throw error;
+  }
+  if (!flaunch || flaunch.toLowerCase() === ZERO_ADDRESS) return null;
+
+  let manager: `0x${string}`;
+  try {
+    manager = (await client.readContract({
+      address: flaunch,
+      abi: flaunchAbi,
+      functionName: 'positionManager',
+    })) as `0x${string}`;
+  } catch (error) {
+    if (isMissingFunction(error)) return null;
+    throw error;
+  }
+  if (!manager || manager.toLowerCase() === ZERO_ADDRESS) return null;
+  return manager;
+}
+
 export function poolIdOf(key: PoolKey): `0x${string}` {
   return keccak256(
     encodeAbiParameters(
@@ -142,11 +268,28 @@ export async function verifyLaunch(
   client: ChainReader,
   deployment: Deployment,
   memecoin: `0x${string}`,
+  wiring: WiringCache = WiringCache.trusting(deployment.positionManager),
 ): Promise<LaunchCheck> {
+  // The coin's own manager first. A coin the protocol has never heard of has no `flaunch()`, which
+  // is still "not yet": the coin page loads the instant a launch is submitted, before the chain has
+  // caught up, and that must not be remembered as "no".
+  let positionManager: `0x${string}` | null;
+  try {
+    positionManager = await resolvePositionManager(client, memecoin);
+  } catch {
+    return refuse('launch.unreadable', true);
+  }
+  if (!positionManager) return refuse('launch.not_flaunched', true);
+
+  // Approval is a fact about the chain: is this manager's fee wiring routed to OUR calculator? A
+  // manager wired elsewhere is another gate's, permanently — no amount of waiting rewires it.
+  const wired = await wiring.isWired(client, positionManager, deployment.spendGatedCalculator);
+  if (!wired.ok) return refuse('launch.unapproved_position_manager', false);
+
   let poolKey: PoolKey;
   try {
     poolKey = (await client.readContract({
-      address: deployment.positionManager,
+      address: positionManager,
       abi: positionManagerAbi,
       functionName: 'poolKey',
       args: [memecoin],
@@ -164,9 +307,8 @@ export async function verifyLaunch(
 
   let settings: readonly [boolean, bigint, `0x${string}`, bigint];
   let trusted: readonly [`0x${string}`, boolean];
-  let flaunchesAt: bigint;
   try {
-    [settings, trusted, flaunchesAt] = (await Promise.all([
+    [settings, trusted] = (await Promise.all([
       client.readContract({
         address: deployment.spendGatedCalculator,
         abi: spendGatedAbi,
@@ -179,17 +321,27 @@ export async function verifyLaunch(
         functionName: 'trustedPoolKeySigner',
         args: [poolId],
       }),
-      client.readContract({
-        address: deployment.positionManager,
-        abi: positionManagerAbi,
-        functionName: 'flaunchesAt',
-        args: [poolId],
-      }),
-    ])) as [typeof settings, typeof trusted, bigint];
+    ])) as [typeof settings, typeof trusted];
   } catch {
     return refuse('launch.unreadable', true);
   }
 
+  // The window's open is the manager's to report. A manager that is wired but has no
+  // `flaunchesAt` is a generation this gate has no round model for — a permanent fact about the
+  // contract, not an outage, so it is refused as unsupported rather than as unreadable and retried
+  // forever.
+  let flaunchesAt: bigint;
+  try {
+    flaunchesAt = (await client.readContract({
+      address: positionManager,
+      abi: positionManagerAbi,
+      functionName: 'flaunchesAt',
+      args: [poolId],
+    })) as bigint;
+  } catch (error) {
+    return refuse(isMissingFunction(error) ? 'launch.unsupported_position_manager' : 'launch.unreadable', !isMissingFunction(error));
+  }
+
   const [enabled, walletCap, , endsAt] = settings;
   const [signer, signerEnabled] = trusted;
 
@@ -204,7 +356,7 @@ export async function verifyLaunch(
   const closesAt = Number(endsAt) * 1000;
   if (closesAt <= Date.now()) return refuse('launch.already_over', false);
 
-  const spendToken = await resolveSpendToken(client, deployment, memecoin, poolKey, poolId);
+  const spendToken = await resolveSpendToken(client, positionManager, memecoin, poolKey, poolId);
   if (!spendToken) return refuse('launch.paired_unreadable', true);
 
   let name = '';
@@ -231,9 +383,38 @@ export async function verifyLaunch(
     name,
     symbol,
     spendToken,
+    positionManager,
   };
 }
 
+/**
+ * Did a read fail because the contract has no such function, rather than because the chain did
+ * not answer? viem reports the former as a call that returned no data or reverted at the
+ * contract (`ContractFunctionZeroDataError`, `ContractFunctionRevertedError`); a transport
+ * failure looks nothing like it, and a `view` that exists does not revert on a pool id.
+ */
+function isMissingFunction(error: unknown): boolean {
+  const seen = new Set<unknown>();
+  let current: unknown = error;
+  while (current && typeof current === 'object' && !seen.has(current)) {
+    seen.add(current);
+    const name = (current as { name?: unknown }).name;
+    if (
+      name === 'ContractFunctionZeroDataError' ||
+      name === 'AbiDecodingZeroDataError' ||
+      name === 'ContractFunctionRevertedError'
+    ) {
+      return true;
+    }
+    const message = (current as { message?: unknown }).message;
+    if (typeof message === 'string' && /returned no data|zero data|function (selector )?was not (recognized|found)/i.test(message)) {
+      return true;
+    }
+    current = (current as { cause?: unknown }).cause;
+  }
+  return false;
+}
+
 /**
  * Which token this pool's spend is measured in.
  *
@@ -246,7 +427,7 @@ export async function verifyLaunch(
  */
 async function resolveSpendToken(
   client: ChainReader,
-  deployment: Deployment,
+  positionManager: `0x${string}`,
   memecoin: `0x${string}`,
   poolKey: PoolKey,
   poolId: `0x${string}`,
@@ -254,7 +435,7 @@ async function resolveSpendToken(
   let paired: `0x${string}`;
   try {
     paired = (await client.readContract({
-      address: deployment.positionManager,
+      address: positionManager,
       abi: positionManagerAbi,
       functionName: 'pairedToken',
       args: [poolId],
@@ -278,7 +459,7 @@ async function resolveSpendToken(
 /**
  * Verification with a memory, because every coin-page view asks.
  *
- * Unmemoised, each call costs five chain reads against one endpoint from one address — which is a
+ * Unmemoised, each call costs seven chain reads against one endpoint from one address — which is a
  * free denial-of-service lever, and public endpoints rate-limit long before a launch does.
  *
  * A positive verdict is cached until the window closes, because a launch that qualifies cannot
@@ -288,12 +469,22 @@ async function resolveSpendToken(
 export class Discovery {
   private readonly verdicts = new Map<string, { verdict: LaunchCheck; until: number }>();
   private readonly inFlight = new Map<string, Promise<LaunchCheck>>();
+  /**
+   * Which managers are wired to this gate's calculator, remembered per manager. The primary one is
+   * trusted from the start: boot asserted it, and asking again would be the only three reads that
+   * could never answer differently.
+   */
+  readonly wiring: WiringCache;
 
   constructor(
     private readonly client: ChainReader,
     private readonly deployment: Deployment,
     private readonly now: () => number = Date.now,
-  ) {}
+    wiring: WiringCache = new WiringCache(checkPositionManagerWiring, now),
+  ) {
+    this.wiring = wiring;
+    this.wiring.trust(deployment.positionManager);
+  }
 
   async verify(memecoin: `0x${string}`): Promise<LaunchCheck> {
     const key = memecoin.toLowerCase();
@@ -305,7 +496,7 @@ export class Discovery {
     const existing = this.inFlight.get(key);
     if (existing) return existing;
 
-    const flight = verifyLaunch(this.client, this.deployment, memecoin)
+    const flight = verifyLaunch(this.client, this.deployment, memecoin, this.wiring)
       .then((verdict) => {
         this.verdicts.set(key, { verdict, until: this.now() + this.holdFor(verdict) });
         return verdict;

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/chain/signer.ts

@@ -3,15 +3,19 @@ import { privateKeyToAccount, type PrivateKeyAccount } from 'viem/accounts';
 import { gateReadinessTypedData, READINESS_TTL_SECONDS, type GateReadiness, spendAuthorisationTypedData } from '@flayerlabs/gamemode-spec/embed';
 
 /**
- * Issues the signed authorizations SpendGatedSignerFeeCalculator.trackSwap verifies.
+ * Issues the signed authorisations SpendGatedSignerFeeCalculator.trackSwap verifies.
  *
- * EIP-712, over the `SpendAuthorization` struct the calculator declares. It used to be an
- * EIP-191 personal-sign over `keccak256(abi.encodePacked(...))`, which committed to the five
- * fields and nothing else — no chain id, no verifying contract. An audit flagged that as the
- * same defect already raised against the parent calculator (M-6, remediated there in the
- * EIP-712 PR but never ported to this fork): the protocol deploys deterministically across
- * chains, so the same poolId genuinely recurs, and one signing key shared between two
- * environments made an authorization issued for one valid on the other. The domain closes it.
+ * EIP-712, over the `SpendAuthorization` struct the calculator declares, under the
+ * `FlaunchSpendGate` version `2` domain. The struct carries a cumulative ceiling: the most this
+ * buyer may EVER have spent on this pool, which the calculator compares against its own
+ * `walletSpentWei` accumulator. There is no nonce and no per-purchase amount, because there is
+ * nothing to consume — two authorisations with the same ceiling cannot add up, so reusing one is
+ * harmless by construction and the gate holds nothing against it.
+ *
+ * The domain matters: the protocol deploys deterministically across chains, so the same poolId
+ * genuinely recurs, and one signing key shared between two environments would otherwise make an
+ * authorisation issued for one valid on the other. Version `2` also keeps 0.5.x signatures (a
+ * five-field struct with a nonce) from verifying on this calculator and vice versa.
  *
  * The digest MUST match `hashSpendAuthorization` on the calculator exactly. That function is
  * public for this reason — a domain drift is otherwise a silent `InvalidSigner` at swap time
@@ -22,8 +26,7 @@ export interface SignedPayload {
   buyer: `0x${string}`;
   poolId: `0x${string}`;
   deadline: bigint;
-  maxSpendWei: bigint;
-  nonce: bigint;
+  spendCeilingWei: bigint;
   signature: `0x${string}`;
   signer: `0x${string}`;
 }
@@ -62,15 +65,10 @@ export class PayloadSigner {
     buyer: `0x${string}`,
     poolId: `0x${string}`,
     deadline: bigint,
-    maxSpendWei: bigint,
-    nonce: bigint,
+    spendCeilingWei: bigint,
   ): `0x${string}` {
     return hashTypedData(
-      spendAuthorisationTypedData(
-        { buyer, poolId, deadline, maxSpendWei, nonce },
-        this.chainId,
-        this.verifyingContract,
-      ),
+      spendAuthorisationTypedData({ buyer, poolId, deadline, spendCeilingWei }, this.chainId, this.verifyingContract),
     );
   }
 
@@ -78,23 +76,21 @@ export class PayloadSigner {
     buyer: `0x${string}`,
     poolId: `0x${string}`,
     deadline: bigint,
-    maxSpendWei: bigint,
-    nonce: bigint,
+    spendCeilingWei: bigint,
   ): Promise<SignedPayload> {
     const signature = await this.account.signTypedData(
-      spendAuthorisationTypedData(
-        { buyer, poolId, deadline, maxSpendWei, nonce },
-        this.chainId,
-        this.verifyingContract,
-      ),
+      spendAuthorisationTypedData({ buyer, poolId, deadline, spendCeilingWei }, this.chainId, this.verifyingContract),
     );
-    return { buyer, poolId, deadline, maxSpendWei, nonce, signature, signer: this.account.address };
+    return { buyer, poolId, deadline, spendCeilingWei, signature, signer: this.account.address };
   }
 }
 
 /**
  * Encodes a signed payload as the hookData the swap must carry:
- * `abi.encode(address referrer, SignedMessage{buyer, poolId, deadline, maxSpendWei, nonce, signature})`
+ * `abi.encode(address referrer, SignedMessage{buyer, poolId, deadline, spendCeilingWei, signature})`
+ *
+ * The referrer word is always zero. The calculator ignores it, but the trusted page checks it, so
+ * a creator iframe cannot redirect attribution while keeping a valid signature.
  */
 export function encodeHookData(payload: SignedPayload): `0x${string}` {
   return encodeAbiParameters(
@@ -106,8 +102,7 @@ export function encodeHookData(payload: SignedPayload): `0x${string}` {
           { name: 'buyer', type: 'address' },
           { name: 'poolId', type: 'bytes32' },
           { name: 'deadline', type: 'uint256' },
-          { name: 'maxSpendWei', type: 'uint256' },
-          { name: 'nonce', type: 'uint256' },
+          { name: 'spendCeilingWei', type: 'uint256' },
           { name: 'signature', type: 'bytes' },
         ],
       },
@@ -118,8 +113,7 @@ export function encodeHookData(payload: SignedPayload): `0x${string}` {
         buyer: payload.buyer,
         poolId: payload.poolId,
         deadline: payload.deadline,
-        maxSpendWei: payload.maxSpendWei,
-        nonce: payload.nonce,
+        spendCeilingWei: payload.spendCeilingWei,
         signature: payload.signature,
       },
     ],