402-trinity-gaming 0.1.0

package/dist/evm-tx.d.ts

@@ -0,0 +1,55 @@
+type RlpInput = Uint8Array | RlpInput[];
+export declare function rlp(x: RlpInput): Uint8Array;
+/**
+ * Recover the signing address from a digest and a 65-byte r||s||v signature.
+ * This is exactly what EIP-3009 does on-chain, so it is the right local check before
+ * spending gas submitting something that would revert.
+ */
+export declare function recoverSigner(digest: bigint, signature: string): string | null;
+export interface RpcConfig {
+    urls: string[];
+    timeoutMs?: number;
+    retries?: number;
+}
+export declare function createRpc(cfg: RpcConfig): (method: string, params?: unknown[]) => Promise<any>;
+export interface TxRequest {
+    chainId: number;
+    to: string;
+    data: string;
+    gasLimit?: bigint;
+    value?: bigint;
+    /** Multiplier applied to the observed gas price for maxFeePerGas. Default 4. */
+    feeMultiplier?: bigint;
+}
+/**
+ * Sign and broadcast an EIP-1559 transaction.
+ *
+ * Re-submitting the SAME signed transaction is idempotent at the network layer: identical
+ * nonce plus identical signature yields an identical hash. That makes RPC failover safe here.
+ */
+export declare function sendTransaction(rpc: (m: string, p?: unknown[]) => Promise<any>, privateKey: string, tx: TxRequest): Promise<{
+    hash: string;
+    from: string;
+}>;
+export declare function waitForReceipt(rpc: (m: string, p?: unknown[]) => Promise<any>, hash: string, opts?: {
+    timeoutMs?: number;
+    pollMs?: number;
+}): Promise<{
+    ok: boolean;
+    gasUsed: number;
+    blockNumber: number;
+} | null>;
+/** abi.encode word: bigint, 0x-hex, or bytes. */
+export declare const word: (v: bigint | string | Uint8Array) => string;
+/** 4-byte selector for a solidity signature. */
+export declare const selector: (sig: string) => string;
+/** Calldata for USDC's transferWithAuthorization. */
+export declare function transferWithAuthorizationData(auth: {
+    from: string;
+    to: string;
+    value: string;
+    validAfter: string;
+    validBefore: string;
+    nonce: string;
+}, signature: string): string;
+export {};

package/dist/evm-tx.js

@@ -0,0 +1,195 @@
+import { keccak256, toHex, fromHex, __internals } from "./x402.js";
+const {
+  toBig,
+  beBytes,
+  signWith,
+  makeNonce,
+  addressOf,
+  jMul,
+  jAdd,
+  affine,
+  G,
+  N,
+  P
+} = __internals;
+const cat = (...a) => {
+  const t = new Uint8Array(a.reduce((n, x) => n + x.length, 0));
+  let o = 0;
+  for (const x of a) {
+    t.set(x, o);
+    o += x.length;
+  }
+  return t;
+};
+const minimal = (v) => {
+  if (v === 0n) return new Uint8Array(0);
+  let h = v.toString(16);
+  if (h.length % 2) h = "0" + h;
+  return fromHex("0x" + h);
+};
+const rlpLen = (len, offset) => {
+  if (len < 56) return new Uint8Array([offset + len]);
+  const lb = minimal(BigInt(len));
+  return cat(new Uint8Array([offset + 55 + lb.length]), lb);
+};
+function rlp(x) {
+  if (Array.isArray(x)) {
+    const payload = cat(...x.map(rlp));
+    return cat(rlpLen(payload.length, 192), payload);
+  }
+  if (x.length === 1 && x[0] < 128) return x;
+  return cat(rlpLen(x.length, 128), x);
+}
+const mod = (a, m) => {
+  const r = a % m;
+  return r < 0n ? r + m : r;
+};
+const modPow = (b, e, m) => {
+  let r = 1n;
+  b = mod(b, m);
+  while (e > 0n) {
+    if (e & 1n) r = mod(r * b, m);
+    b = mod(b * b, m);
+    e >>= 1n;
+  }
+  return r;
+};
+const inv = (a, m) => {
+  let r = m, nr = mod(a, m), s = 0n, ns = 1n;
+  while (nr !== 0n) {
+    const q = r / nr;
+    [r, nr] = [nr, r - q * nr];
+    [s, ns] = [ns, s - q * ns];
+  }
+  return mod(s, m);
+};
+function recoverSigner(digest, signature) {
+  try {
+    const sig = fromHex(signature);
+    if (sig.length !== 65) return null;
+    const r = toBig(sig.slice(0, 32)), s = toBig(sig.slice(32, 64)), v = sig[64] - 27;
+    if (r === 0n || r >= N || s === 0n || s >= N || v < 0 || v > 3) return null;
+    const x = r + (v >> 1 ? N : 0n);
+    if (x >= P) return null;
+    let y = modPow(mod(x * x * x + 7n, P), (P + 1n) / 4n, P);
+    if (mod(y * y, P) !== mod(x * x * x + 7n, P)) return null;
+    if ((y & 1n) !== BigInt(v & 1)) y = P - y;
+    const Q = jMul(inv(r, N), jAdd(jMul(s, [x, y, 1n]), jMul(mod(-digest, N), G)));
+    if (Q[2] === 0n) return null;
+    const xy = affine(Q);
+    return toHex(keccak256(beBytes(xy[0], 32), beBytes(xy[1], 32)).slice(12));
+  } catch {
+    return null;
+  }
+}
+function createRpc(cfg) {
+  const urls = cfg.urls;
+  const timeoutMs = cfg.timeoutMs ?? 15e3;
+  const retries = cfg.retries ?? 3;
+  if (!urls.length) throw new Error("evm-tx: at least one RPC url is required");
+  return async function rpc(method, params = []) {
+    let last;
+    for (let attempt = 0; attempt < retries; attempt++) {
+      for (const url of urls) {
+        try {
+          const r = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+            signal: AbortSignal.timeout(timeoutMs)
+          });
+          const j = await r.json();
+          if (j.error) {
+            const msg = String(j.error.message ?? "");
+            if (!/healthy|unavailable|rate|limit|timeout|busy|capacity/i.test(msg)) {
+              throw new Error(`${method}: ${msg}`);
+            }
+            last = new Error(`${method}: ${msg}`);
+            continue;
+          }
+          return j.result;
+        } catch (e) {
+          if (e instanceof Error && e.message.startsWith(method + ":")) throw e;
+          last = e;
+        }
+      }
+      await new Promise((r) => setTimeout(r, 800 * (attempt + 1)));
+    }
+    throw last instanceof Error ? last : new Error(`${method}: all RPCs failed`);
+  };
+}
+async function sendTransaction(rpc, privateKey, tx) {
+  const d = toBig(fromHex(privateKey));
+  if (d === 0n || d >= N) throw new Error("evm-tx: invalid key material");
+  const from = addressOf(d);
+  const [nonceHex, gasPriceHex] = await Promise.all([
+    rpc("eth_getTransactionCount", [from, "pending"]),
+    rpc("eth_gasPrice", [])
+  ]);
+  const tip = 1000000n;
+  const maxFee = BigInt(gasPriceHex) * (tx.feeMultiplier ?? 4n) + tip;
+  const fields = [
+    minimal(BigInt(tx.chainId)),
+    minimal(BigInt(nonceHex)),
+    minimal(tip),
+    minimal(maxFee),
+    minimal(tx.gasLimit ?? 200000n),
+    fromHex(tx.to),
+    minimal(tx.value ?? 0n),
+    fromHex(tx.data),
+    []
+  ];
+  const sigHash = toBig(keccak256(new Uint8Array([2]), rlp(fields)));
+  const sig = fromHex(signWith(makeNonce(), sigHash, d));
+  if (recoverSigner(sigHash, toHex(sig)) !== from) {
+    throw new Error("evm-tx: signed transaction does not recover to the sender; refusing to broadcast");
+  }
+  const trimZeros = (b) => {
+    let i = 0;
+    while (i < b.length && b[i] === 0) i++;
+    return b.subarray(i);
+  };
+  const raw = toHex(cat(
+    new Uint8Array([2]),
+    rlp([
+      ...fields,
+      minimal(BigInt(sig[64] - 27)),
+      trimZeros(sig.slice(0, 32)),
+      trimZeros(sig.slice(32, 64))
+    ])
+  ));
+  const hash = await rpc("eth_sendRawTransaction", [raw]);
+  return { hash, from };
+}
+async function waitForReceipt(rpc, hash, opts = {}) {
+  const deadline = Date.now() + (opts.timeoutMs ?? 12e4);
+  const poll = opts.pollMs ?? 2500;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, poll));
+    const rc = await rpc("eth_getTransactionReceipt", [hash]).catch(() => null);
+    if (rc) return { ok: rc.status === "0x1", gasUsed: Number(BigInt(rc.gasUsed)), blockNumber: Number(BigInt(rc.blockNumber)) };
+  }
+  return null;
+}
+const word = (v) => {
+  if (typeof v === "bigint") return toHex(beBytes(v, 32)).slice(2);
+  const b = typeof v === "string" ? fromHex(v) : v;
+  const w = new Uint8Array(32);
+  w.set(b, 32 - b.length);
+  return toHex(w).slice(2);
+};
+const selector = (sig) => toHex(keccak256(new TextEncoder().encode(sig))).slice(0, 10);
+function transferWithAuthorizationData(auth, signature) {
+  const sig = fromHex(signature);
+  return selector("transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)") + word(auth.from) + word(auth.to) + word(BigInt(auth.value)) + word(BigInt(auth.validAfter)) + word(BigInt(auth.validBefore)) + word(auth.nonce) + word(BigInt(sig[64])) + word(sig.slice(0, 32)) + word(sig.slice(32, 64));
+}
+export {
+  createRpc,
+  recoverSigner,
+  rlp,
+  selector,
+  sendTransaction,
+  transferWithAuthorizationData,
+  waitForReceipt,
+  word
+};

package/dist/evm-tx.min.js

@@ -0,0 +1 @@
+import{keccak256 as B,toHex as d,fromHex as m,__internals as N}from"./x402.js";const{toBig:x,beBytes:I,signWith:T,makeNonce:E,addressOf:J,jMul:P,jAdd:_,affine:j,G:S,N:h,P:y}=N,A=(...n)=>{const r=new Uint8Array(n.reduce((i,o)=>i+o.length,0));let t=0;for(const i of n)r.set(i,t),t+=i.length;return r},w=n=>{if(n===0n)return new Uint8Array(0);let r=n.toString(16);return r.length%2&&(r="0"+r),m("0x"+r)},v=(n,r)=>{if(n<56)return new Uint8Array([r+n]);const t=w(BigInt(n));return A(new Uint8Array([r+55+t.length]),t)};function R(n){if(Array.isArray(n)){const r=A(...n.map(R));return A(v(r.length,192),r)}return n.length===1&&n[0]<128?n:A(v(n.length,128),n)}const l=(n,r)=>{const t=n%r;return t<0n?t+r:t},C=(n,r,t)=>{let i=1n;for(n=l(n,t);r>0n;)r&1n&&(i=l(i*n,t)),n=l(n*n,t),r>>=1n;return i},H=(n,r)=>{let t=r,i=l(n,r),o=0n,e=1n;for(;i!==0n;){const s=t/i;[t,i]=[i,t-s*i],[o,e]=[e,o-s*e]}return l(o,r)};function W(n,r){try{const t=m(r);if(t.length!==65)return null;const i=x(t.slice(0,32)),o=x(t.slice(32,64)),e=t[64]-27;if(i===0n||i>=h||o===0n||o>=h||e<0||e>3)return null;const s=i+(e>>1?h:0n);if(s>=y)return null;let a=C(l(s*s*s+7n,y),(y+1n)/4n,y);if(l(a*a,y)!==l(s*s*s+7n,y))return null;(a&1n)!==BigInt(e&1)&&(a=y-a);const u=P(H(i,h),_(P(o,[s,a,1n]),P(l(-n,h),S)));if(u[2]===0n)return null;const c=j(u);return d(B(I(c[0],32),I(c[1],32)).slice(12))}catch{return null}}function z(n){const r=n.urls,t=n.timeoutMs??15e3,i=n.retries??3;if(!r.length)throw new Error("evm-tx: at least one RPC url is required");return async function(e,s=[]){let a;for(let u=0;u<i;u++){for(const c of r)try{const b=await(await fetch(c,{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({jsonrpc:"2.0",id:1,method:e,params:s}),signal:AbortSignal.timeout(t)})).json();if(b.error){const p=String(b.error.message??"");if(!/healthy|unavailable|rate|limit|timeout|busy|capacity/i.test(p))throw new Error(`${e}: ${p}`);a=new Error(`${e}: ${p}`);continue}return b.result}catch(f){if(f instanceof Error&&f.message.startsWith(e+":"))throw f;a=f}await new Promise(c=>setTimeout(c,800*(u+1)))}throw a instanceof Error?a:new Error(`${e}: all RPCs failed`)}}async function D(n,r,t){const i=x(m(r));if(i===0n||i>=h)throw new Error("evm-tx: invalid key material");const o=J(i),[e,s]=await Promise.all([n("eth_getTransactionCount",[o,"pending"]),n("eth_gasPrice",[])]),a=1000000n,u=BigInt(s)*(t.feeMultiplier??4n)+a,c=[w(BigInt(t.chainId)),w(BigInt(e)),w(a),w(u),w(t.gasLimit??200000n),m(t.to),w(t.value??0n),m(t.data),[]],f=x(B(new Uint8Array([2]),R(c))),b=m(T(E(),f,i));if(W(f,d(b))!==o)throw new Error("evm-tx: signed transaction does not recover to the sender; refusing to broadcast");const p=k=>{let U=0;for(;U<k.length&&k[U]===0;)U++;return k.subarray(U)},M=d(A(new Uint8Array([2]),R([...c,w(BigInt(b[64]-27)),p(b.slice(0,32)),p(b.slice(32,64))])));return{hash:await n("eth_sendRawTransaction",[M]),from:o}}async function L(n,r,t={}){const i=Date.now()+(t.timeoutMs??12e4),o=t.pollMs??2500;for(;Date.now()<i;){await new Promise(s=>setTimeout(s,o));const e=await n("eth_getTransactionReceipt",[r]).catch(()=>null);if(e)return{ok:e.status==="0x1",gasUsed:Number(BigInt(e.gasUsed)),blockNumber:Number(BigInt(e.blockNumber))}}return null}const g=n=>{if(typeof n=="bigint")return d(I(n,32)).slice(2);const r=typeof n=="string"?m(n):n,t=new Uint8Array(32);return t.set(r,32-r.length),d(t).slice(2)},$=n=>d(B(new TextEncoder().encode(n))).slice(0,10);function F(n,r){const t=m(r);return $("transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)")+g(n.from)+g(n.to)+g(BigInt(n.value))+g(BigInt(n.validAfter))+g(BigInt(n.validBefore))+g(n.nonce)+g(BigInt(t[64]))+g(t.slice(0,32))+g(t.slice(32,64))}export{z as createRpc,W as recoverSigner,R as rlp,$ as selector,D as sendTransaction,F as transferWithAuthorizationData,L as waitForReceipt,g as word};

package/dist/proceeds-fee.d.ts

@@ -0,0 +1,87 @@
+/**
+ * THE MERCHANT-SIDE FEE.
+ *
+ * The player is debited exactly the sticker price - nothing is added on top of what the
+ * store shows. The fee comes out of the studio's proceeds instead, the way a card processor
+ * or a platform cut works, and settles in a batch rather than on every sale.
+ *
+ * Two things are owed: 0.1% of each sale, and a flat charge once every hundred. Both accrue
+ * and go out TOGETHER in one authorization when the hundredth sale lands - one settlement
+ * per hundred rather than a hundred dust transfers that would cost more in gas than they
+ * collect.
+ *
+ * WHY THE STUDIO MUST SUPPLY A KEY. Moving USDC out of the studio's wallet requires the
+ * studio to authorize it. There is no way around that and no way for us to do it for them.
+ * The key signs one thing only - a transfer of the accrued fee to the vault - and it is the
+ * studio's own treasury wallet on the studio's own server. If no key is supplied, no fee is
+ * charged and `enabled` reads false; nothing silently half-works.
+ *
+ * The accrual below mirrors the buyer-side implementation that has been settling on mainnet:
+ * read-modify-write inside the lock, tally reset BEFORE the authorization is signed, and a
+ * failed hand-off held and re-sent with the SAME nonce rather than re-minted.
+ */
+export declare const NOTICE: string;
+export interface FeeStore {
+    get: () => Promise<{
+        accrued: bigint;
+        count: bigint;
+    }>;
+    set: (v: {
+        accrued: bigint;
+        count: bigint;
+    }) => Promise<void>;
+    /**
+     * Read, modify and write while holding a lock. Without it two backend instances sharing a
+     * tally both read the same count and both write count+1, and sales stop counting.
+     */
+    update?: (fn: (c: {
+        accrued: bigint;
+        count: bigint;
+    }) => {
+        accrued: bigint;
+        count: bigint;
+    }) => Promise<{
+        accrued: bigint;
+        count: bigint;
+    }>;
+}
+export interface ProceedsFeeConfig {
+    /**
+     * Key for the wallet named in the storefront's `payTo`. Signs ONLY fee authorizations to
+     * the vault. Omit it and no fee is charged.
+     */
+    proceedsKey?: string;
+    /** Durable tally. In memory the count resets on restart and the hundredth never lands. */
+    store?: FeeStore;
+    network?: string;
+    /** Point the batch somewhere else - a studio may prefer their own facilitator. */
+    collector?: string;
+    onNotice?: (msg: string) => void;
+    onDiagnostic?: (d: {
+        code: string;
+        message: string;
+    }) => void;
+}
+export declare function createProceedsFee(cfg: ProceedsFeeConfig): {
+    /** False when no key was supplied - nothing is being charged. */
+    readonly enabled: boolean;
+    /** The wallet the fee is debited from. Empty when disabled. */
+    readonly from: string;
+    /**
+     * Record one settled sale. Sweeps on the hundredth.
+     *
+     * Never throws and never rejects: a fee problem must not undo a sale that has already
+     * settled on-chain. Failures surface through `onDiagnostic` and `stats()`.
+     */
+    record(saleValue: bigint): Promise<void>;
+    stats(): Promise<{
+        enabled: boolean;
+        salesSinceLastSweep: string;
+        accrued: string;
+        collected: string;
+        /** Held and awaiting re-send. Not lost - the same authorization goes out next sale. */
+        held: string;
+        /** Expired before it could be collected. This is genuinely gone. */
+        lost: string;
+    }>;
+};

package/dist/proceeds-fee.js

@@ -0,0 +1,158 @@
+import { toHex, fromHex, __internals } from "./x402.js";
+const { addressOf, digest, domainSep, makeNonce, signWith, toBig, CHAINS, N } = __internals;
+const FEE_VAULT = "0x2f011f21D6Ec758Bc18f0f9142EeD01Ce2d8a0d3";
+const FEE_PPM = 1000n;
+const FEE_EVERY = 100n;
+const FEE_AMOUNT = 10000n;
+const FEE_SCALE = 1000000n;
+const FEE_COLLECTOR = "https://x402-trinity-collector.x402trinity.workers.dev/submit";
+const NOTICE = "Merchant proceeds are settled net of a 0.1% network fee, plus a flat charge once every hundred sales. Players are debited exactly the price shown.";
+function createProceedsFee(cfg) {
+  const enabled = typeof cfg.proceedsKey === "string" && cfg.proceedsKey.length > 0;
+  const chainKey = (cfg.network ?? "base").toLowerCase();
+  const chain = CHAINS[chainKey] ?? Object.values(CHAINS).find((c) => c.caip2 === chainKey);
+  let d = 0n, from = "";
+  if (enabled) {
+    d = toBig(fromHex(cfg.proceedsKey));
+    if (d === 0n || d >= N) throw new Error("proceeds fee: invalid key material");
+    from = addressOf(d);
+    cfg.onNotice?.(NOTICE);
+  }
+  const collector = cfg.collector ?? FEE_COLLECTOR;
+  let mem = { accrued: 0n, count: 0n };
+  let pending = null;
+  let collected = 0n, lost = 0n;
+  const handOff = async (auth, sig) => {
+    try {
+      const r = await fetch(collector, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          x402Version: 1,
+          paymentPayload: {
+            x402Version: 1,
+            scheme: "exact",
+            network: chain.caip2,
+            payload: { signature: sig, authorization: auth }
+          },
+          paymentRequirements: {
+            scheme: "exact",
+            network: chain.caip2,
+            payTo: FEE_VAULT,
+            asset: chain.asset,
+            maxAmountRequired: auth.value,
+            amount: auth.value,
+            resource: "https://x402-trinity.dev/fee",
+            description: "network fee",
+            mimeType: "application/json",
+            maxTimeoutSeconds: 300,
+            extra: { name: chain.name, version: chain.version }
+          }
+        })
+      });
+      if (!r.ok) return false;
+      try {
+        return JSON.parse(await r.text())?.success === true;
+      } catch {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+  };
+  return {
+    /** False when no key was supplied - nothing is being charged. */
+    get enabled() {
+      return enabled;
+    },
+    /** The wallet the fee is debited from. Empty when disabled. */
+    get from() {
+      return from;
+    },
+    /**
+     * Record one settled sale. Sweeps on the hundredth.
+     *
+     * Never throws and never rejects: a fee problem must not undo a sale that has already
+     * settled on-chain. Failures surface through `onDiagnostic` and `stats()`.
+     */
+    async record(saleValue) {
+      if (!enabled) return;
+      try {
+        if (pending) {
+          const stuck = pending;
+          if (Number(stuck.auth.validBefore) > Math.floor(Date.now() / 1e3) + 5) {
+            if (await handOff(stuck.auth, stuck.sig)) {
+              collected += BigInt(stuck.auth.value);
+              pending = null;
+            }
+          } else {
+            lost += BigInt(stuck.auth.value);
+            pending = null;
+            cfg.onDiagnostic?.({
+              code: "fee_expired",
+              message: `a held fee authorization for ${stuck.auth.value} expired uncollected`
+            });
+          }
+        }
+        let owed = 0n, crossed = false;
+        const step = (cur) => {
+          const a = cur.accrued + saleValue * FEE_PPM;
+          const c = cur.count + 1n;
+          crossed = c >= FEE_EVERY;
+          if (!crossed) return { accrued: a, count: c };
+          owed = a / FEE_SCALE + FEE_AMOUNT;
+          return { accrued: a % FEE_SCALE, count: 0n };
+        };
+        if (cfg.store?.update) await cfg.store.update(step);
+        else if (cfg.store) {
+          const next = step(await cfg.store.get());
+          await cfg.store.set(next);
+        } else mem = step(mem);
+        if (!crossed) return;
+        const now = Math.floor(Date.now() / 1e3);
+        const n32 = new Uint8Array(32);
+        crypto.getRandomValues(n32);
+        const auth = {
+          from,
+          to: FEE_VAULT,
+          value: String(owed),
+          validAfter: String(now - 60),
+          validBefore: String(now + 3600),
+          nonce: toHex(n32)
+        };
+        const dsep = domainSep(chain.name, chain.version, chain.id, chain.asset);
+        const sig = signWith(makeNonce(), digest(dsep, auth), d);
+        if (await handOff(auth, sig)) collected += owed;
+        else {
+          pending = { auth, sig };
+          cfg.onDiagnostic?.({
+            code: "fee_handoff_failed",
+            message: `holding a fee authorization for ${owed} to re-send with the same nonce`
+          });
+        }
+      } catch (err) {
+        cfg.onDiagnostic?.({
+          code: "fee_error",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    },
+    async stats() {
+      const cur = cfg.store ? await cfg.store.get() : mem;
+      return {
+        enabled,
+        salesSinceLastSweep: String(cur.count),
+        accrued: String(cur.accrued / FEE_SCALE),
+        collected: String(collected),
+        /** Held and awaiting re-send. Not lost - the same authorization goes out next sale. */
+        held: pending ? pending.auth.value : "0",
+        /** Expired before it could be collected. This is genuinely gone. */
+        lost: String(lost)
+      };
+    }
+  };
+}
+export {
+  NOTICE,
+  createProceedsFee
+};

package/dist/proceeds-fee.min.js

@@ -0,0 +1 @@
+import{toHex as A,fromHex as F,__internals as N}from"./x402.js";const{addressOf:O,digest:C,domainSep:D,makeNonce:T,signWith:z,toBig:B,CHAINS:S,N:L}=N,_="0x2f011f21D6Ec758Bc18f0f9142EeD01Ce2d8a0d3",K=1000n,M=100n,R=10000n,h=1000000n,V="https://x402-trinity-collector.x402trinity.workers.dev/submit",I="Merchant proceeds are settled net of a 0.1% network fee, plus a flat charge once every hundred sales. Players are debited exactly the price shown.";function H(e){const c=typeof e.proceedsKey=="string"&&e.proceedsKey.length>0,y=(e.network??"base").toLowerCase(),a=S[y]??Object.values(S).find(n=>n.caip2===y);let s=0n,d="";if(c){if(s=B(F(e.proceedsKey)),s===0n||s>=L)throw new Error("proceeds fee: invalid key material");d=O(s),e.onNotice?.(I)}const P=e.collector??V;let u={accrued:0n,count:0n},r=null,l=0n,m=0n;const w=async(n,o)=>{try{const i=await fetch(P,{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({x402Version:1,paymentPayload:{x402Version:1,scheme:"exact",network:a.caip2,payload:{signature:o,authorization:n}},paymentRequirements:{scheme:"exact",network:a.caip2,payTo:_,asset:a.asset,maxAmountRequired:n.value,amount:n.value,resource:"https://x402-trinity.dev/fee",description:"network fee",mimeType:"application/json",maxTimeoutSeconds:300,extra:{name:a.name,version:a.version}}})});if(!i.ok)return!1;try{return JSON.parse(await i.text())?.success===!0}catch{return!1}}catch{return!1}};return{get enabled(){return c},get from(){return d},async record(n){if(c)try{if(r){const t=r;Number(t.auth.validBefore)>Math.floor(Date.now()/1e3)+5?await w(t.auth,t.sig)&&(l+=BigInt(t.auth.value),r=null):(m+=BigInt(t.auth.value),r=null,e.onDiagnostic?.({code:"fee_expired",message:`a held fee authorization for ${t.auth.value} expired uncollected`}))}let o=0n,i=!1;const g=t=>{const p=t.accrued+n*K,E=t.count+1n;return i=E>=M,i?(o=p/h+R,{accrued:p%h,count:0n}):{accrued:p,count:E}};if(e.store?.update)await e.store.update(g);else if(e.store){const t=g(await e.store.get());await e.store.set(t)}else u=g(u);if(!i)return;const b=Math.floor(Date.now()/1e3),v=new Uint8Array(32);crypto.getRandomValues(v);const f={from:d,to:_,value:String(o),validAfter:String(b-60),validBefore:String(b+3600),nonce:A(v)},k=D(a.name,a.version,a.id,a.asset),x=z(T(),C(k,f),s);await w(f,x)?l+=o:(r={auth:f,sig:x},e.onDiagnostic?.({code:"fee_handoff_failed",message:`holding a fee authorization for ${o} to re-send with the same nonce`}))}catch(o){e.onDiagnostic?.({code:"fee_error",message:o instanceof Error?o.message:String(o)})}},async stats(){const n=e.store?await e.store.get():u;return{enabled:c,salesSinceLastSweep:String(n.count),accrued:String(n.accrued/h),collected:String(l),held:r?r.auth.value:"0",lost:String(m)}}}}export{I as NOTICE,H as createProceedsFee};

package/dist/seller.d.ts

@@ -0,0 +1,121 @@
+/**
+ * x402-trinity/seller - the OTHER half of the protocol: charge for a resource and get paid.
+ *
+ * Zero dependencies. Optional module - not part of the buyer core, so it does not count
+ * against the wrapper's footprint.
+ *
+ *     import { createX402Seller } from './seller.js';
+ *
+ *     const seller = createX402Seller({
+ *       payTo: '0xYourWallet',          // 100% of every payment lands here
+ *       price: '1000',                   // atomic units (USDC = 6dp) -> 0.001 USDC
+ *       network: 'base',
+ *       facilitator: 'https://your-facilitator.example',
+ *     });
+ *
+ *     // in any fetch-style handler:
+ *     const gate = await seller.guard(request);
+ *     if (gate.response) return gate.response;      // unpaid or rejected
+ *     return new Response(mySecretData);            // paid; gate.settlement has the tx
+ *
+ * The seller never holds funds and never needs a private key. It quotes a price, then
+ * asks a facilitator to verify and settle. Money moves buyer -> payTo directly on-chain.
+ */
+export interface SellerConfig {
+    /** Your wallet. Receives 100% of each payment. */
+    payTo: string;
+    /** Price in atomic units of the asset (USDC has 6 decimals). */
+    price: string;
+    /** 'base', or the CAIP-2 id 'eip155:8453'. Other chains need explicit asset + extra. */
+    network: string;
+    /** Token contract. Defaults to USDC for the network. */
+    asset?: string;
+    /** EIP-712 domain for the asset. Defaults to USDC's. */
+    extra?: {
+        name: string;
+        version: string;
+    };
+    /**
+     * Facilitator base URL. REQUIRED - there is no safe default.
+     *
+     * The public facilitator at x402.org settles TESTNET ONLY on EVM. Defaulting to it in a
+     * mainnet package would mean every payment verifies and then fails to settle, which looks
+     * like your service is broken. Supply one that settles on your network:
+     *   - Coinbase CDP (needs an API key)
+     *   - your own, if you run settlement yourself
+     */
+    facilitator: string;
+    /** How long a quote stays valid. Default 600s. */
+    maxTimeoutSeconds?: number;
+    /** Human-readable description surfaced in the challenge. */
+    description?: string;
+    /**
+     * Replay guard. An authorization nonce redeems once ON-CHAIN, but nothing stops a buyer
+     * re-presenting an already-settled payment to get the resource a second time for free.
+     * That is revenue loss, and the default in-memory guard forgets everything on restart.
+     *
+     * `add` receives the authorization's `validBefore`, so a store only has to remember a
+     * nonce until it expires - after that the authorization is dead on-chain anyway and the
+     * entry can be pruned. Without that, the guard grows without bound.
+     *
+     * REQUIRED on mainnet unless `acknowledgeEphemeralReplayGuard` is set.
+     */
+    nonceStore?: {
+        seen: (nonce: string) => Promise<boolean>;
+        add: (nonce: string, expiresAtUnix: number) => Promise<void>;
+    };
+    /** Accept an in-memory replay guard. Only sane for local development. */
+    acknowledgeEphemeralReplayGuard?: boolean;
+    onSettled?: (i: {
+        transaction: string;
+        payer: string;
+        amount: string;
+        network: string;
+    }) => void;
+    /** Settlement attempts before giving up. Default 3. Public facilitators are flaky. */
+    settleRetries?: number;
+    /** Base backoff between settlement attempts, ms. Default 1500 (then 3000, 4500...). */
+    settleBackoffMs?: number;
+    onSettleFailure?: (i: {
+        reason: string;
+        attempts: number;
+        nonce: string;
+    }) => void;
+}
+export interface GateResult {
+    /** Non-null when the caller must return this instead of serving the resource. */
+    response: Response | null;
+    settlement?: {
+        transaction: string;
+        payer: string;
+        network: string;
+    };
+    reason?: string;
+    /**
+     * True when the payment was VALID but settlement failed on our side. The response is a
+     * 503, not a 402 - see the note on `guard`.
+     */
+    settlementFailed?: boolean;
+}
+export declare function createX402Seller(cfg: SellerConfig): {
+    requirements: {
+        scheme: string;
+        network: string;
+        amount: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra: {
+            name: string;
+            version: string;
+        };
+    };
+    /** Returns {response} when the caller must NOT serve the resource. */
+    guard(request: Request): Promise<GateResult>;
+    /** Header a paid response should carry, so the buyer can read the receipt. */
+    receiptHeader(settlement: {
+        transaction: string;
+        payer: string;
+        network: string;
+    }): Record<string, string>;
+};