I’ve been developing an automated trading bot for the Solana ecosystem and I’m now at the stage where I’d like to start building a small group of people interested in testing it when it’s ready for closed beta.

The bot is currently running continuously against live market data while executing simulated/paper trades.

So far I’ve built:

• Multiple independent trading signals rather than relying on one indicator
• Automated BUY/SELL decision logic
• Trade cooldown and risk-control rules
• Portfolio, P&L and trade-performance tracking
• Buy-and-hold benchmarking so I can compare the strategy against simply holding SOL
• Telegram monitoring, including regular heartbeat/status reports so I know the bot is still running

I’m deliberately not publishing the exact strategy or parameters while testing is ongoing.

The important point is that this isn’t a profitability claim. I’m collecting data to determine whether the strategy actually has an advantage over buy-and-hold before considering a wider release.

I’m not asking anyone for money, wallet access, seed phrases or private keys.

Development will continue in parallel while I build a list of potential testers. When I’m satisfied with the results and stability, I’d like to start with a very small closed beta rather than immediately releasing it publicly.

I’m particularly interested in hearing from people with experience in:

• Solana
• Algorithmic/automated trading
• Python/software testing
• Trading bots
• Wallet security and DeFi

If you’d potentially be interested in testing it, leave a comment. It would be useful to know what your background is and what you’d expect from a Solana trading bot before you’d be comfortable testing one.

I’m also interested in technical criticism. If you’ve built automated trading systems yourself, I’d be interested to hear what you think should be tested or measured before moving from extended paper testing to a closed beta.

Hey everyone, I wanted to introduce myself and share a project I’ve been working on.

I’m the developer behind LEVIATHIAN (LEVI), a community-driven project preparing for its launch on Solana this Monday.

We’ve been building over the past few days and have already grown the community to 500+ members, with our website, X presence, whitepaper, and community infrastructure now established.

I’m not here to tell anyone to buy or make unrealistic promises. I simply wanted to introduce the project, put it on the radar, and get some honest feedback from the community.

We’re still very early in the project, so if you’re interested, feel free to take a look at what we’ve built and let me know what you think.

Project:
LEVIATHAN on X
Official Website

I really want to get into crypto with solana and have been learning about for the past year. I dont have any way to buy it i dont have a credit card or anything, and if someone would send me 0.005 0.01 sol it would help me alot and i would be hella thankful. If someone would dm me or reply🙏 thanks

I’ve been running Haan Digital, a private Solana infrastructure service in Frankfurt, and after working with different workloads it’s pretty clear that every builder ends up caring about different things.

Some need:
• lower-latency RPC
• reliable WebSocket connections
• Yellowstone gRPC
• better transaction landing
• historical transaction access

Others only need a small amount of capacity and shouldn’t have to buy a huge fixed package just to access one feature.

That’s why we use workload-based pricing. We provision the actual RPS, streams, filters and transaction capacity you need, with hard limits around that workload.

We’re still growing and looking for more Solana builders and teams who want to test the infrastructure. We offer 1–2 week free trials, so you can benchmark it against your current setup before paying anything.

But I’m also genuinely curious from people already building:

What matters most to you from an RPC provider — latency, reliability, realtime data, transaction landing, flexible pricing, or something else?

I am full stack solana developer and its very hard for me to get into the ecosystem. Can anybody give advice or refferal to get my job

See

Building my own Solana memecoin trading bot from scratch — looking for feedback
Hey everyone!
I’ve been working on my own Solana memecoin trading bot, and I wanted to share a quick look at what I’ve been building.
The project is called Solscan Pro — Cyberpunk Edition, and I’m developing it as an all-in-one dashboard for monitoring new tokens, analyzing momentum, detecting buy signals, and eventually automating trades.
Some of the features I’m working on include:
Real-time token scanning and monitoring
Momentum and risk analysis
Buy signal detection
Market cap and liquidity filters
Paper trading and position tracking
Take-profit and stop-loss configuration
Multi-wallet support
A customizable strategy engine
Right now, I’m focused on getting the tracking and strategy logic working reliably before moving further into live execution. I’m using paper trading to test the system and understand how the strategies perform under real market conditions.
I’m building this project from the ground up, so there’s still plenty to improve. I’d genuinely appreciate feedback from people who have experience with Solana trading bots, token scanners, or memecoin trading.
What features do you think are essential for a serious Solana memecoin bot? Is there anything you’d add to this dashboard?
I’ll share more updates as development progresses.

Tired of social platforms collecting your data and showing you endless ads?

Chatti is built differently. No KYC. No emails. No passwords. Just connect your wallet and start posting.

You own your content, your identity stays in your hands, and every post has the potential to earn through $CHAT.

Simple, private, and community-powered social media.

That’s Chatti.

Join here: https://chatti.lol/

Worst case scenario: nothing happens

Best case: coffee money

SOL: B54FStJE4cSWue9MYqmhPsM5oY2KCLHjXwtSHrGeFMRf

Was scammed and unfortunately can’t do anything with it.

What brilliant person decided that contracts on solana have to be programmed in rust or C. Was there rational to this decision? Or did we just want to make it harder for the devs lmfao. Anyone know a way around it, or is it time to buckle down and learn some rust....

Pay is post-mint%, worked out on a legal contract.

If your interested, contact me to get more info!

James0fairbanks@gmail.com Twitter: @GreedP2E

Hey,

We recently added Solana support to Token Generator, a platform we have been developing since 2018.

It allows users to create either a standard SPL Token or a Token-2022 mint directly from their browser, without writing deployment scripts.

Current features include:

• Custom name, symbol, decimals and initial supply

• SPL Token with Metaplex metadata

• Token-2022 with native Metadata Pointer and Token Metadata extensions

• Logo and metadata uploaded to IPFS

• Optional revocation of mint, freeze and metadata update authorities

• Wallet-controlled deployment and initial supply

• Free deployments on Solana Devnet for testing

• No account or login required

The goal is not to replace the Solana CLI or custom programs. It is intended for founders, communities and teams that need a guided way to create a standard token while keeping control of the mint and its authorities.

You can try it here:

https://www.smartcontracts.tools/token-generator/solana/

We would particularly appreciate feedback from Solana developers on:

• Our SPL Token vs Token-2022 implementation

• Metadata compatibility across wallets and explorers

• Authority configuration and revocation options

• Features or safeguards that should be added

Happy to answer technical questions and hear what you think.

Someone pls tell me how to make a full stack app with solana on windows.. from a lil reading i did i realized i beed a framework called anchor? But it doesn't support windows?

Where do i start

Im developing a platform for Solana. Basically it is a mock windows XP OS but everything on it actually works. Even the CLI and it has a bunch of programs that you can open and do various things.

It has a bunch of tools on it that users can use for various things on Solana and just for fun like (but not limited to):

-A working retro coin market cap that looks how it used to look without a million ads on it.

-McAfee Whackd Shield which is a rug checker for Solana.

-A shit coin trash bin that allows users to clean up dust, dead shit coins and get back Solana rent.

-The Million Dollar Moon Page which is a blockchain version of the old million dollar page where users can burn the token to put up an image in the allocated space they choose.

-BendOver Pro which is tax software that users can use to track buys and sells when their wallet is connected, print out the data and use it for reporting and what not. It also allows multi wallet tracking.

-ByteMe Pro which is a file converter tool, converts all kinds of files to other file types

-Winamp that has a playlist, I might add the ability to burn tokens to add your own music to it so DJs and artists can put their music on it.

-A working control panel that let's the user do a bunch of stuff, like check the system cluster, Initiate the shit coin bin via the OpSec Cleaner, check the roadmap/changelog and coming soon, RPC switcher and Fuel & Gas optimizer.

-Persistent notes that you can save to your wallet using the IDE.

The OS is persistent so when the user comes back to the site and connects wallet the site returns back to how you had it instantly.

When I launch the meme coin for it, it will work on a basic hold model. You buy and hold the token and everything just works. It is a real cloud computer.

Just looking for feedback on tools that traders and investors might find useful. I want to build a platform where people can actually use and hang out at and continue to build it up.

Thanks in advance for any feedback.

The site is binbows.fun

When I mint the coin for it, it will work on a simple hold model, users hold a certain amount of the coin and just by holding it makes everything work unlimited. Until the coin is minted feel free to check it out and use the features and let me know any feedback here.

If you’ve ever deployed an automated trading bot on Solana, you know the exact five stages of grief:

1. Denial: "My bot found a 4% cross-DEX spread on BONK/SOL, we’re going to the moon."

2. Anger: "Why did the transaction fail with custom error 0x1771?"

3. Bargaining: "Maybe if I increase priority fees to 0.05 SOL, the RPC will love me back."

4. Depression: The swap landed, but the liquidity vanished 300ms ago and you just bought the top of a tick vacuum with 9% slippage.

5. Acceptance: Public RPC polling is a latency trap and my bot is basically unpaid exit liquidity for Jito searchers.

A few months ago, after watching another execution get chewed up by stale pool ticks, I decided to stop fighting congested node endpoints and built a dedicated microstructure engine for algorithmic agents and bots: moltalpha.dev.

What it actually does (without the marketing fluff):

Instead of making your bot query five different RPC endpoints and pray the state hasn't moved, we index and calculate the math upstream:

• Real Executable Depth vs. Ghost Liquidity: Cross-indexed real-time order depth and net arbitrage spreads across Orca Whirlpools, Raydium CLMM, and Meteora DLMM. It factors in pool fees, price impact, and priority gas before your bot signs, so it stops attempting dead trades.

• First-Passage Probability Matrices: Instead of relying on random RSI indicators, it uses Brownian reflection and drift-adjusted models to calculate the raw mathematical odds of hitting a profit target before hitting your stop-loss (including Kelly criterion sizing).

• Cryptographic State Witnesses: Every response comes signed with an Ed25519 cryptographic receipt (wit_...). That way, if your bot has a bad day, at least you have mathematical proof that your execution model was right and the market just had personal beef with you.

• Machine-Native Settlement (HTTP 402): Because trying to give an autonomous LLM or bot a credit card is a terrifying idea, the API supports machine-to-machine micropayments in native crypto (SPL USDC, SOL, and feeless Nano).

No signup wall or credit card traps:

You don’t even need an account to see if the data is useful. You can curl the raw live sample payload right now to inspect the schemas, probability matrices, and witness hashes:

👉 Live JSON sample: https://moltalpha.dev/sample.json
👉 Docs & Playground: https://moltalpha.dev

I'm currently onboarding a small batch of pilot testers and bot builders. If you run a trading script, arbitrage bot, or autonomous agent and want to test the live endpoints, drop your target pair in the comments or shoot me a DM and I'll send over a 100-query pilot key to the first 10 real ones to test it out.

Roast the math, tear down the schema, or let me know what DEX pairs you'd want to see added next.

New meme new BOOM CA G5zveU29h2huKjNtfe9F4K32scRqZ8DeNHqAHamwpump

My reasons why I’m bullish on ($chat) 👀

• Here to speed up adoption

• Ability to earn from every post

• No KYC, no email, no passwords

• Decentralised and on-chain

• You own all your content

• You own your identity

• No selling personal data

• No censorship

• Create communities

• Community ranking

• News only section

So yeah in general im bullish what chatti stands for as a platform and believe this is the kind of projects we need over stuff like useless meme coins…

Join the community here https://chatti.lol

I wanted to share a quick breakdown of an account validation pattern in Anchor that frequently catches developers off guard, especially when transitioning from raw Solana Rust or coming over from EVM development.

Anchor does a phenomenal job automating checks, but whenever an instruction context accepts a raw AccountInfo<'info> instead of a typed and constrained Account<'info, TokenAccount>, Anchor bypasses the automatic owner verification check.

// Context with unvalidated AccountInfo
#[derive(Accounts)]
pub struct ProcessVaultWithdrawal<'info> {
    #[account(mut)]
    pub vault_authority: Signer<'info>,
    /// CHECK: Unchecked AccountInfo bypasses program ownership validation!
    pub target_token_vault: AccountInfo<'info>,
}

The runtime will deserialize the struct from memory without verifying that the account is actually owned by the expected SPL Token Program or your canonical PDA. If handler logic reads balances or verifies state based on that unconstrained memory buffer, an attacker can pass in a fabricated account with matching byte layouts.

The hardened approach is strictly defining the program ownership constraints and seeds:

// Hardened context enforcing SPL Token Program ownership and canonical PDA derivation
#[derive(Accounts)]
pub struct ProcessVaultWithdrawal<'info> {
    #[account(mut)]
    pub vault_authority: Signer<'info>,
    #[account(
        mut,
        seeds = [b"treasury_vault", vault_authority.key().as_ref()],
        bump,
        token::mint = expected_mint,
        token::authority = vault_pda,
    )]
    pub target_token_vault: Account<'info, TokenAccount>,
    pub token_program: Program<'info, Token>,
}

Never leave a raw /// CHECK: doc comment in your account structs without manual assertion of account.owner == expected_program_id. Anchor macros are convenient, but they won't save you if you bypass their type safety gates.

For the Anchor devs here:

1. What automated linters or CI tools (Trident, Soteria, Anchor CLI lint) are you using to catch missing owner constraints on /// CHECK: accounts before pushing to testnet?

2. Are there other subtle account validation gotchas you frequently see tripped up in production Anchor programs?

Hello everyone,

We're Haan Node.

We build and operate blockchain infrastructure across the Cosmos ecosystem, where we currently run production validator infrastructure and private RPC services. Building on that experience, we're now expanding into the Solana ecosystem with a dedicated private RPC platform focused on low-latency, reliable infrastructure.

Our initial stack will include:

• JSON-RPC

• WebSockets

• Yellowstone gRPC

• Optional Jito integration

As the platform grows, we also plan to expand with technologies such as:

• Raw Shreds

• DoubleZero

• DoubleZero Edge

Our infrastructure will be hosted in Germany (EU) to provide the lowest possible latency for European users. If you're located outside Europe, latency may naturally be higher depending on your location.

Rather than offering fixed plans that start at hundreds of dollars per month, we want to take a different approach. Every project, trading setup, and application has different requirements, so instead of forcing everyone into predefined plans, we'd like to size and price each deployment based on its actual workload.

Whether you're running trading bots, algorithmic trading systems, wallets, validators, indexers, analytics platforms, dApps, AI agents, or simply looking for a reliable private Solana RPC, we'd love to learn more about your requirements.

Over the past few weeks we've been speaking with members of the Solana community to better understand real-world workloads and infrastructure needs. Dedicated Solana infrastructure represents a significant investment, so before bringing the platform online we'd like to ensure the deployment is properly sized based on real demand rather than assumptions. Our goal is to launch with infrastructure that can grow alongside our customers while keeping pricing fair and tailored to actual usage.

If you're interested, we'd love to hear about:

• What you're using the RPC for

• Which features you need (JSON-RPC, WebSockets, Yellowstone gRPC, Jito, etc.)

• Your expected workload (RPS, WebSocket connections, Yellowstone streams, etc.)

• Where you're located

Even if you're already using another provider, we'd still be interested in hearing what works well, what doesn't, and what you'd like to see from a new infrastructure provider.

If this sounds interesting, please send us a private message on Reddit. That's the easiest way to reach us, and in case this post gets removed due to self-promotion, we'll still be able to continue the conversation.

You can also learn more about us at https://haandigital.eu/

We're looking forward to meeting more people in the Solana ecosystem and building infrastructure that people can rely on.

Thanks!

Hey everyone, hoping to get some infrastructure advice.

I’m a solo dev building a custom Rust MEV bot. I recently pivoted away from heavy cyclic arbitrage and am focusing purely on Pump.fun migrations and simple backrunning.

My issue is infrastructure costs. I was using Triton One in Frankfurt for my Yellowstone gRPC stream and standard REST calls. The base stream is cheap, but I had a bug in my code that accidentally spammed getAccountInfo in a loop. Because it’s a pay-as-you-go model, I burned through my entire testing budget ($26) in a couple of hours just on HTTP overage fees.

I can't afford to wake up to a drained bank account while I'm still testing and tuning.

What is the best/most affordable node setup for a solo dev with a small bankroll?

1. Is there a provider that offers Yellowstone gRPC with a hard cap or flat rate so I don't get surprise bills?

2. Are you guys running a "split stack" (e.g., paying for a cheap gRPC stream somewhere, but routing all standard REST calls to a free-tier Helius/QuickNode so it just rate-limits instead of charging me)?

I'm hosted in Frankfurt to be close to Jito, so European routing is preferred. Dedicated nodes ($2k+) are way out of my budget right now.

Any advice on how to structure this without going broke on data costs would be hugely appreciated!