@flayerlabs/gamemode-gate 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Flayer Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,79 @@
+# @flayerlabs/gamemode-gate
+
+Run server-authoritative Game Mode rooms, spending allowance, admission and game discovery.
+
+## Requirements
+
+You need:
+
+- Node.js 20 or later
+- PostgreSQL
+- `@flayerlabs/gamemode-spec` at the matching SDK version
+
+Install the package and direct database dependency:
+
+```bash
+pnpm add @flayerlabs/gamemode-gate @flayerlabs/gamemode-spec pg
+```
+
+## Start a local gate without a chain
+
+`createDemoGate` starts the real gate flow with a stand-in wallet and no chain access. It expects
+PostgreSQL at `postgres://postgres:gamemode@127.0.0.1:55439/gamemode` unless you set `DATABASE_URL`.
+
+```ts
+import { createDemoGate } from '@flayerlabs/gamemode-gate'
+import { rules, type Config } from './game/rules.js'
+
+const config: Config = {
+  rounds: 3,
+  ceiling: 10,
+  points: 500,
+  roundMs: 10_000,
+}
+
+const demo = await createDemoGate({
+  game: rules,
+  config,
+  gateOrigin: 'http://127.0.0.1:4000',
+})
+
+await demo.app.listen({ host: '127.0.0.1', port: 4000 })
+```
+
+This path uses the real room, database, socket and signed spend authorisations. It records purchases
+instead of submitting them to a chain. Do not use `createDemoGate` in production.
+
+## Build a production gate
+
+Run `migrate(pool)` before the gate accepts traffic. A `createGate` setup needs:
+
+- `Sessions` configured with the page domain and the gate's exact public origin
+- `Claims`, `Ledger` and `PayloadSigner` for spending authorisations
+- `pointsPerDollar`, `usdPerEth` and the allowed game origins
+
+Add the chain services used by your deployment:
+
+- `Discovery` verifies each launch before the gate adopts it
+- `Settlement` updates recorded spending from the chain
+
+Run one gate process for each game. The current room writer does not support multiple replicas.
+
+Use `createTurnstileAdmit` if the trusted parent supplies Cloudflare Turnstile evidence. The policy
+checks session creation. Game action and claim policy remain the gate operator's responsibility.
+
+Read the [production gate guide](https://github.com/flayerlabs/gamemode-sdk/blob/main/docs/guides/run-a-gate.md)
+before deploying a gate.
+
+## Run the central game registry
+
+`createGameRegistry` provides:
+
+- public `GET /games/:chainId/:coin` lookups for trusted Flaunch pages
+- authenticated internal routes for the Flaunch launch backend to pin or disable a registration
+
+The registry is a central Flaunch service. Do not run it inside a creator gate. Its
+`writerToken` must contain at least 32 characters and stay on the launch backend.
+
+Read the current request and response behaviour in the
+[game registry source](https://github.com/flayerlabs/gamemode-sdk/blob/main/packages/gate/src/game-registry.ts).

package/dist/chain/discover.d.ts

@@ -0,0 +1,158 @@
+import { type PublicClient } from 'viem';
+/**
+ * All this needs of a client: the ability to read a contract.
+ *
+ * Naming the one method rather than taking a whole `PublicClient` also sidesteps viem's chain
+ * generics, which make a client built for one chain structurally incompatible with the general
+ * type over unrelated methods like `getBlock`.
+ */
+export type ChainReader = Pick<PublicClient, 'readContract'>;
+export declare const positionManagerAbi: readonly [{
+    readonly type: "function";
+    readonly name: "poolKey";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "_token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "currency0";
+            readonly type: "address";
+        }, {
+            readonly name: "currency1";
+            readonly type: "address";
+        }, {
+            readonly name: "fee";
+            readonly type: "uint24";
+        }, {
+            readonly name: "tickSpacing";
+            readonly type: "int24";
+        }, {
+            readonly name: "hooks";
+            readonly type: "address";
+        }];
+    }];
+}, {
+    readonly name: "flaunchesAt";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "_poolId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+export declare const spendGatedAbi: readonly [{
+    readonly name: "spendGateSettings";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "_poolId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+        readonly name: "enabled";
+    }, {
+        readonly type: "uint256";
+        readonly name: "walletCapWei";
+    }, {
+        readonly type: "address";
+        readonly name: "settler";
+    }, {
+        readonly type: "uint256";
+        readonly name: "endsAt";
+    }];
+}, {
+    readonly name: "trustedPoolKeySigner";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes32";
+        readonly name: "_poolId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+        readonly name: "signer";
+    }, {
+        readonly type: "bool";
+        readonly name: "enabled";
+    }];
+}];
+export interface PoolKey {
+    currency0: `0x${string}`;
+    currency1: `0x${string}`;
+    fee: number;
+    tickSpacing: number;
+    hooks: `0x${string}`;
+}
+export interface Launch {
+    coinAddress: `0x${string}`;
+    poolId: `0x${string}`;
+    poolKey: PoolKey;
+    /** When buying opens, in epoch ms. */
+    opensAt: number;
+    /** When the gate stops enforcing on chain, in epoch ms. */
+    closesAt: number;
+    walletCapWei: bigint;
+    signer: `0x${string}`;
+    name: string;
+    symbol: string;
+    imageUrl?: string | null;
+}
+/**
+ * A refusal, with the one distinction that matters.
+ *
+ * `retryable` separates "the chain has not caught up yet" from "this coin is not a game launch".
+ * Collapsing the two once cost a real launch its whole window: a coin page loaded the instant a
+ * launch was submitted, asked before the pool was readable, was told "not a game launch", and both
+ * ends cached that answer for thirty seconds each — against a ninety-second window.
+ */
+export interface Refused {
+    ok: false;
+    code: string;
+    retryable: boolean;
+}
+export type LaunchCheck = ({
+    ok: true;
+} & Launch) | Refused;
+export interface Deployment {
+    positionManager: `0x${string}`;
+    spendGatedCalculator: `0x${string}`;
+    /** The signer this gate holds. A launch naming anyone else is not ours to run. */
+    signer: `0x${string}`;
+}
+export declare function poolIdOf(key: PoolKey): `0x${string}`;
+/**
+ * Verify a coin, from the chain.
+ *
+ * Every read is wrapped, because an RPC failure is not a statement about the token. Treating one as
+ * "not a game launch" is exactly the mistake described on {@link Refused}.
+ */
+export declare function verifyLaunch(client: ChainReader, deployment: Deployment, memecoin: `0x${string}`): Promise<LaunchCheck>;
+/**
+ * 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
+ * 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
+ * un-qualify while it is open. A retryable refusal is cached only briefly, and a permanent one for
+ * longer — the whole point of the distinction is that "not yet" must not be remembered like "no".
+ */
+export declare class Discovery {
+    private readonly client;
+    private readonly deployment;
+    private readonly now;
+    private readonly verdicts;
+    private readonly inFlight;
+    constructor(client: ChainReader, deployment: Deployment, now?: () => number);
+    verify(memecoin: `0x${string}`): Promise<LaunchCheck>;
+    private holdFor;
+}
+//# sourceMappingURL=discover.d.ts.map

package/dist/chain/discover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/chain/discover.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4C,KAAK,YAAY,EAAE,MAAM,MAAM,CAAC;AAEnF;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;AAuB7D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUrB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKxB,CAAC;AAIH,MAAM,WAAW,OAAO;IACtB,SAAS,EAAE,KAAK,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,KAAK,MAAM,EAAE,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,KAAK,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,MAAM;IACrB,WAAW,EAAE,KAAK,MAAM,EAAE,CAAC;IAC3B,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,KAAK,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,WAAW,GAAG,CAAC;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG,MAAM,CAAC,GAAG,OAAO,CAAC;AAE5D,MAAM,WAAW,UAAU;IACzB,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;IAC/B,oBAAoB,EAAE,KAAK,MAAM,EAAE,CAAC;IACpC,kFAAkF;IAClF,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;CACvB;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,KAAK,MAAM,EAAE,CAOpD;AAID;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,KAAK,MAAM,EAAE,GACtB,OAAO,CAAC,WAAW,CAAC,CA2EtB;AAED;;;;;;;;;GASG;AACH,qBAAa,SAAS;IAKlB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,GAAG;IANtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8D;IACvF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2C;gBAGjD,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,UAAU,EACtB,GAAG,GAAE,MAAM,MAAiB;IAGzC,MAAM,CAAC,QAAQ,EAAE,KAAK,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAqB3D,OAAO,CAAC,OAAO;CAIhB"}

package/dist/chain/discover.js

@@ -0,0 +1,169 @@
+import { encodeAbiParameters, keccak256, parseAbi } from 'viem';
+/**
+ * Asking the chain whether a coin is really a game launch, and on what terms.
+ *
+ * This is what makes rooms exist because a LAUNCH exists rather than because somebody asked for
+ * one. A room used to be minted on demand, which on a public URL means anyone can invent as many
+ * as they like.
+ *
+ * The authorisation is already on chain: a launch that wants a game names its signer in the
+ * 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.
+ */
+const poolKeyComponents = [
+    { name: 'currency0', type: 'address' },
+    { name: 'currency1', type: 'address' },
+    { name: 'fee', type: 'uint24' },
+    { name: 'tickSpacing', type: 'int24' },
+    { name: 'hooks', type: 'address' },
+];
+export const positionManagerAbi = [
+    {
+        type: 'function',
+        name: 'poolKey',
+        stateMutability: 'view',
+        inputs: [{ name: '_token', type: 'address' }],
+        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)']),
+];
+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 trustedPoolKeySigner(bytes32 _poolId) view returns (address signer, bool enabled)',
+]);
+const erc20 = parseAbi(['function name() view returns (string)', 'function symbol() view returns (string)']);
+export function poolIdOf(key) {
+    return keccak256(encodeAbiParameters([{ type: 'address' }, { type: 'address' }, { type: 'uint24' }, { type: 'int24' }, { type: 'address' }], [key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks]));
+}
+const refuse = (code, retryable) => ({ ok: false, code, retryable });
+/**
+ * Verify a coin, from the chain.
+ *
+ * Every read is wrapped, because an RPC failure is not a statement about the token. Treating one as
+ * "not a game launch" is exactly the mistake described on {@link Refused}.
+ */
+export async function verifyLaunch(client, deployment, memecoin) {
+    let poolKey;
+    try {
+        poolKey = (await client.readContract({
+            address: deployment.positionManager,
+            abi: positionManagerAbi,
+            functionName: 'poolKey',
+            args: [memecoin],
+        }));
+    }
+    catch {
+        return refuse('launch.unreadable', true);
+    }
+    // A coin the protocol has never heard of returns an empty key rather than throwing.
+    if (!poolKey || poolKey.hooks === '0x0000000000000000000000000000000000000000') {
+        return refuse('launch.not_flaunched', true);
+    }
+    const poolId = poolIdOf(poolKey);
+    let settings;
+    let trusted;
+    let flaunchesAt;
+    try {
+        [settings, trusted, flaunchesAt] = (await Promise.all([
+            client.readContract({
+                address: deployment.spendGatedCalculator,
+                abi: spendGatedAbi,
+                functionName: 'spendGateSettings',
+                args: [poolId],
+            }),
+            client.readContract({
+                address: deployment.spendGatedCalculator,
+                abi: spendGatedAbi,
+                functionName: 'trustedPoolKeySigner',
+                args: [poolId],
+            }),
+            client.readContract({
+                address: deployment.positionManager,
+                abi: positionManagerAbi,
+                functionName: 'flaunchesAt',
+                args: [poolId],
+            }),
+        ]));
+    }
+    catch {
+        return refuse('launch.unreadable', true);
+    }
+    const [enabled, walletCapWei, , endsAt] = settings;
+    const [signer, signerEnabled] = trusted;
+    if (!enabled)
+        return refuse('launch.not_a_game', false);
+    // Not ours to run. Permanent: another gate holds that key, and no amount of waiting changes it.
+    if (!signerEnabled || signer.toLowerCase() !== deployment.signer.toLowerCase()) {
+        return refuse('launch.another_signer', false);
+    }
+    if (walletCapWei <= 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);
+    let name = '';
+    let symbol = '';
+    try {
+        [name, symbol] = (await Promise.all([
+            client.readContract({ address: memecoin, abi: erc20, functionName: 'name' }),
+            client.readContract({ address: memecoin, abi: erc20, functionName: 'symbol' }),
+        ]));
+    }
+    catch {
+        // Cosmetic. A coin with an unreadable name is still a valid launch, and refusing one over a
+        // 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 };
+}
+/**
+ * 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
+ * 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
+ * un-qualify while it is open. A retryable refusal is cached only briefly, and a permanent one for
+ * longer — the whole point of the distinction is that "not yet" must not be remembered like "no".
+ */
+export class Discovery {
+    client;
+    deployment;
+    now;
+    verdicts = new Map();
+    inFlight = new Map();
+    constructor(client, deployment, now = Date.now) {
+        this.client = client;
+        this.deployment = deployment;
+        this.now = now;
+    }
+    async verify(memecoin) {
+        const key = memecoin.toLowerCase();
+        const cached = this.verdicts.get(key);
+        if (cached && cached.until > this.now())
+            return cached.verdict;
+        // One flight per coin: a burst of coin-page views is one caller as far as the chain is
+        // concerned, and without this the first launch of the day is its own thundering herd.
+        const existing = this.inFlight.get(key);
+        if (existing)
+            return existing;
+        const flight = verifyLaunch(this.client, this.deployment, memecoin)
+            .then((verdict) => {
+            this.verdicts.set(key, { verdict, until: this.now() + this.holdFor(verdict) });
+            return verdict;
+        })
+            .finally(() => this.inFlight.delete(key));
+        this.inFlight.set(key, flight);
+        return flight;
+    }
+    holdFor(verdict) {
+        if (verdict.ok)
+            return Math.max(0, verdict.closesAt - this.now());
+        return verdict.retryable ? 3_000 : 60_000;
+    }
+}
+//# sourceMappingURL=discover.js.map

package/dist/chain/discover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.js","sourceRoot":"","sources":["../../src/chain/discover.ts"],"names":[],"mappings":"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"}

package/dist/chain/signer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Issues the signed authorizations 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.
+ *
+ * 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
+ * rather than a loud failure at signing time. Parity is pinned by test/signer-parity.test.ts
+ * against vectors generated with Foundry.
+ */
+export interface SignedPayload {
+    buyer: `0x${string}`;
+    poolId: `0x${string}`;
+    deadline: bigint;
+    maxSpendWei: bigint;
+    nonce: bigint;
+    signature: `0x${string}`;
+    signer: `0x${string}`;
+}
+export declare class PayloadSigner {
+    private readonly chainId;
+    private readonly verifyingContract;
+    private readonly account;
+    /**
+     * @param verifyingContract The calculator that will validate these signatures. Binding it is
+     * half the point of the domain. Unit tests may use a placeholder because they have no deployment.
+     * A production operator must pass the calculator that chain discovery also verifies.
+     */
+    constructor(privateKey: `0x${string}`, chainId: number, verifyingContract: `0x${string}`);
+    get address(): `0x${string}`;
+    /** The digest the calculator reconstructs; mirrors its `hashSpendAuthorization`. */
+    messageHash(buyer: `0x${string}`, poolId: `0x${string}`, deadline: bigint, maxSpendWei: bigint, nonce: bigint): `0x${string}`;
+    sign(buyer: `0x${string}`, poolId: `0x${string}`, deadline: bigint, maxSpendWei: bigint, nonce: bigint): Promise<SignedPayload>;
+}
+/**
+ * Encodes a signed payload as the hookData the swap must carry:
+ * `abi.encode(address referrer, SignedMessage{buyer, poolId, deadline, maxSpendWei, nonce, signature})`
+ */
+export declare function encodeHookData(payload: SignedPayload): `0x${string}`;
+//# sourceMappingURL=signer.d.ts.map

package/dist/chain/signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../../src/chain/signer.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,KAAK,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,KAAK,MAAM,EAAE,CAAC;IACzB,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;CACvB;AAED,qBAAa,aAAa;IAUtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAVpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAE5C;;;;OAIG;gBAED,UAAU,EAAE,KAAK,MAAM,EAAE,EACR,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,KAAK,MAAM,EAAE;IAKnD,IAAI,OAAO,IAAI,KAAK,MAAM,EAAE,CAE3B;IAED,oFAAoF;IACpF,WAAW,CACT,KAAK,EAAE,KAAK,MAAM,EAAE,EACpB,MAAM,EAAE,KAAK,MAAM,EAAE,EACrB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GACZ,KAAK,MAAM,EAAE;IAUV,IAAI,CACR,KAAK,EAAE,KAAK,MAAM,EAAE,EACpB,MAAM,EAAE,KAAK,MAAM,EAAE,EACrB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,aAAa,CAAC;CAU1B;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,KAAK,MAAM,EAAE,CA4BpE"}

package/dist/chain/signer.js

@@ -0,0 +1,60 @@
+import { encodeAbiParameters, hashTypedData, zeroAddress } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { spendAuthorisationTypedData } from '@flayerlabs/gamemode-spec/embed';
+export class PayloadSigner {
+    chainId;
+    verifyingContract;
+    account;
+    /**
+     * @param verifyingContract The calculator that will validate these signatures. Binding it is
+     * half the point of the domain. Unit tests may use a placeholder because they have no deployment.
+     * A production operator must pass the calculator that chain discovery also verifies.
+     */
+    constructor(privateKey, chainId, verifyingContract) {
+        this.chainId = chainId;
+        this.verifyingContract = verifyingContract;
+        this.account = privateKeyToAccount(privateKey);
+    }
+    get address() {
+        return this.account.address;
+    }
+    /** The digest the calculator reconstructs; mirrors its `hashSpendAuthorization`. */
+    messageHash(buyer, poolId, deadline, maxSpendWei, nonce) {
+        return hashTypedData(spendAuthorisationTypedData({ buyer, poolId, deadline, maxSpendWei, nonce }, this.chainId, this.verifyingContract));
+    }
+    async sign(buyer, poolId, deadline, maxSpendWei, nonce) {
+        const signature = await this.account.signTypedData(spendAuthorisationTypedData({ buyer, poolId, deadline, maxSpendWei, nonce }, this.chainId, this.verifyingContract));
+        return { buyer, poolId, deadline, maxSpendWei, nonce, 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})`
+ */
+export function encodeHookData(payload) {
+    return encodeAbiParameters([
+        { type: 'address' },
+        {
+            type: 'tuple',
+            components: [
+                { name: 'buyer', type: 'address' },
+                { name: 'poolId', type: 'bytes32' },
+                { name: 'deadline', type: 'uint256' },
+                { name: 'maxSpendWei', type: 'uint256' },
+                { name: 'nonce', type: 'uint256' },
+                { name: 'signature', type: 'bytes' },
+            ],
+        },
+    ], [
+        zeroAddress,
+        {
+            buyer: payload.buyer,
+            poolId: payload.poolId,
+            deadline: payload.deadline,
+            maxSpendWei: payload.maxSpendWei,
+            nonce: payload.nonce,
+            signature: payload.signature,
+        },
+    ]);
+}
+//# sourceMappingURL=signer.js.map

package/dist/chain/signer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.js","sourceRoot":"","sources":["../../src/chain/signer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,MAAM,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAA0B,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AA4B9E,MAAM,OAAO,aAAa;IAUL;IACA;IAVF,OAAO,CAAoB;IAE5C;;;;OAIG;IACH,YACE,UAAyB,EACR,OAAe,EACf,iBAAgC;QADhC,YAAO,GAAP,OAAO,CAAQ;QACf,sBAAiB,GAAjB,iBAAiB,CAAe;QAEjD,IAAI,CAAC,OAAO,GAAG,mBAAmB,CAAC,UAAU,CAAC,CAAC;IACjD,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;IAC9B,CAAC;IAED,oFAAoF;IACpF,WAAW,CACT,KAAoB,EACpB,MAAqB,EACrB,QAAgB,EAChB,WAAmB,EACnB,KAAa;QAEb,OAAO,aAAa,CAClB,2BAA2B,CACzB,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,EAC/C,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,iBAAiB,CACvB,CACF,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,IAAI,CACR,KAAoB,EACpB,MAAqB,EACrB,QAAgB,EAChB,WAAmB,EACnB,KAAa;QAEb,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAChD,2BAA2B,CACzB,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,EAC/C,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,iBAAiB,CACvB,CACF,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAClG,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,OAAsB;IACnD,OAAO,mBAAmB,CACxB;QACE,EAAE,IAAI,EAAE,SAAS,EAAE;QACnB;YACE,IAAI,EAAE,OAAO;YACb,UAAU,EAAE;gBACV,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;gBAClC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE;gBACnC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE;gBACrC,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE;gBACxC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;gBAClC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE;aACrC;SACF;KACF,EACD;QACE,WAAW;QACX;YACE,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,SAAS,EAAE,OAAO,CAAC,SAAS;SAC7B;KACF,CACF,CAAC;AACJ,CAAC"}

package/dist/claims.d.ts

@@ -0,0 +1,62 @@
+import type { Pool } from 'pg';
+import type { PlayerId } from '@flayerlabs/gamemode-spec';
+import type { EconomyBalance } from '@flayerlabs/gamemode-spec/live';
+import { Ledger, type BalanceKey } from './ledger.js';
+import type { PayloadSigner, SignedPayload } from './chain/signer.js';
+/**
+ * Turning points into something a player can actually spend.
+ *
+ * Two parties have to agree before a buy can happen, and they check different things. The ledger
+ * knows what this player earned and what they have already been authorised for. The signer knows
+ * whether it is willing to vouch for this pool at all. Only when both say yes does an
+ * authorisation exist.
+ *
+ * The order matters and is not interchangeable: the hold is recorded first, then signed. A
+ * signature that exists without a hold is spending nobody is tracking; a hold without a signature
+ * is a refund waiting to happen. Only one of those costs money.
+ */
+/** How long an authorisation stays valid. Long enough to approve in a wallet, short enough that an
+ *  abandoned one does not sit around spendable. */
+export declare const CLAIM_AUTHORIZATION_TTL_MS: number;
+/** Request ids cross an unauthenticated parser before they reach Postgres, so bound them here too. */
+export declare function isClaimRequestId(value: unknown): value is string;
+/** The signed message carries uint256, while JavaScript's bigint has no upper bound. */
+export declare function isClaimAmount(value: unknown): value is bigint;
+export type Authorisation = {
+    ok: true;
+    payload: SignedPayload;
+} | {
+    ok: false;
+    refuse: string;
+};
+export declare class Claims {
+    private readonly pool;
+    private readonly ledger;
+    private readonly signer;
+    /** Called when a hold could neither be signed nor released, and needs a human. */
+    private readonly onStrandedHold?;
+    /** An internal seam for exact window-boundary tests. Production uses the process clock. */
+    private readonly now;
+    constructor(pool: Pool, ledger: Ledger, signer: PayloadSigner, 
+    /** Called when a hold could neither be signed nor released, and needs a human. */
+    onStrandedHold?: ((nonce: bigint, error: unknown) => void) | undefined, 
+    /** An internal seam for exact window-boundary tests. Production uses the process clock. */
+    now?: () => number);
+    /**
+     * Authorise a player to spend up to `upToWei`, or explain why not.
+     *
+     * The ledger's ceiling is a conservative mirror of the chain's: the contract tracks
+     * `walletSpentWei` per pool per wallet and enforces it whatever we believe. Being ahead of the
+     * chain is safe — we simply authorise less than we could. Being behind it would mean issuing a
+     * signature that reverts at the swap, which to a player is indistinguishable from being robbed.
+     */
+    authorise(roundId: string, player: PlayerId, upToWei: bigint, requestId: string): Promise<Authorisation>;
+    private finish;
+    /** Give back every authorisation that expired unspent. */
+    releaseExpired(): Promise<BalanceKey[]>;
+    /** What this player could spend right now. */
+    availableWei(roundId: string, player: PlayerId): Promise<bigint>;
+    /** Full authoritative balance for live snapshots. */
+    economyBalance(roundId: string, player: PlayerId): Promise<EconomyBalance>;
+}
+//# sourceMappingURL=claims.d.ts.map

package/dist/claims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claims.d.ts","sourceRoot":"","sources":["../src/claims.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAC/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAErE,OAAO,EAAE,MAAM,EAAE,KAAK,UAAU,EAAc,MAAM,aAAa,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEtE;;;;;;;;;;;GAWG;AAEH;mDACmD;AACnD,eAAO,MAAM,0BAA0B,QAAa,CAAC;AAIrD,sGAAsG;AACtG,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEhE;AAED,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE7D;AAED,MAAM,MAAM,aAAa,GACrB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,aAAa,CAAA;CAAE,GACpC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC,qBAAa,MAAM;IAEf,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,kFAAkF;IAClF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAChC,2FAA2F;IAC3F,OAAO,CAAC,QAAQ,CAAC,GAAG;gBANH,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,aAAa;IACtC,kFAAkF;IACjE,cAAc,CAAC,GAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,aAAA;IACzE,2FAA2F;IAC1E,GAAG,GAAE,MAAM,MAAiB;IAG/C;;;;;;;OAOG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;YAyBhG,MAAM;IA4BpB,0DAA0D;IAC1D,cAAc,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAIvC,8CAA8C;IAC9C,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAIhE,qDAAqD;IACrD,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC;CAG3E"}