clockwork-press 0.0.1 → 0.2.0

package/dist/quote.js

@@ -0,0 +1,40 @@
+// The curve exposes no quote function — this is the curve's own integer
+// arithmetic, in the same order, copied from the PONS.md appendix. Buys charge every
+// fee off the input before the constant-product step.
+import { cfg } from './env.js';
+import { pub } from './chain.js';
+import { curveAbi } from './abis.js';
+const ceilDiv = (a, b) => (a + b - 1n) / b;
+const amountOut = (inAmt, rIn, rOut) => (inAmt * rOut) / (rIn + inAmt);
+const amountIn = (outAmt, rIn, rOut) => (outAmt * rIn) / (rOut - outAmt) + 1n;
+export async function quoteBuy(curve, quoteIn, recipient) {
+    const read = (functionName, args = []) => pub.readContract({ address: curve, abi: curveAbi, functionName, args });
+    const [reserves, sellable, feeBps, creatorTaxBps, rawSnipeBps] = await Promise.all([
+        read('getReserves'),
+        read('sellableTokens'),
+        read('feeBps'),
+        read('creatorTaxBps'),
+        read('currentSnipeTaxBps', [recipient]),
+    ]);
+    const [quoteReserve, tokenReserve] = reserves;
+    // The snipe tax is capped so the buyer always nets at least 1% of spend.
+    let snipeBps = rawSnipeBps;
+    if (snipeBps > 0n) {
+        const maxSnipeBps = cfg.BPS - feeBps - creatorTaxBps - 100n;
+        if (snipeBps > maxSnipeBps)
+            snipeBps = maxSnipeBps;
+    }
+    let spent = quoteIn;
+    const fee = (spent * feeBps) / cfg.BPS;
+    const tax = (spent * creatorTaxBps) / cfg.BPS;
+    const snipe = (spent * snipeBps) / cfg.BPS;
+    let tokensOut = amountOut(spent - fee - tax - snipe, quoteReserve, tokenReserve);
+    // A buy that would cross the reserved allocation fills to the edge.
+    if (tokensOut > sellable) {
+        tokensOut = sellable;
+        const net = amountIn(sellable, quoteReserve, tokenReserve);
+        const grossed = ceilDiv(net * cfg.BPS, cfg.BPS - feeBps - creatorTaxBps - snipeBps);
+        spent = grossed < quoteIn ? grossed : quoteIn;
+    }
+    return { tokensOut, spent, refund: quoteIn - spent, snipeBps };
+}

package/dist/telegram.js

@@ -0,0 +1,45 @@
+import { cfg } from './env.js';
+// The art the cards ride on comes from clockwork.json (brand.art); an empty slot means a text-only card.
+export const ART = { press: cfg.art.claim || '', snack: cfg.art.slice || '', burn: cfg.art.percent || '', buy: cfg.art.buy || '', newHolder: cfg.art.newHolder || '' };
+async function call(method, body) {
+    const res = await fetch(`https://api.telegram.org/bot${cfg.tgToken}/${method}`, {
+        method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ chat_id: cfg.tgChat, ...body }),
+    });
+    if (!res.ok)
+        console.error(`[telegram] ${method} failed: ${res.status} ${await res.text()}`);
+    return res.ok;
+}
+export async function post(text) {
+    if (!cfg.tgToken || !cfg.tgChat) {
+        console.log('[telegram] not configured, would have posted:\n' + text);
+        return;
+    }
+    await call('sendMessage', { text, disable_web_page_preview: true });
+}
+// A photo (jpg/png url) or an animation (mp4 url) with the text as its caption; plain text if telegram refuses the media.
+export async function postMedia(url, caption) {
+    if (!cfg.tgToken || !cfg.tgChat) {
+        console.log(`[telegram] not configured, would have posted ${url}:\n` + caption);
+        return;
+    }
+    const isVideo = /\.mp4($|\?)/i.test(url);
+    const ok = await call(isVideo ? 'sendAnimation' : 'sendPhoto', { [isVideo ? 'animation' : 'photo']: url, caption: caption.slice(0, 1000) });
+    if (!ok)
+        await call('sendMessage', { text: caption, disable_web_page_preview: true });
+}
+// A card: the art on top, clean lines under it, the first line bold. Values are escaped, so any text is safe.
+const esc = (t) => t.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+export async function postCard(url, lines) {
+    const ls = lines.filter((l) => !!l).map(esc);
+    if (!ls.length)
+        return;
+    const html = [`<b>${ls[0]}</b>`, ...ls.slice(1)].join('\n');
+    if (!cfg.tgToken || !cfg.tgChat) {
+        console.log(`[telegram] not configured, would have posted ${url}:\n` + ls.join('\n'));
+        return;
+    }
+    const isVideo = /\.mp4($|\?)/i.test(url);
+    const ok = url ? await call(isVideo ? 'sendAnimation' : 'sendPhoto', { [isVideo ? 'animation' : 'photo']: url, caption: html.slice(0, 1000), parse_mode: 'HTML' }) : false;
+    if (!ok)
+        await call('sendMessage', { text: html, parse_mode: 'HTML', disable_web_page_preview: true });
+}

package/dist/v4.js

@@ -0,0 +1,87 @@
+// The burn leg in pool phase: GME -> $GMERALD through Uniswap v4 on Robinhood
+// Chain via the Universal Router (V4_SWAP), quoted first with the v4 Quoter.
+// Addresses from developers.uniswap.org/contracts/v4/deployments (chain 4663).
+import { encodeAbiParameters, parseAbi, maxUint160 } from 'viem';
+const MAX_UINT48 = 281474976710655; // 2^48 - 1, a JS number because viem maps uint48 to number
+import { cfg } from './env.js';
+import { pub, wallet, account } from './chain.js';
+export const V4 = {
+    poolManager: '0x8366a39cc670b4001a1121b8f6a443a643e40951',
+    universalRouter: '0x8876789976decbfcbbbe364623c63652db8c0904',
+    quoter: '0x8dc178efb8111bb0973dd9d722ebeff267c98f94',
+    permit2: '0x000000000022D473030F116dDEE9F6B43aC78BA3',
+    tickSpacing: 200,
+};
+const quoterAbi = parseAbi([
+    'struct PoolKey { address currency0; address currency1; uint24 fee; int24 tickSpacing; address hooks; }',
+    'struct QuoteExactSingleParams { PoolKey poolKey; bool zeroForOne; uint128 exactAmount; bytes hookData; }',
+    'function quoteExactInputSingle(QuoteExactSingleParams params) returns (uint256 amountOut, uint256 gasEstimate)',
+]);
+const routerAbi = parseAbi(['function execute(bytes commands, bytes[] inputs, uint256 deadline) payable']);
+const permit2Abi = parseAbi([
+    'function allowance(address user, address token, address spender) view returns (uint160 amount, uint48 expiration, uint48 nonce)',
+    'function approve(address token, address spender, uint160 amount, uint48 expiration)',
+]);
+const erc20 = parseAbi(['function allowance(address,address) view returns (uint256)', 'function approve(address,uint256) returns (bool)']);
+export function poolKey(token) {
+    const a = cfg.gme.toLowerCase(), b = token.toLowerCase();
+    const [currency0, currency1] = a < b ? [cfg.gme, token] : [token, cfg.gme];
+    return { currency0, currency1, fee: 0, tickSpacing: V4.tickSpacing, hooks: cfg.hook, zeroForOne: a < b };
+}
+export async function quoteGmeToToken(token, amountIn) {
+    const k = poolKey(token);
+    const { result } = await pub.simulateContract({
+        address: V4.quoter, abi: quoterAbi, functionName: 'quoteExactInputSingle',
+        args: [{ poolKey: { currency0: k.currency0, currency1: k.currency1, fee: k.fee, tickSpacing: k.tickSpacing, hooks: k.hooks }, zeroForOne: k.zeroForOne, exactAmount: amountIn, hookData: '0x' }],
+    });
+    return result[0];
+}
+// Gas: the chain's base fee moves fast and viem's default cap can land under the next block's base fee
+// ("fee cap cannot be lower than the block base fee"). Cap at three times the current base fee; the chain
+// only charges what the block actually costs.
+async function fees() {
+    const b = await pub.getBlock();
+    const base = b.baseFeePerGas ?? 1000000000n;
+    let prio = 0n;
+    try {
+        prio = await pub.estimateMaxPriorityFeePerGas();
+    }
+    catch { }
+    return { maxFeePerGas: base * 3n + prio, maxPriorityFeePerGas: prio };
+}
+// Universal Router: command 0x10 = V4_SWAP; v4 actions 0x07 SWAP_EXACT_IN, 0x0c SETTLE_ALL, 0x0f TAKE_ALL.
+export async function swapGmeToToken(token, amountIn, minOut) {
+    const w = wallet();
+    const me = account().address;
+    const k = poolKey(token);
+    // Permit2 is how the router pulls ERC-20 input: approve Permit2 once, then Permit2 -> router.
+    const erc20Allow = await pub.readContract({ address: cfg.gme, abi: erc20, functionName: 'allowance', args: [me, V4.permit2] });
+    if (erc20Allow < amountIn) {
+        const h = await w.writeContract({ address: cfg.gme, abi: erc20, functionName: 'approve', args: [V4.permit2, 2n ** 256n - 1n], ...(await fees()) });
+        await pub.waitForTransactionReceipt({ hash: h });
+    }
+    const [p2Amt, p2Exp] = await pub.readContract({ address: V4.permit2, abi: permit2Abi, functionName: 'allowance', args: [me, cfg.gme, V4.universalRouter] });
+    if (p2Amt < amountIn || Number(p2Exp) < Math.floor(Date.now() / 1000) + 600) {
+        const h = await w.writeContract({ address: V4.permit2, abi: permit2Abi, functionName: 'approve', args: [cfg.gme, V4.universalRouter, maxUint160, MAX_UINT48], ...(await fees()) });
+        await pub.waitForTransactionReceipt({ hash: h });
+    }
+    // This chain's Universal Router carries a non-standard swap struct: an extra `bytes`
+    // field sits between the path and the amounts (read off a live trade, tx 0x2ee2...c3a0).
+    // The standard single-hop layout reverts inside the router's decoder, so we use the
+    // path form with that field empty: SWAP_EXACT_IN (0x07), then SETTLE_ALL, TAKE_ALL.
+    const swapParams = encodeAbiParameters([{ type: 'tuple', components: [
+                { type: 'address', name: 'currencyIn' },
+                { type: 'tuple[]', name: 'path', components: [{ type: 'address', name: 'intermediateCurrency' }, { type: 'uint24', name: 'fee' }, { type: 'int24', name: 'tickSpacing' }, { type: 'address', name: 'hooks' }, { type: 'bytes', name: 'hookData' }] },
+                { type: 'bytes', name: 'extra' }, { type: 'uint128', name: 'amountIn' }, { type: 'uint128', name: 'amountOutMinimum' }
+            ] }], [{ currencyIn: cfg.gme, path: [{ intermediateCurrency: token, fee: k.fee, tickSpacing: k.tickSpacing, hooks: k.hooks, hookData: '0x' }], extra: '0x', amountIn, amountOutMinimum: minOut }]);
+    const settle = encodeAbiParameters([{ type: 'address' }, { type: 'uint256' }], [cfg.gme, amountIn]);
+    const take = encodeAbiParameters([{ type: 'address' }, { type: 'uint256' }], [token, minOut]);
+    const actions = '0x070c0f';
+    const input = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes[]' }], [actions, [swapParams, settle, take]]);
+    const deadline = BigInt(Math.floor(Date.now() / 1000) + 600);
+    const hash = await w.writeContract({ address: V4.universalRouter, abi: routerAbi, functionName: 'execute', args: ['0x10', [input], deadline], ...(await fees()) });
+    const rcpt = await pub.waitForTransactionReceipt({ hash });
+    if (rcpt.status !== 'success')
+        throw new Error(`v4 swap reverted: ${hash}`);
+    return hash;
+}