yappr 0.1.0

package/dist/src/treasury/cycle.js

@@ -0,0 +1,154 @@
+import { config } from "../config.js";
+import { runOnBeforeClaim, runOnAfterClaim, runOnSwap, } from "../hooks/registry.js";
+import { WETH } from "./index.js";
+import { formatUnits } from "viem";
+import { recordDevWeth } from "../stats.js";
+// The self-funding loop, run on a timer (TREASURY_INTERVAL_MS). Each cycle:
+// claim fees → pay optional dev cut → burn a share of the token → keep a small ETH
+// gas reserve → swap remaining WETH to USDC → top up compute when it's expiring.
+// All amounts are wei BigInts; treasury.* methods are no-ops under TREASURY_DRY_RUN.
+// 0.0001 ETH in wei — kept unwrapped as a gas reserve so the wallet can transact.
+const ETH_RESERVE = 100000000000000n;
+// Run one full treasury/claim cycle. Exported so the entry point can fire one at
+// startup (every launch) before the recurring scheduler takes over.
+export async function runTreasuryCycle(treasury, log) {
+    log.info("treasury cycle start");
+    const result = {
+        tokenClaimed: 0n,
+        wethClaimed: 0n,
+        tokenBurned: 0n,
+        tokenToDev: 0n,
+        wethToDev: 0n,
+        wethUnwrapped: 0n,
+        wethSwapped: 0n,
+        computeExtended: false,
+        txHashes: [],
+        cycledAt: new Date().toISOString(),
+    };
+    try {
+        log.info("treasury step: reading wallet balances");
+        const balances = await treasury.balances();
+        log.info({
+            token: formatUnits(balances.token, 18),
+            weth: formatUnits(balances.weth, 18),
+            usdc: formatUnits(balances.usdc, 6),
+            eth: formatUnits(balances.eth, 18),
+            dryRun: config.treasuryDryRun || undefined,
+        }, "treasury balances");
+        await runOnBeforeClaim(balances);
+        // Only claim when there's actually something to collect — the claim is an
+        // on-chain tx that costs gas even when no fees have accrued. On a failed check
+        // we fall back to attempting the claim so we never silently stop collecting.
+        let token = 0n;
+        let weth = 0n;
+        let shouldClaim = true;
+        log.info("treasury step: checking claimable fees");
+        try {
+            const claimable = await treasury.claimableFees();
+            shouldClaim = claimable.hasClaimable;
+            log.info({ token0: claimable.token0, token1: claimable.token1, hasClaimable: claimable.hasClaimable }, "claimable fees");
+            if (!shouldClaim) {
+                log.info("no unclaimed fees — skipping claim this cycle");
+            }
+        }
+        catch (err) {
+            log.warn({ err }, "claimable-fee check failed — attempting claim anyway");
+        }
+        if (shouldClaim) {
+            log.info("treasury step: claiming fees");
+            ({ token, weth } = await treasury.claimFees());
+            result.tokenClaimed = token;
+            result.wethClaimed = weth;
+            log.info({ token: formatUnits(token, 18), weth: formatUnits(weth, 18) }, "fees claimed");
+        }
+        // Dev fee — send a cut of each claimed asset to the dev address. The cut is
+        // computed on the total amount claimed this cycle, before burn/swap.
+        let wethRemaining = weth;
+        if (token === 0n && weth === 0n) {
+            log.info("nothing claimed this cycle — skipping dev cut, burn and swap");
+        }
+        if (config.devAddress && (token > 0n || weth > 0n)) {
+            log.info("treasury step: dev cut");
+            if (config.devTokenBps > 0 && token > 0n) {
+                const devToken = (token * BigInt(config.devTokenBps)) / 10000n;
+                if (devToken > 0n) {
+                    const txHash = await treasury.transferToken(config.tokenAddress, config.devAddress, devToken);
+                    result.tokenToDev = devToken;
+                    result.txHashes.push(txHash);
+                    log.info({ devToken: devToken.toString(), txHash }, "token sent to dev");
+                }
+            }
+            if (config.devWethBps > 0 && weth > 0n) {
+                const devWeth = (weth * BigInt(config.devWethBps)) / 10000n;
+                if (devWeth > 0n) {
+                    const txHash = await treasury.transferToken(WETH, config.devAddress, devWeth);
+                    result.wethToDev = devWeth;
+                    result.txHashes.push(txHash);
+                    wethRemaining = weth - devWeth;
+                    recordDevWeth(Number(formatUnits(devWeth, 18))); // track cumulative dev revenue (WETH)
+                    log.info({ devWeth: devWeth.toString(), txHash }, "weth sent to dev");
+                }
+            }
+        }
+        if (token > 0n) {
+            const burnAmount = (token * BigInt(config.burnBps)) / 10000n;
+            if (burnAmount > 0n) {
+                log.info({ burnAmount: formatUnits(burnAmount, 18) }, "treasury step: burning token");
+                await runOnSwap("burn", burnAmount);
+                const txHash = await treasury.burnToken(burnAmount);
+                result.tokenBurned = burnAmount;
+                result.txHashes.push(txHash);
+                log.info({ burnAmount: burnAmount.toString(), txHash }, "token burned");
+            }
+        }
+        if (wethRemaining > 0n) {
+            let wethToSwap = wethRemaining;
+            if (wethRemaining > ETH_RESERVE && balances.eth < ETH_RESERVE) {
+                const txHash = await treasury.unwrapWethToEth(ETH_RESERVE);
+                result.wethUnwrapped = ETH_RESERVE;
+                result.txHashes.push(txHash);
+                wethToSwap = wethRemaining - ETH_RESERVE;
+                log.info({ amount: ETH_RESERVE.toString(), txHash }, "unwrapped WETH to ETH for gas reserve");
+            }
+            if (wethToSwap > 0n) {
+                log.info({ weth: formatUnits(wethToSwap, 18) }, "treasury step: swapping WETH to USDC");
+                await runOnSwap("swap", wethToSwap);
+                const txHash = await treasury.swapWethToUsdc(wethToSwap);
+                result.wethSwapped = wethToSwap;
+                result.txHashes.push(txHash);
+                log.info({ weth: wethToSwap.toString(), txHash }, "weth swapped to usdc");
+            }
+        }
+        if (config.computeInstanceId) {
+            log.info("treasury step: checking compute expiry");
+            const expiry = await treasury.computeExpiry();
+            if (!expiry) {
+                // Unknown expiry → do NOT buy. Extending on a failed lookup would silently
+                // purchase compute every cycle. Better to skip and surface the problem.
+                log.warn("could not determine compute expiry — skipping extension to avoid an unintended purchase");
+            }
+            else {
+                const hoursRemaining = (expiry.getTime() - Date.now()) / (1000 * 60 * 60);
+                if (hoursRemaining < 24) {
+                    await treasury.extendCompute();
+                    result.computeExtended = true;
+                    log.info({ hoursRemaining: hoursRemaining.toFixed(1) }, "compute extended (+24h)");
+                }
+                else {
+                    log.info({ hoursRemaining: hoursRemaining.toFixed(1), expiry }, "compute has sufficient time remaining — skipping extension");
+                }
+            }
+        }
+        await runOnAfterClaim(result);
+        log.info({ cycledAt: result.cycledAt }, "treasury cycle complete");
+    }
+    catch (err) {
+        log.error({ err }, "treasury cycle failed");
+    }
+}
+// Schedule the recurring treasury cycle. The caller runs the initial startup cycle
+// itself (see src/yappr.ts), so this only sets up the timer for subsequent runs.
+export function startTreasury(treasury, log) {
+    const timer = setInterval(() => void runTreasuryCycle(treasury, log), config.treasuryIntervalMs);
+    return () => clearInterval(timer);
+}

package/dist/src/treasury/index.d.ts

@@ -0,0 +1,28 @@
+export type TreasuryBalances = {
+    token: bigint;
+    weth: bigint;
+    usdc: bigint;
+    eth: bigint;
+};
+export interface Treasury {
+    claimableFees(): Promise<{
+        token0: string;
+        token1: string;
+        hasClaimable: boolean;
+    }>;
+    claimFees(): Promise<{
+        token: bigint;
+        weth: bigint;
+    }>;
+    burnToken(amount: bigint): Promise<string>;
+    transferToken(token: `0x${string}`, to: `0x${string}`, amount: bigint): Promise<string>;
+    unwrapWethToEth(amount: bigint): Promise<string>;
+    swapWethToUsdc(amount: bigint): Promise<string>;
+    extendCompute(): Promise<void>;
+    computeExpiry(): Promise<Date | null>;
+    balances(): Promise<TreasuryBalances>;
+    lifetimeEarned(): Promise<number>;
+}
+export declare const WETH: `0x${string}`;
+export declare function getTreasury(): Treasury;
+export declare function createBankrTreasury(): Treasury;

package/dist/src/treasury/index.js

@@ -0,0 +1,222 @@
+import { encodeFunctionData, createPublicClient, http } from "viem";
+import { base } from "viem/chains";
+import { submitTx, walletAddress, payFetch, paidUsd } from "../wallet.js";
+import { bankrApi } from "../bankr.js";
+import { fetchComputeInstance, computeInstanceExpiry } from "../compute.js";
+import { config } from "../config.js";
+import { log } from "../log.js";
+import { sleep, envNumber } from "../util.js";
+import { ERC20_ABI, WETH_ABI, UNISWAP_ROUTER_ABI } from "./abi.js";
+const UNISWAP_ROUTER = "0x2626664c2603336E57B271c5C0b26F421741e481";
+export const WETH = "0x4200000000000000000000000000000000000006";
+const USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+const BURN_ADDRESS = "0x000000000000000000000000000000000000dead";
+const publicClient = createPublicClient({ chain: base, transport: http() });
+function erc20Balance(token, owner) {
+    return publicClient.readContract({
+        address: token, abi: ERC20_ABI, functionName: "balanceOf", args: [owner],
+    });
+}
+// Retry a read-only step with exponential backoff (2s → 4s → 8s → 16s). The public
+// Base RPC rate-limits bursts (seen as "over rate limit" eth_call failures), and a
+// transient read failure must never abort a cycle that has already moved money.
+// Only ever wrap reads — never claim/submit calls.
+const READ_ATTEMPTS = envNumber("TREASURY_READ_ATTEMPTS", 5);
+async function readWithRetry(step, fn) {
+    let lastErr;
+    for (let attempt = 1; attempt <= READ_ATTEMPTS; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt < READ_ATTEMPTS) {
+                const delayMs = 2000 * 2 ** (attempt - 1);
+                log.warn({ step, attempt, maxAttempts: READ_ATTEMPTS, delayMs, err: err instanceof Error ? err.message : String(err) }, "treasury read failed — retrying after backoff");
+                await sleep(delayMs);
+            }
+        }
+    }
+    throw lastErr;
+}
+let _treasury = null;
+export function getTreasury() {
+    if (!_treasury)
+        _treasury = createBankrTreasury();
+    return _treasury;
+}
+export function createBankrTreasury() {
+    return {
+        // Read-only check (no tx, no payment) of unclaimed creator fees for our token,
+        // via Bankr's GET /token-launches/:addr/fees. The treasury cycle uses this to
+        // skip the claim transaction — and its gas — when there's nothing to collect.
+        async claimableFees() {
+            const res = await readWithRetry("claimableFees", () => bankrApi(config.bankrApiKey, `/token-launches/${config.tokenAddress}/fees`));
+            const token = res.tokens?.find((t) => t.tokenAddress?.toLowerCase() === config.tokenAddress.toLowerCase())
+                ?? res.tokens?.[0];
+            const token0 = token?.claimable?.token0 ?? "0";
+            const token1 = token?.claimable?.token1 ?? "0";
+            // Mirrors the Bankr CLI's own "has claimable fees" test: strip any "<"/">"
+            // rounding prefix and treat a positive amount on either side as claimable.
+            const amount = (s) => parseFloat(s.replace(/^[<>]/, "")) || 0;
+            return { token0, token1, hasClaimable: amount(token0) > 0 || amount(token1) > 0 };
+        },
+        async claimFees() {
+            if (config.treasuryDryRun) {
+                log.info("treasury [dry run] claimFees");
+                return { token: 0n, weth: 0n };
+            }
+            // Measure the claim by diffing wallet balances before/after the on-chain
+            // settlement — the claim endpoint returns only a tx hash, not amounts.
+            const address = walletAddress();
+            log.info("treasury claimFees: reading pre-claim balances");
+            const [tokenBefore, wethBefore] = await readWithRetry("claimFees pre-claim balances", () => Promise.all([
+                erc20Balance(config.tokenAddress, address),
+                erc20Balance(WETH, address),
+            ]));
+            log.info("treasury claimFees submitting");
+            const { transactionHash } = await bankrApi(config.bankrApiKey, `/token-launches/${config.tokenAddress}/fees/claim`, { method: "POST", auth: "bearer", body: JSON.stringify({}) });
+            log.info({ txHash: transactionHash }, "treasury claimFees: waiting for confirmation");
+            await readWithRetry("claimFees receipt", () => publicClient.waitForTransactionReceipt({ hash: transactionHash }));
+            // Past this point the claim has settled on-chain. A failure to MEASURE it must
+            // not abort the cycle — degrade to zero amounts (this batch just won't be
+            // burned/swapped this cycle) and let the rest of the cycle run.
+            log.info("treasury claimFees: reading post-claim balances");
+            try {
+                const [tokenAfter, wethAfter] = await readWithRetry("claimFees post-claim balances", () => Promise.all([
+                    erc20Balance(config.tokenAddress, address),
+                    erc20Balance(WETH, address),
+                ]));
+                const token = tokenAfter > tokenBefore ? tokenAfter - tokenBefore : 0n;
+                const weth = wethAfter > wethBefore ? wethAfter - wethBefore : 0n;
+                log.info({ txHash: transactionHash, token: token.toString(), weth: weth.toString() }, "treasury claimFees ok");
+                return { token, weth };
+            }
+            catch (err) {
+                log.error({ txHash: transactionHash, err: err instanceof Error ? err.message : String(err) }, "treasury claimFees: claim settled but post-claim balance read failed — treating claimed amounts as 0 (no burn/swap this cycle)");
+                return { token: 0n, weth: 0n };
+            }
+        },
+        async burnToken(amount) {
+            if (config.treasuryDryRun) {
+                log.info({ amount: amount.toString() }, "treasury [dry run] burnToken");
+                return "0xdry";
+            }
+            log.info({ amount: amount.toString() }, "treasury burnToken submitting");
+            const data = encodeFunctionData({ abi: ERC20_ABI, functionName: "transfer", args: [BURN_ADDRESS, amount] });
+            const txHash = await submitTx(config.tokenAddress, data);
+            log.info({ txHash, amount: amount.toString() }, "treasury burnToken ok");
+            return txHash;
+        },
+        async transferToken(token, to, amount) {
+            if (config.treasuryDryRun) {
+                log.info({ token, to, amount: amount.toString() }, "treasury [dry run] transferToken");
+                return "0xdry";
+            }
+            log.info({ token, to, amount: amount.toString() }, "treasury transferToken submitting");
+            const data = encodeFunctionData({ abi: ERC20_ABI, functionName: "transfer", args: [to, amount] });
+            const txHash = await submitTx(token, data);
+            log.info({ txHash, token, to, amount: amount.toString() }, "treasury transferToken ok");
+            return txHash;
+        },
+        async unwrapWethToEth(amount) {
+            if (config.treasuryDryRun) {
+                log.info({ amount: amount.toString() }, "treasury [dry run] unwrapWethToEth");
+                return "0xdry";
+            }
+            log.info({ amount: amount.toString() }, "treasury unwrapWethToEth submitting");
+            const data = encodeFunctionData({ abi: WETH_ABI, functionName: "withdraw", args: [amount] });
+            const txHash = await submitTx(WETH, data);
+            log.info({ txHash, amount: amount.toString() }, "treasury unwrapWethToEth ok");
+            return txHash;
+        },
+        async swapWethToUsdc(amount) {
+            if (config.treasuryDryRun) {
+                log.info({ amount: amount.toString() }, "treasury [dry run] swapWethToUsdc");
+                return "0xdry";
+            }
+            // The router pulls WETH via transferFrom, so it needs an allowance. Approve
+            // per-amount each swap (never an unlimited approval): check the current
+            // allowance first and only top it up when it's short.
+            const allowance = await readWithRetry("swap allowance", () => publicClient.readContract({
+                address: WETH, abi: ERC20_ABI, functionName: "allowance",
+                args: [walletAddress(), UNISWAP_ROUTER],
+            }));
+            if (allowance < amount) {
+                log.info({ allowance: allowance.toString(), amount: amount.toString() }, "treasury swapWethToUsdc approving router");
+                const approveData = encodeFunctionData({
+                    abi: ERC20_ABI, functionName: "approve", args: [UNISWAP_ROUTER, amount],
+                });
+                const approveTx = await submitTx(WETH, approveData);
+                log.info({ txHash: approveTx }, "treasury swapWethToUsdc approval ok");
+            }
+            log.info({ amount: amount.toString() }, "treasury swapWethToUsdc submitting");
+            const data = encodeFunctionData({
+                abi: UNISWAP_ROUTER_ABI,
+                functionName: "exactInputSingle",
+                args: [{
+                        tokenIn: WETH, tokenOut: USDC, fee: 500,
+                        recipient: walletAddress(),
+                        amountIn: amount, amountOutMinimum: 0n, sqrtPriceLimitX96: 0n,
+                    }],
+            });
+            const txHash = await submitTx(UNISWAP_ROUTER, data);
+            log.info({ txHash, amount: amount.toString() }, "treasury swapWethToUsdc ok");
+            return txHash;
+        },
+        async extendCompute() {
+            if (!config.computeInstanceId)
+                return;
+            if (config.treasuryDryRun) {
+                log.info({ instanceId: config.computeInstanceId }, "treasury [dry run] extendCompute 24h");
+                return;
+            }
+            log.info({ instanceId: config.computeInstanceId }, "treasury extendCompute submitting 24h");
+            const res = await payFetch(`https://compute.x402layer.cc/compute/instances/${config.computeInstanceId}/extend`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ extend_hours: 24, network: "base" }),
+            });
+            if (!res.ok) {
+                throw new Error(`Compute extend failed: ${res.status} ${await res.text()}`);
+            }
+            log.info({ usd: paidUsd(res) }, "treasury extendCompute ok (+24h)");
+        },
+        async computeExpiry() {
+            if (!config.computeInstanceId)
+                return null;
+            // Instance lookup needs wallet-signature auth — the same authenticated path
+            // the deploy script uses. A plain fetch here would 401 and return null, which
+            // the cycle would misread as "expiring soon" and buy compute every run.
+            try {
+                const instance = await fetchComputeInstance(config.bankrApiKey, walletAddress(), config.computeInstanceId);
+                return computeInstanceExpiry(instance);
+            }
+            catch (err) {
+                log.warn({ err }, "compute expiry lookup failed");
+                return null;
+            }
+        },
+        // All-time gross creator fees earned (WETH), from Bankr's fees endpoint:
+        // `lifetimeEarnedWeth` (fees that have left the claimable bucket — claimed +
+        // swapped) plus `totals.claimableWeth` (fees pending right now, not yet in
+        // `lifetimeEarnedWeth`). Summing the two covers the full lifetime as fees flow
+        // pending → claimed. Read-only (no payment); polled on a timer to feed the
+        // stats ledger. (WETH side only — the token-side fee isn't valued in WETH here.)
+        async lifetimeEarned() {
+            const res = await bankrApi(config.bankrApiKey, `/token-launches/${config.tokenAddress}/fees`);
+            const num = (s) => parseFloat(s ?? "0") || 0;
+            return num(res.lifetimeEarnedWeth) + num(res.totals?.claimableWeth);
+        },
+        async balances() {
+            const address = walletAddress();
+            const [token, weth, usdc, eth] = await readWithRetry("balances", () => Promise.all([
+                erc20Balance(config.tokenAddress, address),
+                erc20Balance(WETH, address),
+                erc20Balance(USDC, address),
+                publicClient.getBalance({ address }),
+            ]));
+            return { token, weth, usdc, eth };
+        },
+    };
+}

package/dist/src/util.d.ts

@@ -0,0 +1,3 @@
+export declare const sleep: (ms: number) => Promise<void>;
+export declare function requireEnv(name: string): string;
+export declare function envNumber(name: string, fallback: number): number;

package/dist/src/util.js

@@ -0,0 +1,18 @@
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export function requireEnv(name) {
+    const v = process.env[name];
+    if (!v)
+        throw new Error(`Missing required env var: ${name}`);
+    return v;
+}
+// Lenient numeric env var: a missing/empty/malformed value falls back instead of
+// becoming NaN (which setInterval would treat as ~1ms, and charts as garbage).
+// For agent-critical knobs that should *fail* the boot on a malformed value, use
+// `numeric()` in config.ts instead.
+export function envNumber(name, fallback) {
+    const raw = process.env[name];
+    if (raw == null || raw === "")
+        return fallback;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : fallback;
+}

package/dist/src/wallet.d.ts

@@ -0,0 +1,5 @@
+export declare function initBankr(): Promise<`0x${string}`>;
+export declare function walletAddress(): `0x${string}`;
+export declare function payFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+export declare function paidUsd(res: Response): number | undefined;
+export declare function submitTx(to: string, data: string): Promise<string>;