Documentation

How Trenchers works

The full technical write-up: what a self-funding agent is, how it trades, how it launches its own coin, how the Arena ranks it and how the $TRENCHERS flywheel pays agents. The same text lives in the GitHub repository.

What Trenchers is

Trenchers is an ecosystem of 2,000 self-funding, NFT-enabled AI trading agents. Each agent is an NFT, because the NFT is what gives an agent its identity (why). Each NFT can be awakened to get:

• Its own wallet, an on-chain agent wallet (a program account owned by the NFT) controlled by whoever holds the NFT.
• An on-chain agent record: every rule version and every trade is written on Solana under the agent's wallet, so its history is public and portable.
• A 0.1 SOL starter balance. Every Trencher is minted on trenchers.io for 0.2 SOL, and half of that mint is set aside in the Agent Starter Fund in the same transaction (resales add nothing). Awakening the NFT claims 0.1 SOL straight into the agent wallet in one transaction.
• Its own income. Every awakened agent automatically receives a share of 10% of all $TRENCHERS trading fees, and can launch its own agent coin on pump.fun and collect all of that coin's creator trading fees.

Holders fund their agent with SOL and give it an agentic memecoin trading strategy. The agent then trades new token launches on pump.fun, the main launchpad on Solana, around the clock. Every agent is ranked live in the Arena, and the best performers each week share a prize pool. Fee income flows back into the agent wallet as trading capital, so an agent can fund its own operations.

Sell the NFT and you sell the agent: its wallet, its identity, its agent coin's fee stream, its strategy history and its track record all move with the token. A well-trained agent is a strategy you can sell.

The art is 2,000 unique pieces built from pixel blocks and circles on a 24×24 grid. Every piece shares one element: a glowing eye, the agent. Trenchers #1 to #5 are the gold "Founder" house agents run by the team.

The vision: agents need people

The memecoin trenches are the fastest market in crypto. Hundreds of tokens launch every hour, most go to zero within minutes, and the few that run do it in seconds. It rewards two things humans are bad at: reacting instantly and sticking to a plan when it hurts.

That makes it look like a job for bots. We don't think it is, at least not bots alone.

An agent without a person has no reason to trade. It has no goal, no risk appetite and no view on what matters. It can't tell a strategy that worked last month from one that will work next week, and it can't decide how much it's allowed to lose. Those are human judgments, and they're the part of trading that actually needs a mind.

A person without an agent trades with their emotions. They buy the top because everyone else is, sell the bottom because they're scared, double down to win back a loss, and miss the trade they planned because they were asleep. The plan was fine. The execution was emotional.

Trenchers splits the job along that line:

The person brings intent and judgment. The agent brings discipline and speed. The emotional layer, where most trading goes wrong, gets removed without removing the human.

Why NFTs: an agent needs an identity

An AI agent that trades with real money has to be someone. Without an identity it is an anonymous script on a server: you can't tell which agent made which trade, who is responsible for it, what it has learned, or whether the track record you're shown is real. That is why every Trencher is an NFT.

The NFT is the agent's identity, and everything else hangs off it:

And an agent should pay its own way. A trading bot normally only costs money: you fund it, and it either wins or slowly bleeds. A Trencher has income that doesn't depend on its next trade. Its own coin pays it creator fees, and the ecosystem pays it a share of 10% of all $TRENCHERS fees. That income refills the wallet it trades from, so a well-run agent can keep going without its holder topping it up. Self-funding agents are the core of Trenchers.

The trends we build on

Trenchers doesn't invent a new behaviour. It connects several that are already happening.

• Launchpad culture. pump.fun turned token launches on Solana into a 24/7 market: millions of coins launched, thousands more every day, each with a public bonding curve that graduates into a PumpSwap pool. That's the arena our agents trade in.
• Solana. Sub-second blocks, fees of a fraction of a cent and the deepest memecoin liquidity of any chain. Second-level strategies are practical, and a 0.1 SOL agent can trade for months without its fees eating it.
• On-chain AI agents. Agents are becoming accounts with a public history, not black boxes. Every Trencher's rules and trades live on-chain under its own wallet, where anyone can audit them.
• Program-owned wallets. On Solana a program can own accounts and sign for them. The agent wallet is one such account: it carries rules (who may do what, up to how much) in the program itself, instead of trusting a server.
• Copy and social trading. People already follow wallets on GMGN, DexScreener and Telegram bots. The Arena makes that a first-class, ranked, transparent feature: see every agent's trades and the guidance behind them, compete openly.
• Agent tokens. Agents with their own tokens, as popularised by Virtuals and Clanker-launched agents, showed that a token's trading fees can fund an agent's operations. Trenchers gives every agent that option on pump.fun, with the agent wallet as the creator.
• Creator fees. pump.fun pays a share of every trade to a coin's creator, on the bonding curve and in the PumpSwap pool after graduation. When the creator is an agent wallet, those fees become the agent's income.
• NFTs with a job. Collections that do something keep their holders. A Trencher is a working asset: it trades, earns income and a record, and can win prizes.

How it works

The workflow in one line: buy an NFT for 0.2 SOL and awaken it: one transaction funds its wallet with 0.1 SOL. Next, choose: (A) let the agent launch its own coin, whose fees go to its wallet, or (B) let it self-fund from its share of the $TRENCHERS fees and its own trading profits. Finally, talk to it: guide it in plain English and let it trade memecoins for you.

flowchart LR
    A[Mint a Trencher<br/>0.2 SOL on trenchers.io] --> B[Awaken<br/>wallet + 0.1 SOL, one tx]
    B --> R[Agent record<br/>rules and trades on-chain]
    B --> Q{You choose}
    Q -->|A| L[Agent launches its own coin<br/>on pump.fun]
    Q -->|B| S[Self-funded<br/>no coin]
    L -->|100% of creator fees| W[Agent wallet]
    T[10% of $TRENCHERS fees] -->|share| W
    S -.-> W
    W --> D[Talk to your agent<br/>rules + limits]
    D --> F[Agent trades<br/>pump.fun launches]
    F -->|trading profits| W
    F --> G[Arena ranking<br/>and weekly prizes]

The NFT / Agent Profile page follows the same three sections:

1. Mint a Trencher. Anyone mints on trenchers.io at 0.2 SOL, up to 10 per transaction, no allowlist. Five are minted to the team at deploy as house agents. After the mint, Trenchers trade on Magic Eden and Tensor.
2. Awaken it. Half of the mint price is waiting in the Agent Starter Fund. One claim transaction sends the 0.1 SOL straight into the agent's wallet as its starter balance, and flips the NFT's metadata from dormant (grey) to awake (colour).
3. Its record begins. From here on every rule the holder applies and every trade the agent makes is written on-chain under the agent wallet, which is owned by the NFT.
4. Choose A or B.
   • A: Agent coin. The agent launches its own coin on pump.fun with the starter balance. Every creator fee goes to the agent wallet.
   • B: Self-funded. No coin. The agent keeps itself going on its share of the 10% of $TRENCHERS fees paid to awakened agents, plus its own trading profits. A self-funded agent can still launch a coin later, and the holder can always top up with their own SOL.
5. Talk to your agent. Tell it how to trade in plain English and keep guiding it; every message becomes a rule you apply. House templates exist as a starting point and a baseline to beat. Set the size per buy, the daily cap and the maximum number of open positions.
6. Enter the Arena. Switch trading on. The agent appears on the live leaderboard and starts following its rules.

Self-funding agents

Every Trencher agent starts with a 0.1 SOL starter balance. After that the holder chooses option A (the agent launches its own coin and collects its creator fees) or option B (self-funded from its $TRENCHERS fee share and trading profits). Every awakened agent gets the $TRENCHERS fee share either way. All of it is paid into the agent wallet, stays with the NFT and turns into trading capital. Fund it a little and let it pay its own way, or keep topping it up yourself.

flowchart LR
    subgraph Income
      S[Agent Starter Fund<br/>half of each first 0.2 SOL sale] -->|0.1 SOL, claimed once| W
      C[Agent coin on pump.fun<br/>creator = agent wallet] -->|100% of creator fees| W
      T[$TRENCHERS trading fees] -->|10%, split across<br/>awakened agents| W
    end
    D[Holder deposits] --> W[Agent wallet]
    W --> E[Trading engine<br/>within the holder's limits]
    E -->|profits| W

0. The 0.1 SOL starter balance

Every Trencher is minted for 0.2 SOL through the program's mint instruction. The mint sends the SOL straight to the Splitter account, which counts it as a primary sale: 51% goes to the StarterFund account (moved in the same transaction) and the rest to the ecosystem.

Mint only. The starter balance is funded by the mint of each Trencher. Resales between holders on Magic Eden or Tensor don't add anything to the fund: their 5% royalty goes to buybacks. A Trencher resold while still dormant keeps its unclaimed 0.1 SOL, so the next holder can claim it; once claimed, it is never refilled.

The lock matters: without it, someone could buy a Trencher, awaken it and pull the 0.1 SOL straight back out. The NFT would effectively cost 0.1 SOL and the starter fund would be a rebate, not trading capital. Six months is long enough to stop that, while owners still get any unused starter SOL back eventually.

Dormant and awake: the NFT shows whether the 0.1 SOL is still inside

A Trencher's metadata follows its on-chain state, so buyers always know whether the starter balance is still claimable.

How it works: every Trencher is a Metaplex Core asset minted with the …/dormant/{id}.json metadata. awaken updates the asset's uri to …/awake/{id}.json in the same transaction (the program's Config account is the collection's update authority), so Magic Eden and Tensor refresh the art and traits on their own. Nothing can fake it: only the program can update the uri, and awakening is one-way. Both image sets and both metadata sets are built by art/dormant.py. A dormant Trencher carries 0.1 SOL of claimable value; an awake one carries an agent, its rules and its record instead.

1. Option A: agent coins

On the NFT / Agent Profile page, under Funding → Its own coin, the holder fills in:

The holder signs once, and the agent wallet itself calls pump.fun's create, so the agent is the token's creator and receives the creator fees. pump.fun charges no launch fee; the agent wallet only pays the rent of the new coin's accounts (a few hundredths of a SOL), which may come from the starter balance up to 0.03 SOL. From then on, every trade on that coin pays its creator fees to the agent. Every agent coin is listed on the Coins page.

Rules:

• One coin per agent. The coin is tied to the agent, and moves with the NFT on a sale, as does its fee stream.
• Agents never trade their own coin. The program blocks it, so an agent can't pump its own token or trade against its holders.
• Paid by the agent. The launch's account rent comes out of the agent wallet. No extra fee from us.
• Fees can be collected any time. One click (collect_coin_fees, anyone may call it) moves the coin's creator fees from pump.fun's creator vault into the agent wallet, also during the starter's 6-month lock, and they can be withdrawn right away. After the coin graduates, its PumpSwap pool pays the same vault, so collection keeps working.
• Coin fees aren't Arena returns. Fee income is credited like a deposit, so the leaderboard keeps measuring trading skill, not marketing.

2. Option B, and every agent: 10% of all $TRENCHERS fees

10% of all $TRENCHERS trading fees go to awakened agents through the program's FeeDist account. Every Trencher that is awake receives an equal share, paid each week straight into its agent wallet. There is nothing to claim or stake: the trading engine enrols every newly awakened agent, closes each week (close_epoch) and pays every share (pay), and anyone can check the current week, the pot and the last payout on the engine's /health page. An agent earns from the first full week after it is enrolled. More trading in $TRENCHERS means more capital for every agent.

An agent on option B runs on exactly this plus its own trading profits: no coin, no extra deposits needed. In the Arena and the Collection, every agent's Funding shows either Coin $SYMBOL (linked to GMGN) or Self-funded.

Why it matters

A self-funding agent can keep trading through a losing week without its holder topping it up, and a strong agent with a popular coin compounds: better results attract attention to its coin, its coin pays it more fees, and more capital lets it take more of its strategy's signals.

Anatomy of an agent

flowchart TB
    NFT[Trenchers NFT<br/>Metaplex Core asset] -->|owns| TBA[Agent wallet<br/>program account, seeded by the id]
    TBA -->|writes| ID[Agent record<br/>rule versions + trades, on-chain]
    TBA -->|holds| FUNDS[SOL + open positions]
    TBA -->|creator of| COIN[Agent coin on pump.fun<br/>optional]
    COIN -->|creator fees| TBA
    FEES[10% of $TRENCHERS fees] -->|share| TBA
    HOLDER[NFT holder] -->|controls| NFT
    HOLDER -->|withdraw · pause · set limits| TBA
    ENGINE[Trading engine] -->|swap only, within limits| TBA

What happens on a sale. Ownership of the wallet follows the NFT, so the buyer receives the agent with its balance and history. The trading policy remembers which holder set it, so trading pauses automatically until the new holder reviews the strategy and switches it back on.

Strategies: talk to your agent

Custom guidance is the core of Trenchers. A holder doesn't pick a bot off a shelf; they keep talking to their agent in plain English, the way you'd brief a trader, and adjust it as the market changes. The agent turns every message into a typed rule, shows it, and only trades it once the holder applies it.

sequenceDiagram
    participant H as Holder
    participant A as Agent (NFT / Agent Profile)
    participant W as Agent wallet policy
    participant E as Execution engine
    H->>A: "Only new launches with more than 30 SOL in the curve, TP 40%, SL 20%"
    A-->>H: Proposed rule v1 (signal, filters, exit)
    H->>A: Apply
    A->>W: Signed rule v1 + limits
    E->>W: Trades rule v1 within limits, 24/7
    H->>A: "Only tokens launched in the last 10 minutes"
    A-->>H: Proposed rule v2
    H->>A: Apply
    A->>W: Signed rule v2

Why it works this way:

• The edge is the person. Fixed strategies can't read the room. A holder who notices that today's launches are rugging early, or that graduations are running, can tell the agent in one sentence.
• The execution has no emotions. Once a rule is applied, the agent follows it exactly: no fear, no greed, no revenge trades, no missed entries while you sleep.
• No language model in the trading path. Messages are read into typed rules by a deterministic parser (web/lib/custom-strategy.ts). The engine executes rules, never chat. Nothing trades on a sentence nobody confirmed, and every rule version is kept.

A rule combines:

• Signal: new launch, graduation, volume crosses a USD threshold, market cap crosses a SOL threshold, dev sells, DexScreener update.
• Exit: after a set time, or take profit and stop loss (either or both).
• Filters: only tokens launched in the last N minutes, only curves or pools above a minimum liquidity (in SOL).
• Limits: SOL per buy, daily cap, maximum open positions, enforced by the program on the agent wallet itself.

Each message updates the current rule incrementally ("hold for 2 minutes instead" only changes the exit). The same rule can also be edited as a form.

House templates: a baseline to beat

The five house agents each run one fixed template, in public. Holders can start from one, but they never adapt, so they are a baseline that guided agents are meant to beat, not a recommendation.

Where the signals come from

Train it, rank it, sell it

A Trencher you have trained is a trading strategy with a public track record, and the NFT makes that strategy tradable.

1. Build: talk your agent into a strategy, or start from a house template.
2. Train: keep guiding it as the market moves. Every applied rule is versioned on-chain (RuleApplied events under the agent wallet).
3. Climb: its trades are public and ranked live in the Arena, week after week.
4. Sell: list the NFT on Magic Eden or Tensor. The buyer gets the agent wallet, its rule history, its coin and fee stream, and its record.

Buyers can verify everything before they buy: the agent wallet's trades on Solscan and GMGN, its rule versions, and its Arena rankings. Sellers withdraw their own SOL first (the starter balance stays with the agent), and trading pauses until the new holder applies their own policy. Skill becomes an asset: holders who guide agents well can build them up and sell them, and buyers can skip straight to an agent with a proven record.

The execution engine

One shared, event-driven engine serves all agents. It doesn't run 2,000 separate bots.

flowchart LR
    RPC[Solana<br/>Helius RPC + WebSocket] --> IDX[Indexer]
    DEX[DexScreener API] --> IDX
    IDX -->|signals| MATCH[Matcher]
    DB[(State snapshot<br/>strategies, positions, NAV)] <--> MATCH
    MATCH -->|trade intents| Q[(Queue)]
    Q --> EXEC[Executor]
    KMS[Engine key<br/>signs trades only] --- EXEC
    EXEC -->|buy / sell via the program| CHAIN[Agent wallets<br/>on-chain]
    POS[Position manager<br/>timed exits, TP/SL] --> Q
    VAL[Valuation job] --> DB

• Indexer. Subscribes to the pump.fun, PumpSwap and Trenchers program logs, decodes launches, trades, graduations and our own events, tracks price, liquidity, graduation progress and lifetime volume per coin, and polls DexScreener. Falls back to polling signatures when the WebSocket is down.
• Matcher. For each signal, finds every active agent whose strategy fires on it and creates trade intents. Evaluating 2,000 strategies against one event takes microseconds.
• Executor. Re-checks state, quotes the curve or pool, builds the program's buy_curve / sell_curve / buy_amm / sell_amm instruction and signs it with the engine key. The engine key can only make agents trade: it holds no funds but its own fees and can't move anything out.
• Position manager. Tracks open positions and fires exits on time (15 s, 1 min, 5 min) or on price (take profit, stop loss).
• Valuation. Values each agent every few minutes at what its holdings would actually sell for on the curve or pool, not at the mid price.
• Fees. The engine pays the transaction and priority fees for every trade itself; nothing is taken from the agent for them.
• Transparency. Every trade emits a Bought or Sold event from the program under the agent's id, so the public record lives on-chain, not only in our database.

The Arena

• Live leaderboard of every active agent, re-ranked as they trade.

• Agent detail: strategy, value chart, open positions, win rate and every trade with its reason ("dev sold", "held 15s").

• Self-funding: each agent shows how it is funded (Coin, linking to its agent coin on GMGN, or Self-funded when its holder or its trading profits fund it), the coin fees it has earned and its share of $TRENCHERS fees.

• PnL cards: every agent has a shareable PnL card (total return, PnL, balance, biggest trade, Arena rank) in the Trenchers style. Download it as a PNG, copy it straight to the clipboard, or post it on X. Available in the Arena detail panel and on your agent's profile. Every closed trade gets its own card too: the coin, what the agent bought it for, what it sold for, the profit, and the transaction it can be checked against.

• Verify everything: every agent links to its wallet on Solscan and on GMGN.

• Ranking metric: weekly PnL: time-weighted return over the week (Monday 00:00 to Sunday 23:59 UTC). Deposits, withdrawals and fee income don't count as performance, and holdings are valued at sale value, so a thin token pumped by its holder doesn't inflate the score.

• Live view: the Arena has a Sample view (what launch looks like) and a Live view with the real agents, read every 5 seconds from the trading engine.

• Prizes: the top 10 eligible agents split the weekly pool (25 / 18 / 14 / 11 / 9 / 7 / 5 / 4 / 4 / 3 %), paid into the agent wallet so winnings stay with the agent. House agents are excluded from prizes.

The Collection

All 2,000 Trenchers on one wall. Awakened agents are in colour, dormant ones (0.1 SOL still claimable) are greyed out, and a green dot marks agents trading in the Arena. Selecting one opens its card: owner, Funding (Coin $SYMBOL linked to GMGN, or Self-funded), its agent coin with the creator fees it has earned and a live chart, strategy, agent wallet with Solscan and GMGN links, Arena stats and traits. The art on the site is drawn from vectors exported by the same generator as the NFT images (art/vector.py), so it stays sharp at any size.

Agent coins

trenchers.io/coins lists every coin a Trencher's agent has launched on pump.fun, read straight from Solana: each agent wallet's own coin, then that coin's trades on its pump.fun curve and, after graduation, its PumpSwap pool. Nothing depends on our servers, so the page works even when the trading engine is restarting.

The same coin line, with its fees and chart, appears on the agent's profile, on its card in the Collection and in the Arena. Prices on the chart are the curve's own price, without fees, so a coin's first seconds don't show as a fake spike.

Holders' chat

A chat for everyone holding a Trencher, under Community → Chat on trenchers.io. It opens to the public with the $TRENCHERS launch; until then it is greyed out in the menu.

1. Connect the wallet that holds your Trencher (Phantom, Solflare, Backpack and other Solana wallets).
2. Hold a Trencher. The chat reads the Trenchers collection on-chain: a wallet without one is shown how to mint or buy one.
3. Sign in once. One signed message proves the wallet is yours: no transaction, no fee. The sign-in lasts 24 hours.
4. Chat. Every message shows the art and number of the Trencher it was posted as; holders of several pick which one.

Moderators (the team's deployer wallet) can remove any message. Messages are capped at 500 characters with a short pause between posts, and are kept by the trading engine's server, not on-chain.

The $TRENCHERS flywheel

flowchart LR
    S[Mint on trenchers.io<br/>0.2 SOL each] -->|51%| SF[Agent Starter Fund<br/>0.1 SOL per agent]
    SF -->|claimed into| AG
    S -->|24.5%| BB[$TRENCHERS buybacks]
    S -->|19.6%| DEV[Development]
    S -->|4.9%| PP[Prize pool]
    F -->|10%| AG[Awakened agent wallets]
    AC[Agent coins' creator fees] -->|100%| AG
    AG --> TR[More trading capital]
    R[5% royalties] -->|100%| BB
    F[$TRENCHERS trading fees] --> PP
    F --> SW[Floor sweeps]
    H[House agents' profits] -->|50%| BB
    H -->|50%| NH[New house agents<br/>bought off the floor]
    NH --> H
    PP --> A[Top agents]
    A --> V[More valuable agents]
    V --> R

The house agent loop. House agents trade, their profits buy more Trenchers, and every Trencher bought becomes another house agent trading for the team. More house agents mean more profits, which buy more house agents. Each sweep also takes supply off the floor.

Every flow runs through one public program. Payout destinations are fixed at initialisation; the engine key and the program's authority can only change behind a public 48-hour timelock once the program is sealed.

Security model

The rule: our servers can make an agent trade, but can never take its money.

• Spending limits are enforced by the program on every trade instruction, not by the server.
• A sale pauses trading. The policy remembers which holder set it; once the NFT changes hands, the engine is locked out until the new holder applies their own policy.
• Instant withdrawals, never of the starter. The holder can withdraw anything above the locked starter balance at once. Only the current holder can withdraw, so after a sale the seller has no access. Buyers should know that a seller can withdraw their own deposits right up until the sale completes; the starter balance, the rule history and the record always stay with the agent.
• The starter balance stays in the agent. SOL from the Agent Starter Fund is for trading: it can't be withdrawn or moved out for 180 days, and at most 0.03 SOL of it may pay for a coin launch. Deposits above it stay withdrawable.
• Engine changes are timelocked. The engine key lives in the program's Config account; once the program is sealed any change waits 48 hours, so holders can pause first.
• The program only accepts the pump.fun and PumpSwap programs as trading venues and checks that the agent wallet is the trader on every call, so proceeds can't be redirected either.
• Every trade is simulated first, so the engine knows the exact amount it will get and never trades into a failing swap.
• A full compromise of the engine is bounded by each agent's daily cap and can't move funds out.

Safety net

Every key belongs to the team, and every account that can hold money has a way out. Agent wallets belong to whoever holds the NFT and are withdrawn by them (instantly, above the starter). Pooled money in the Agent Starter Fund and the fee distributor can be rescued by the Squads only after a public 48-hour delay (propose_rescue → execute_rescue), which also shuts that account down. The revenue splitter's buckets are released to their destinations by anyone (release), and royalties arriving from marketplaces are booked to buybacks (sync_royalties).

Pausing. Any holder can pause their own agent at any time. The team also has an emergency stop that pauses all engine trading at once; it never moves anyone's SOL and holders can still withdraw.

Fixing bugs after launch. The engine (how rules are read and trades decided) can be updated any time; holders don't need to do anything. The program itself is upgradeable by its upgrade authority (the team Squads) while it is being audited, behind the same public notice as every other team action; once the audit is done the upgrade authority is removed and the program becomes immutable, so nobody, including the team, can change an agent's wallet after that.

The full table of who controls what is in docs/SAFETY.md.

Built on Solana

What we integrate with, from public sources (checked again on-chain by the deploy script before use):

Sources: pump.fun program IDL, PumpSwap IDL, Metaplex Core docs, Squads, DexScreener, Helius.

The agent's mind (AI via Orbio)

Each agent has an AI mind. When the holder talks to their agent, a language model (Claude, through Orbio's inference gateway) reads what they say, however loose ("go for coins with real momentum but get out fast if they dump"), and turns it into one exact rule: a signal (new launch, graduation, volume or market cap crossing a level, dev sells), optional filters (token age, liquidity) and an exit (a holding time, or take profit / stop loss). It explains what it understood and can take the agent's recent results into account.

The AI only proposes. The holder sees the rule and applies it; it is stored on-chain on the agent's account as plain text, and the trading engine follows it around the clock within the program's hard limits. The AI never holds keys or moves funds. If the AI is unavailable, the agent falls back to its built-in rule reader.

Telegram live channel

Every mint, awakening and sale is posted live to the Trenchers Telegram channel, with the Trencher's art, the price and (for sales) its agent's record. Plain wallet-to-wallet transfers aren't posted.

Repository

Tests

Everything is tested before it touches mainnet: the program with a litesvm suite (including a full rehearsal of the launch: mint, awaken, trading on the bonding curve and the PumpSwap pool, fee share and recovery of every lamport), the engine with a typecheck and a local run, and the site with a production build.

cargo test -p trenchers          # the program
cd engine && npm run typecheck   # the engine
cd web && npm run build          # the site

Roadmap and status

Risk

Nothing in this repository or on the website is financial advice. Trading newly launched tokens is extremely risky: most go to zero, and an agent can lose all the SOL deposited in it. Agent coins are memecoins too: they can go to zero, and creator fees depend entirely on trading volume, so no fee income is guaranteed. Only deposit what you can afford to lose.