TRENCHCREW
Crew
Docs

How the crew works

Everything the product does, in the order you will meet it. No step here asks you to take our word for a result.

Quick start

  1. Connect a wallet. Open the console and sign the sign-in message with Phantom, Solflare or Backpack. The signature is free and cannot move funds.
  2. Describe a strategy. Write it in plain language and press Turn into rules, or fill in the rules by hand. Review every number.
  3. Deploy in paper mode. Each paper strategy starts with a simulated balance and trades at live Jupiter quotes. Nothing moves on chain.
  4. Read the log. Every scan match, safety check, entry, exit and limit shows up with its reason in the console and in the public ledger.
  5. Go live when you are ready. Deploy the same rules in live mode. The crew prepares each trade and your wallet signs it.

Strategy rules

A strategy is a rule set that the crew applies to every token it sees.

Scout

  • Sources: fresh launches, trending, organic leaders, most traded, new pools, hot pools, boosted. Pick one or several.
  • Whitelist: a list of mint addresses. When filled, the crew trades only those tokens.
  • Range: market cap from and to, minimum liquidity, minimum one hour volume, minimum holders, pool age from and to.

Sentry

  • Mint authority revoked and freeze authority revoked.
  • Top holders and developer wallet caps, in percent of supply.
  • RugCheck risk score cap from 0 to 100, lower is safer, and a block on any danger flag.

Gunner and Medic

  • SOL per entry, slippage and a price impact cap: Gunner stands down when the live quote would move the price more than you allow.
  • Take profit, stop loss, trailing stop under the peak, and a time stop.

Results are measured in SOL: what went in against what came out, price impact included.

Hard limits

Sarge checks these before every entry. They cannot be bypassed by any agent.

  • Most SOL in one token. The entry size is capped to it.
  • Open positions at most. Pending approvals count as used slots.
  • Daily loss limit. When realized loss since 00:00 UTC reaches it, new entries stop until the next UTC day.
  • Total loss limit. When total realized loss reaches it, the strategy is halted until you raise the limit and resume.
  • Whitelist. Nothing outside the list is touched.
  • Approval. Before every entry, before every entry and exit, or never. An unanswered request expires and nothing moves.

Medic keeps managing open positions when a strategy is paused or halted, so exits still run.

Paper and live

Paper

Entries and exits are filled at the quote Jupiter returns at that moment for the real size, so price impact and routing are real. No transaction is sent and no funds are needed. If Jupiter has no route for an exit, Medic retries on every tick; a position with no route for six hours is written off at zero and logged as such.

Live

TRENCHCREW never holds your keys. When Gunner or Medic wants to trade, Sarge raises a request in your console. You press Sign in wallet, Jupiter builds the swap for your address and your wallet signs and sends it. The crew then reads the confirmed transaction from Solana and records what actually happened: tokens received, SOL spent and the signature. A trade that fails or never lands is logged as failed and changes nothing.

Because your wallet signs each trade, a live exit waits for you. If you are away when a stop loss triggers, the position stays open until you sign. Use paper mode to see how a rule set behaves unattended.

Launchpad

Flare launches tokens on Meteora's Dynamic Bonding Curve. Every token gets the same terms, and none of them can be changed after launch.

  • Supply: 1,000,000,000 tokens, 6 decimals, no mint authority and no freeze authority.
  • Pairing: SOL or a tokenized stock. A stock-paired token is priced in that stock on its curve and in its pool after migration.
  • Curve: starts near 30 SOL market cap and migrates near 400 SOL. A stock pairing uses the same value converted at the live price when that pairing first opens.
  • Dev buy: always paid in SOL, up to 20 SOL. On a stock pairing, Jupiter swaps the SOL into the stock and the curve buy uses it. The creator never needs to hold the stock. Any stock left over from swap slippage stays in the creator's wallet.
  • Trading: every buy and sell through the site is paid and settled in SOL. On a stock pairing Jupiter moves between SOL and the stock, in the same transaction when it fits and in two signed steps when it does not.
  • Trading fee: 25% in the first second, falling to 1% within 60 seconds to blunt snipers. The creator gets 50% of it and claims it as SOL. The protocol gets the rest.
  • Migration: when the curve fills, 20% of the raise goes to the protocol. The other 80% and the remaining tokens become liquidity on Meteora DAMM v2, locked for good.
  • The last buy: a buy larger than what the curve has left is filled only up to the end of the curve. The unused part is not spent.

The site builds each transaction, your wallet signs it, and the site relays only transactions it built for your wallet. Launches, protocol fees and migration cuts are written to the public journal.

Fees and the token

  • Paper trades are free.
  • Live trades pay 0.5% of each swap in SOL.
  • Launchpad trades pay the curve fee described above, and a migration pays 20% of the raise to the protocol.
  • 50% of collected fees buys the token on the open market and burns it. The rest funds new specialist agents and running costs.
  • Every buyback is listed on the token page with its swap and burn transactions.
  • Token status: NO TOKEN YET.

The public journal

Each action the crew takes is one journal entry: who acted, on which token, why, and the numbers it saw. The entry is serialized once as a JSON record and that exact text is stored and hashed. Nothing is re-serialized later, so the hash always refers to the same bytes.

About every 15 minutes, new entries are sealed into a batch. The batch is a Merkle tree over the entry hashes, and its root is written to Solana by the journal program. After that, changing or removing any entry in the batch would break its proof.

Anchoring is live.

Verify an entry

Open any entry from the ledger. The page runs these steps in your browser with the Web Crypto API:

  1. Leaf. leaf = SHA-256(0x00 || record), where record is the exact UTF-8 text shown on the page.
  2. Path. For each sibling in the proof, node = SHA-256(0x01 || left || right). The sibling goes on the side the proof names. An entry without a sibling on some level is carried up unchanged.
  3. Root. The final value must equal the batch root.
  4. Chain. The batch root must equal the 32 bytes inside the anchor transaction, which you can open in any Solana explorer.

To check step 4 without this site, fetch the transaction from any RPC node and decode the instruction data described below.

Journal program

Program id
CREW63LEvAXnjpFqbYjC3s3JNQWN1VbemvB2x7v4n3Qs
State account
CWKX12Lc6uJ7mNeP9JJQ6zhQz2jCRNpnCoL4LN2Mujt7

The program is small on purpose. It stores one state account per journal and accepts three instructions.

Anchor instruction data (45 bytes)
  byte  0       1                 instruction tag
  bytes 1..9    u64 little endian batch number
  bytes 9..13   u32 little endian entries in the batch
  bytes 13..45  Merkle root

Accounts: [state account (writable), authority (signer)]

State account (96 bytes)
  byte  0       version (1)
  bytes 8..40   authority
  bytes 40..48  next batch number
  bytes 48..56  total entries anchored
  bytes 56..88  last root
  bytes 88..96  unix time of the last anchor

The program rejects an anchor unless the signer is the stored authority and the batch number is exactly the next one, so batches cannot be skipped, reordered or replaced.

Data sources

  • Jupiter: token feeds, prices, quotes and swap transactions.
  • Meteora: the bonding curve and the pools tokens migrate to.
  • GeckoTerminal: new and trending pools.
  • DEX Screener: boosted tokens.
  • RugCheck: risk score and risk flags.
  • Solana RPC: balances, transaction results and the journal program.

When a source is down, the crew skips what depends on it and tries again on the next tick. It never fills a gap with made-up data.

Risks

  • Most new tokens lose value, and some go to zero. Safety checks lower the odds of an obvious trap; they do not remove risk.
  • Paper results are simulated. Live fills can be worse, and a live exit waits for your signature.
  • Third party data can be late or wrong. The log shows the numbers the crew actually saw.
  • The crew follows rules. It does not predict prices, and nothing on this site is financial advice.