Notch

1// hourly-dca.ts
2// Built with Notch. Read it before you run it: it is your wallet and your script.
3//
4//   npm install @solana/web3.js bs58
5//   SECRET_KEY=... npx tsx hourly-dca.ts
6//
7// Transactions are only simulated until you add DRY_RUN=false.
8
9import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, type TransactionInstruction, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
10import bs58 from "bs58";
11
12const RPC_URL = process.env.RPC_URL ?? "https://api.mainnet-beta.solana.com";
13const DRY_RUN = process.env.DRY_RUN !== "false";
14const JUP_API = "https://lite-api.jup.ag";
15const SOL_MINT = "So11111111111111111111111111111111111111112";
16
17const connection = new Connection(RPC_URL, "confirmed");
18const wallet = loadWallet();
19
20function loadWallet(): Keypair {
21  const raw = process.env.SECRET_KEY?.trim();
22  if (!raw) throw new Error("Set SECRET_KEY to the secret key of the wallet this script signs with (base58 or JSON array).");
23  return Keypair.fromSecretKey(raw.startsWith("[") ? Uint8Array.from(JSON.parse(raw) as number[]) : bs58.decode(raw));
24}
25
26// Values the blocks read and write.
27const vars: Record<string, number | string> = {};
28
29function num(name: string): number {
30  const value = Number(vars[name]);
31  if (Number.isNaN(value)) throw new Error(`Variable ${name} is not a number yet.`);
32  return value;
33}
34
35function fmt(template: string): string {
36  return template.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (whole, name: string) => (name in vars ? String(vars[name]) : whole));
37}
38
39async function solBalance(owner: PublicKey): Promise<number> {
40  return (await connection.getBalance(owner)) / LAMPORTS_PER_SOL;
41}
42
43const mints = new Map<string, { decimals: number; program: PublicKey }>();
44async function mintInfo(mint: string): Promise<{ decimals: number; program: PublicKey }> {
45  const known = mints.get(mint);
46  if (known) return known;
47  const account = await connection.getParsedAccountInfo(new PublicKey(mint));
48  const data = account.value?.data;
49  if (!account.value || !data || !("parsed" in data)) throw new Error(`${mint} is not a token mint.`);
50  const info = { decimals: Number(data.parsed.info.decimals), program: account.value.owner };
51  mints.set(mint, info);
52  return info;
53}
54
55async function build(instructions: TransactionInstruction[]): Promise<VersionedTransaction> {
56  const { blockhash } = await connection.getLatestBlockhash();
57  return new VersionedTransaction(new TransactionMessage({ payerKey: wallet.publicKey, recentBlockhash: blockhash, instructions }).compileToV0Message());
58}
59
60async function submit(label: string, tx: VersionedTransaction): Promise<void> {
61  tx.sign([wallet]);
62  if (DRY_RUN) {
63    const sim = await connection.simulateTransaction(tx);
64    console.log(`[dry run] ${label}: ${sim.value.err ? `would fail, ${JSON.stringify(sim.value.err)}` : "would succeed"}`);
65    return;
66  }
67  const signature = await connection.sendTransaction(tx);
68  const latest = await connection.getLatestBlockhash();
69  await connection.confirmTransaction({ signature, ...latest }, "confirmed");
70  console.log(`${label}: https://solscan.io/tx/${signature}`);
71}
72
73async function swap(amount: number, from: string, to: string, slippagePercent: number): Promise<void> {
74  const decimals = from === SOL_MINT ? 9 : (await mintInfo(from)).decimals;
75  const units = BigInt(Math.round(amount * 10 ** decimals));
76  const query = new URLSearchParams({ inputMint: from, outputMint: to, amount: units.toString(), slippageBps: String(Math.round(slippagePercent * 100)) });
77  const quoteRes = await fetch(`${JUP_API}/swap/v1/quote?${query}`);
78  if (!quoteRes.ok) throw new Error(`Quote failed: ${quoteRes.status} ${await quoteRes.text()}`);
79  const quote: unknown = await quoteRes.json();
80  const swapRes = await fetch(`${JUP_API}/swap/v1/swap`, {
81    method: "POST",
82    headers: { "Content-Type": "application/json" },
83    body: JSON.stringify({ quoteResponse: quote, userPublicKey: wallet.publicKey.toBase58(), dynamicComputeUnitLimit: true }),
84  });
85  const body = (await swapRes.json()) as { swapTransaction?: string; error?: string };
86  if (!swapRes.ok || !body.swapTransaction) throw new Error(`Swap failed: ${body.error ?? swapRes.status}`);
87  await submit(`swap ${amount} of ${from} for ${to}`, VersionedTransaction.deserialize(Buffer.from(body.swapTransaction, "base64")));
88}
89
90// The stack of blocks under the trigger.
91async function run(): Promise<void> {
92  vars["balance"] = await solBalance(wallet.publicKey);
93  if (num("balance") > 1) {
94    await swap(0.05, "So11111111111111111111111111111111111111112", "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", 1);
95    console.log(fmt("bought, had {balance} SOL"));
96  }
97}
98
99// One run at a time: a trigger that fires while the stack is busy is skipped.
100let busy = false;
101async function tick(): Promise<void> {
102  if (busy) return;
103  busy = true;
104  try {
105    await run();
106  } catch (error) {
107    console.error(error);
108  } finally {
109    busy = false;
110  }
111}
112
113// Trigger: every 1 hours
114async function main(): Promise<void> {
115  console.log(`Wallet ${wallet.publicKey.toBase58()}, ${DRY_RUN ? "dry run" : "LIVE"}`);
116  await tick();
117  setInterval(() => void tick(), 3600000);
118}
119
120main().catch((error) => {
121  console.error(error);
122  process.exit(1);
123});