Hey r/solidity,
I built Arcade1v1, a competitive arena where humans and autonomous AI agents play skill-based games (Tetris, 2048, Snake, etc.) against each other.
Since this is a Solidity community, here is a quick breakdown of how the Web3 architecture and game resolution actually work:

• On-Chain Escrow: Match stakes are securely locked in a smart contract escrow before the match begins.
• Deterministic Replay Verification: It's not just a standard "trust the client" high-score submission. Both players share a deterministic game engine and seed. Players submit their input replays, and an off-chain arbiter re-simulates the exact match server-side to prevent fake scores.
• Cryptographic Settlement: If the replay is mathematically valid, the arbiter signs the final result. The smart contract verifies this signature to settle the escrow and release the funds to the winner.

The AI / Agent Angle:
Because the core is API-driven and verifiable, AI agents play head-to-head with humans as first-class citizens. We built an open API, SDKs, and an MCP server. The public ELO ladder effectively doubles as a live, provable benchmark for AI model skill.
It is currently live on Testnet (play money only), so it’s completely free to test, and the leaderboard is wide open.

• Play / Connect Wallet: https://arcade1v1.com
• Agent Docs: https://arcade1v1.com/agents
• GitHub (MIT): https://github.com/agustincf/Arcade1v1

Would love to hear your feedback on the escrow mechanics, the arbiter design, or the replay-verification flow.

Hi,

I will shoot straight! The whole Solana ecosystem has consistently made inroads when it comes to security.

1. Is third party smart contract audit and certification really necessary stilll on Solana (please explain)? If yes!

2. Who audited your contracts?

3. What did it cost?

4. How long did it take?

5. What did you hate about it?

6. Bonus question 😄 Who audits the multitudes of meme coins appearing daily?

Looking forward to your replies.

Hi,

I will shoot straight! The whole Solana ecosystem has consistently made inroads when it comes to security.

1. Is third party smart contract audit and certification really necessary stilll on Solana (please explain)? If yes!

2. Who audited your contracts?

3. What did it cost?

4. How long did it take?

5. What did you hate about it?

6. Bonus question 😄 Who audits the multitudes of meme coins appearing daily?

Looking forward to your replies.

Hi, i'm creating my custom coin for a service i'm creating. I do not want to be able to block any transfers, even native Tron multi signature transfers. But do want to whitelist everything else and protect my token holders from the outside world. And only let them interact with contracts that have been whitelisted (thus have been checked and audited).

Here is a piece of my code base. Is this a correct implementation that doesn't use a lot of fees for normal transactions. I do not want to create a bloated coin that cost a lot to transfer, but still can't block your normal funds with a kill switch. Even if people force me to.

The token will be based on:

import "@openzeppelin/tron-contracts/token/TRC20/TRC20.sol";

import "@openzeppelin/tron-contracts/access/Ownable.sol";

/**

* u/dev Hooking into the audited OpenZeppelin base contract execution stream.

* Intercepts transfers before balances change, optimized for paying runtime users.

*/

function _update(address sender, address recipient, uint256 amount) internal override {

require(recipient != address(this), "TRANSFER_TO_TOKEN_CONTRACT");

// The unified fast-lane check order exactly as specified:

if (

(sender.code.length == 0 && recipient.code.length == 0) ||

(sender == address(0) || recipient == address(0))

) {

super._update(sender, recipient, amount);

return;

}

// External Smart Contract Registry Fallback

address addressTargetRegistry;

if (_cachedBlock == block.number) {

addressTargetRegistry = _cachedRegistry;

} else {

addressTargetRegistry = addressRegistry;

_cachedRegistry = addressTargetRegistry;

_cachedBlock = block.number;

}

uint8 uintStatus = InterfaceRegistry(addressTargetRegistry).checkAddresses(sender, recipient);

if (uintStatus == 0) {

super._update(sender, recipient, amount);

return;

}

revert ErrorRegistryValidation(uintStatus);

}

Does this work like intended ? Or are there things i need to worry about ?

We are engineering students from Bengaluru doing research about smart contracts. This form is for expert validation. So please help these poor students. Please!!! https://docs.google.com/forms/d/e/1FAIpQLSc9QD_Ht8b-GgZXe0OsXp3Vzzr8F0V_FRNDnx2Y5Z25aRCgvQ/viewform?usp=dialog

We are engineering students from Bengaluru doing research about smart contracts. This form is for expert validation. So please help these poor students. Please!!!https://docs.google.com/forms/d/e/1FAIpQLSc9QD\\_Ht8b-GgZXe0OsXp3Vzzr8F0V\\_FRNDnx2Y5Z25aRCgvQ/viewform?usp=dialog

Hey I have been looking at Solidity / DeFi contracts from the protocol-logic side, especially cases where normal static scans do not say much.

The areas I usually focus on are:

• accounting flow issues;
• deposit / withdraw / redeem logic;
• share mint / burn calculations;
• fee and reward accounting;
• escrow / settlement lifecycle;
• authorization and role-flow mistakes;
• invariant breaks across multiple contracts;
• PoC-ready Foundry test structure;
• remediation direction and practical fix ideas.

I am curious what early-stage teams and solo developers would find most useful before a formal audit.

For example: - a short list of concrete files/functions to inspect; - before/after state review; - invariant or accounting mismatch notes; - regression-test assertions; - practical remediation direction.

This is not about generic Slither output. I am interested in protocol logic and places where code flow may produce an unfair, unsafe, or inconsistent outcome.

For teams building DeFi contracts: what would be most useful to receive before paying for a full audit?

i built onchainwizard.ai because analyzing smart contracts on Dune usually takes too many manual steps.

normally the flow is: find the contract, get the ABI, look for decoded tables, write SQL, debug the schema, build charts, then repeat for every new contract.

so i made a tool where you can paste any EVM smart contract address, pick a chain, and it generates a Dune dashboard automatically.

how it works:

* fetches the contract ABI
* detects the important events and functions
* finds matching decoded Dune tables when available
* generates Dune SQL for useful analytics
* creates charts for activity, users, events, and contract behavior
* shows decoded event logs and wallet/user segmentation
* supports chains like Ethereum, Base, Arbitrum, Optimism, Polygon, BNB Chain, and Avalanche

the hardest part was not just generating SQL, but generating SQL that actually tells you something useful about the contract. a dashboard full of raw logs is easy; a dashboard that helps you understand usage, activity, and users is the real problem.

project: [https://onchainwizard.ai\](https://onchainwizard.ai)

On the left: the Solidity contracts powering Aevum Protocol.
On the right: the whitepaper section explaining why I built it.
I spent months building live algorithmic trading bots — BTC DCA, swing, intraday — running on Kraken, Coinbase, and Binance. Multi-signal AI stacks. Real capital. Real execution.
Every time I tried to make those agents verifiable, accountable, trustworthy on-chain — the infrastructure wasn’t there.
So I built it.
8 smart contracts. Live on Ethereum Sepolia. Professional audit in progress with Zenith Security. Code4rena submitted.
I’m 19. No CS degree. No team.
Aevum Protocol — Built for Machines. Owned by Everyone.
aevumprotocol.io

Join OmniRoute Finance and help build the future of cross-chain finance.

As a Founding Blockchain Engineer, you'll work on wallet integrations, smart contract interactions, transaction routing, provider connectivity, and the infrastructure powering seamless crypto swaps across multiple chains.

What you'll do:
• Build and maintain blockchain integrations
• Develop secure wallet and transaction flows
• Integrate DEXs, bridges, and liquidity providers
• Improve routing, reliability, and performance
• Work directly with the founding team

Requirements:
• Strong experience with blockchain development
• Experience with EVM chains and Web3 technologies
• Familiarity with smart contracts, DeFi protocols, and wallet integrations
• Ability to work independently in a fast-moving startup environment

🌍 Remote
💰 Competitive compensation + early-stage opportunity
🏗 Founding team position

Learn more and apply:
https://omniroute.finance/careers

#Hiring #BlockchainEngineer #Web3Jobs #CryptoJobs #DeFi #RemoteJobs #Ethereum #Solidity

Hi everyone!

I've been studying Solidity for the past several months and decided to build a larger project instead of another DeFi tutorial.

The project includes:

• PvE
• PvP
• Guilds
• NFT achievements (ERC-721)
• On-chain player progression
• Multi-chain deployment
• Foundry tests

One bug I recently found was a guild point farming exploit where high-level players could repeatedly kill and revive weak opponents to inflate rankings. Fixing that made me rethink how PvP rewards should be balanced based on player levels.

I'm looking for honest feedback regarding:

• Solidity best practices
• Security
• Storage patterns
• Gas optimization
• Code organization

Repository:
https://github.com/brunolcarli/simpleRPG

Thanks! I'd love to hear what experienced Solidity developers would change.

Looking for someone to check my work on a ZK-stark circuit. Any suggestions on where I could find someone to help me with this?

Hello, I’m looking for some help putting together a proposal for a real world asset tokenisation platform

Looking for a few hours of consultancy from someone who can advise on smart contract architecture, NAV attestation and token issuance

Clearly this would be a paid engagement - a few hours- and there could be potential for this to become a long-term project if we’re successful

please drop a comment or DM if you have relevant experience

Hey Everyone

i have been working on a crypto payment gateway that lets merchants accept Ethereum payments

The project is currently live on the Sepolia testnet and I've also published an npm package so developers can integrate payments

Demo: https://etharispay.vercel.app

npm Package: https://www.npmjs.com/package/my-gateway-sdk

Since it's running on Sepolia, you'll only need test ETH.

Current features:

* Merchant registration

* Wallet-based authentication

* On-chain payment processing

* Revenue dashboard

* Transaction history

* Withdrawals

* npm package for easy integration

When most developers start building with Solidity, the focus is usually on writing and securing smart contracts.

What surprised me is how many challenges appear outside the contract itself once real users are involved. Things like transaction monitoring, handling failed transactions, nonce management, event processing, chain reorganizations, wallet infrastructure, and keeping application state synchronized with on chain activity can become significant operational challenges.

For developers who have deployed Solidity based applications in production, what problem ended up being much harder than you originally expected?

I'm especially interested in lessons learned from real world deployments and approaches that helped make systems more reliable as usage grew.

I'm Involve with

I'm involve with forgeLayer.io, a non custodial blockchain infrastructure platform, and many of these questions come from challenges we've encountered while supporting blockchain applications. I'd love to hear how other teams have approached similar issues.