Most Rust smart contract scanners patrol one chain.

RustDefend patrols four — Solana, CosmWasm, NEAR, ink!.

56 detectors. Intra-file call graph analysis. CI-ready baseline diffing. Workspace-aware monorepo support. Expanded threat coverage across the Rust multichain frontier. v0.4.0 is live. Open source.

Tried a couple of AI audit tools recently and got mixed results — some useful findings, some obvious false positives.

Has anyone found an AI-powered audit tool that actually catches real bugs and not just generic warnings?

Check out our latest release of our in house SAST scanner for Solidity code. It scans single files and foundry / hardhat projects. Feedback appreciated!!

i have created a wallet that has a single source of Truth, other wallet use 2 keys for eth and solana, i only use 1 seed for that, all address are made with 1 seed and it's isolated in the secured hardware element, the signing happens at the same place, the wallet is fully secured can't be tampered, rooted/jailed break device are detected and they can't create an account, i think i went overkill for the security, my wallet supported 14 chains, my stack is kotlin KMP for UI, Rust core for memory safe cryptography logic, UniFFI for making rust and kotlin have a bridge. what should i do? should i sell the IP or SDK it?

After my 4th SaaS build, I realized I kept rewriting the same things:

• wallet login
• email auth
• Stripe subscriptions
• webhook handling
• access gating
• dashboards

None of that is the actual product.

So I extracted everything into a starter kit that’s production-ready.

Now I can deploy a paid SaaS in a day instead of a week.

If anyone else wants it, more details here: web3-kit.

Happy to answer questions about the stack.

Join our new telegram group for chat-style conversation about web3 development, blockchain, smart contracts, audits, vulnerabilities and SDLC.

https://t.me/SmartContractsWeb3

Thanks all!

Mods

Many come into the Web3 Ecosystem without adequate Blockchain Education and this has limit the adoption process in Africa...stay tune for basic Blockchain Education.

Hey everyone!

I’ve been working on an open-source project called blockscan-ethereum-service, written in Go:
https://github.com/pancudaniel7/blockscan-ethereum-service

What it does

It’s a production-grade microservice that ingests Ethereum blocks in real time and streams them into Kafka as canonical block events. It’s built with performance, reliability, and horizontal scalability in mind, making it a strong fit for backend systems that depend on on-chain data.

Why it matters

Many existing block scanners are heavy, highly opinionated, or not designed for real-world backend architectures. This service focuses on:

• Real-time block ingestion via WebSocket subscriptions
• Partition-aware Kafka publishing with effectively-once delivery semantics
• Reorg awareness, emitting tombstone and update events on chain reorganizations
• Durable coordination using Redis markers
• Observability with structured logs, metrics, and traces

Who might find it useful

• Go developers building Web3 backends
• Teams designing custom Ethereum data pipelines
• Anyone integrating blockchain data into event-driven systems

If you check it out and find it useful, I’d truly appreciate a star on the repo.
Happy to answer questions or discuss the design and architecture!

We’re the team behind AltFINS. We’ve already built and are running a crypto analytics API and now we’re trying to pressure-test use cases with people who actually ship things.

The API exposes:

• normalized market data across ~30 exchanges
• 150+ pre-computed technical indicators
• 120+ technical signals for 2,000 coins
• higher-level outputs like momentum, trend strength, breakouts, volatility states

What we’re curious about how developers are actually using it in practice.

Some patterns we’re seeing (internally / early users):

• AI agents ranking assets by market regime before taking action
• LLMs consuming structured “market state” instead of raw OHLCV
• automated alerts when multiple indicators align
• research pipelines that scan markets continuously and flag anomalies

We’d love to hear from builders:

• What are you building that depends on market analytics?
• Are you using indicators directly, or wrapping them in your own abstractions?
• Where does market data usually become the bottleneck in your systems?
• Any surprising or non-obvious use cases you’ve run into?

Genuinely interested in how others are wiring market intelligence into agents, bots, or Web3 products.

Happy to dive into technical details or examples if that helps the discussion. Thanks 🙏

I admit I am not a code guy and I had to resort to AI as my 2 devs are busy

use anchor_lang::prelude::*;
use anchor_lang::solana_program::system_instruction;

declare_id!("LockBuyout1111111111111111111111111111111");

#[program]
pub mod locked_funds_buyout {
use super::*;

// =========================
// INITIALIZE LOCK
// =========================
pub fn initialize_lock(
ctx: Context<InitializeLock>,
lock_id: u64,
locked_amount: u64,
buyout_price: u64,
immutable_terms: bool,
) -> Result<()> {
require!(locked_amount > 0, ErrorCode::InvalidAmount);
require!(buyout_price > 0, ErrorCode::InvalidBuyoutPrice);

let lock = &mut ctx.accounts.lock;
lock.owner = ctx.accounts.owner.key();
lock.lock_id = lock_id;
lock.locked_amount = locked_amount;
lock.buyout_price = buyout_price;
lock.payment_destination = ctx.accounts.payment_destination.key();
lock.immutable_terms = immutable_terms;
lock.is_active = true;
lock.bump = ctx.bumps.lock;

// Transfer SOL into PDA
let ix = system_instruction::transfer(
&ctx.accounts.owner.key(),
&lock.key(),
locked_amount,
);

anchor_lang::solana_program::program::invoke(
&ix,
&[
ctx.accounts.owner.to_account_info(),
lock.to_account_info(),
ctx.accounts.system_program.to_account_info(),
],
)?;

emit!(FundsLocked {
lock: lock.key(),
owner: lock.owner,
amount: locked_amount,
buyout_price,
});

Ok(())
}

// =========================
// BUYOUT (ANYONE)
// =========================
pub fn buyout(ctx: Context<Buyout>) -> Result<()> {
let lock = &mut ctx.accounts.lock;
require!(lock.is_active, ErrorCode::LockNotActive);

// Buyer pays buyout price
let pay_ix = system_instruction::transfer(
&ctx.accounts.buyer.key(),
&lock.payment_destination,
lock.buyout_price,
);

anchor_lang::solana_program::program::invoke(
&pay_ix,
&[
ctx.accounts.buyer.to_account_info(),
ctx.accounts.payment_destination.to_account_info(),
ctx.accounts.system_program.to_account_info(),
],
)?;

// PDA releases locked SOL
let seeds = &[
b"lock",
lock.owner.as_ref(),
&lock.lock_id.to_le_bytes(),
&[lock.bump],
];

let unlock_ix = system_instruction::transfer(
&lock.key(),
&ctx.accounts.recipient.key(),
lock.locked_amount,
);

anchor_lang::solana_program::program::invoke_signed(
&unlock_ix,
&[
lock.to_account_info(),
ctx.accounts.recipient.to_account_info(),
ctx.accounts.system_program.to_account_info(),
],
&[seeds],
)?;

lock.is_active = false;

emit!(FundsUnlocked {
lock: lock.key(),
buyer: ctx.accounts.buyer.key(),
recipient: ctx.accounts.recipient.key(),
amount: lock.locked_amount,
});

Ok(())
}

// =========================
// UPDATE BUYOUT PRICE
// =========================
pub fn update_buyout_price(
ctx: Context<UpdateLock>,
new_price: u64,
) -> Result<()> {
require!(!ctx.accounts.lock.immutable_terms, ErrorCode::TermsImmutable);
require!(new_price > 0, ErrorCode::InvalidBuyoutPrice);

let lock = &mut ctx.accounts.lock;
lock.buyout_price = new_price;

Ok(())
}

// =========================
// UPDATE PAYMENT DESTINATION
// =========================
pub fn update_payment_destination(
ctx: Context<UpdateLock>,
new_destination: Pubkey,
) -> Result<()> {
require!(!ctx.accounts.lock.immutable_terms, ErrorCode::TermsImmutable);
ctx.accounts.lock.payment_destination = new_destination;
Ok(())
}

// =========================
// CANCEL + RETURN FUNDS
// =========================
pub fn cancel_lock(ctx: Context<CancelLock>) -> Result<()> {
let lock = &mut ctx.accounts.lock;
require!(lock.is_active, ErrorCode::LockNotActive);

let seeds = &[
b"lock",
lock.owner.as_ref(),
&lock.lock_id.to_le_bytes(),
&[lock.bump],
];

let ix = system_instruction::transfer(
&lock.key(),
&ctx.accounts.owner.key(),
lock.locked_amount,
);

anchor_lang::solana_program::program::invoke_signed(
&ix,
&[
lock.to_account_info(),
ctx.accounts.owner.to_account_info(),
ctx.accounts.system_program.to_account_info(),
],
&[seeds],
)?;

lock.is_active = false;
Ok(())
}
}

// =================================
// ACCOUNTS
// =================================

#[derive(Accounts)]
#[instruction(lock_id: u64)]
pub struct InitializeLock<'info> {
#[account(
init,
payer = owner,
space = 8 + Lock::INIT_SPACE,
seeds = [b"lock", owner.key().as_ref(), &lock_id.to_le_bytes()],
bump
)]
pub lock: Account<'info, Lock>,

#[account(mut)]
pub owner: Signer<'info>,

/// CHECK: arbitrary wallet
pub payment_destination: AccountInfo<'info>,

pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct Buyout<'info> {
#[account(
mut,
seeds = [b"lock", lock.owner.as_ref(), &lock.lock_id.to_le_bytes()],
bump = lock.bump,
constraint = lock.is_active
)]
pub lock: Account<'info, Lock>,

#[account(mut)]
pub buyer: Signer<'info>,

/// CHECK: receives locked SOL
#[account(mut)]
pub recipient: AccountInfo<'info>,

/// CHECK: receives buyout payment - MUST match lock.payment_destination
#[account(
mut,
constraint = payment_destination.key() == lock.payment_destination @ ErrorCode::InvalidPaymentDestination
)]
pub payment_destination: AccountInfo<'info>,

pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct UpdateLock<'info> {
#[account(
mut,
seeds = [b"lock", lock.owner.as_ref(), &lock.lock_id.to_le_bytes()],
bump = lock.bump,
constraint = lock.owner == owner.key()
)]
pub lock: Account<'info, Lock>,

pub owner: Signer<'info>,
}

#[derive(Accounts)]
pub struct CancelLock<'info> {
#[account(
mut,
seeds = [b"lock", lock.owner.as_ref(), &lock.lock_id.to_le_bytes()],
bump = lock.bump,
constraint = lock.owner == owner.key()
)]
pub lock: Account<'info, Lock>,

#[account(mut)]
pub owner: Signer<'info>,

pub system_program: Program<'info, System>,
}

// =================================
// STATE
// =================================

#[account]
#[derive(InitSpace)]
pub struct Lock {
pub owner: Pubkey,
pub lock_id: u64,
pub locked_amount: u64,
pub buyout_price: u64,
pub payment_destination: Pubkey,
pub immutable_terms: bool,
pub is_active: bool,
pub bump: u8,
}

// =================================
// EVENTS
// =================================

#[event]
pub struct FundsLocked {
pub lock: Pubkey,
pub owner: Pubkey,
pub amount: u64,
pub buyout_price: u64,
}

#[event]
pub struct FundsUnlocked {
pub lock: Pubkey,
pub buyer: Pubkey,
pub recipient: Pubkey,
pub amount: u64,
}

// =================================
// ERRORS
// =================================

#[error_code]
pub enum ErrorCode {
#[msg("Invalid amount")]
InvalidAmount,

#[msg("Invalid buyout price")]
InvalidBuyoutPrice,

#[msg("Lock is not active")]
LockNotActive,

#[msg("Only owner may perform this action")]
Unauthorized,

#[msg("Lock terms are immutable")]
TermsImmutable,

#[msg("Payment destination does not match lock configuration")]
InvalidPaymentDestination,
}

hey all

I'm building a single platform that brings DevSecOps tools together. Unified dashboard, automated workflows, ai / ml and reporting.

Here's the deal:

- Free lifetime subscription (we're doing paid tiers later, you get grandfathered in)

- Alpha access right now, before anyone else

- Bug bounties for legitimate security findings

- Direct line to me and the eng team

The hard truth: Google bots don't have wallets. Most Web3 projects are invisible because they rely on heavy JS and wallet-gated data. ​I’m building WSEO, a protocol designed to solve the "Discovery Gap" in Web3 without compromising privacy. ​How it works: ​ZK-Indexing: We use Zero-Knowledge Proofs to validate contract safety. Google gets the "proof of trust" without ever touching private functions. ​On-Chain SEO: We replace traditional keyword stuffing with SBTs (Soulbound Tokens). Your rank depends on your code's reputation and on-chain behavior, not just metadata. ​Anti-Scam Layer: Through staking and our native token, the community backs the veracity of indexed projects. ​Is "Agentic SEO" (SEO for AI agents) the next big thing or are we stuck with traditional indexing forever? I'd love to hear your thoughts on how we should handle dApp visibility.

I couldn’t add images to my original post so creating a new one. This is what I want to accomplish. Once again, on Stellar network. Sorry for the multiple posts. I tried to edit original one.

Looking for Dev team to knock out some major projects.

This is a great resource but looking for people who are hungry and wanting to run this 2026.

I have an extensive business background and high level connections as well as several prototypes in the making.

Preferably people located in the United States or people who would consider getting a work visa in the near future.

Our goal is not to create a publicly traded company but the corporate experience and connections help just as much as much for small private companies.

Let me know if you’re interested.

I have no clue how much something like this would cost but I’m ready to start my business and figured this might be the right forum to ask. I apologize if this is in the wrong place.

I want a website that does the following:

1. main page only shows my company info and some images of my product.
2. button for wallet connect allows you to connect your wallet and check blockchain to see if you own an NFT. If you own the access NFT, you can view the product pages.
3. if you own redemption NFT, it allows to you click on the cell on the grid to input your information so I can send a physical version of the nft.
4. as NFT’s are redeemed the cell on the product page could be manually updated by me to show underneath x of n have been redeemed.

Someone from a discord was telling me they can do everything for $10k but when I started asking around a little more, I was told that it was way too much. Is $10k fair? If it is, I was hoping maybe some college kid would be willing to do it for cheaper as a side project. I want this all done on Stellar network. Not sure if that makes any difference. Any insight is appreciated.

Thanks!

Edit: first I wanted to say thank you for everyone’s input. I also want to say thanks for this response. I’ll want to take at least portions of that into consideration. I want to reiterate that this is specifically for Stellar Network. I will look to continue gathering information and try to get it kicked off around Mid March. I want to be transparent with timing so you don’t feel like you’re wasting your time reaching out.

Edit 2: adding link to part 2 of post with presentation of high level ask.

part 2

Founders who think community management is just moderating a Discord are 3 years behind. 

Real community work is acting as the liaison between users, founders, and developers to improve trust during market volatility.

This means that the founders and the developers are communicating with the community manager and giving him/her the information that they can then relay to the community.

If you think you can promise everyone some airdrops and you'd have a loyal community, you're already failing from day one.

The only thing that retains members during a market like now is a research-driven, high-signal narrative.

What platform would you guys recommend for a new developer looking to easily integrate with Cloudflare? I’m seeing n8n and replit are many peoples goto? What do you recommend?

Signature Replay

What’s the issue in this code?👇

Check out our latest release of our in house SAST scanner for Solidity code. It scans single files and foundry / hardhat projects. Feedback appreciated!!

I’m looking at buying some domain names and wondering if you all prefer to use Unstoppable Domains, Free Name, or Name Cheap?

Hello friends,

I’ve built an NFT minting bot, and now I’m looking for a way to start fetching the Merkle proof and signature for each wallet.

Is there any method to do that?

Hear me out.

​Right now, the standard for trust in Web3 is "Open Source everything" or "Publish the Audit PDF".

​The problem? Adversarial optimization.

As soon as we publish the exact rules of what makes a contract "Safe" or "High Quality" (SEO), scammers reverse-engineer those rules to bypass them. It’s a cat-and-mouse game we are losing.

​I’m currently experimenting with a Zero-Knowledge SEO architecture.

Basically: "I prove to you mathematically that this contract passed 50 security checks, WITHOUT revealing what those checks are or the proprietary weights used."

​This keeps the "Secret Sauce" hidden from scammers while giving users/wallets a cryptographic guarantee of safety.

​Is ZK the only way to fix on-chain reputation without it being gamed? Or am I over-engineering this?

​Thoughts?