DarkyJack · Web3

Fresh start. Diving deeper into Web3 & crypto, learning in public, joining ambassador programs, and sharing honest thoughts along the way.

@zacodil self-custody is not a binary concept the important question is where the trust assumptions actually sit many systems look self-custodial on the surface while relying on shared infrastructure layers underneath

Gnosis Pay's self-custody runs through a middle layer, and that middle layer is what just got hacked, across users at once. Your funds sit in your own Safe smart account (a smart-contract wallet) on Gnosis Chain. To run a card off it, Gnosis Pay bolts a permissioned module layer in front of your wallet: a delay module that parks your own withdrawals in a queue for about 3 minutes so a stolen key can be cancelled in time, plus a spender role that can move a capped amount to the card's settlement address. That shared layer, the part Gnosis provisions, is what broke. Not your key. Today an attacker could push transactions into those queues, and it hit most users at once. One stolen key can't do that to thousands of independent Safes. A shared component with enqueue rights over all of them can. I checked the delay contract: after the cooldown, anyone can execute the next queued tx, strictly first-in-first-out, and the owner can only skip forward, never jump ahead. So once the attacker's drain is in your queue, you can't out-race it. Your keys never moved and Gnosis can't spend your principal. That's true, and it's the wrong thing to feel safe about. What protects users right now is not the contract. It's Gnosis pausing the bridge and covering losses from its own treasury. Self-custody held. The permissioned layer that makes the card usable did not, for most users at once. That layer is the product, and it's the single point of failure the "fully self-custodial" page never mentions.

@NEARProtocol the interesting shift is that privacy is no longer being discussed as a separate category it’s becoming part of the user experience itself payments, swaps, AI inference, treasury operations people simply expect confidentiality to be there

@NEARProtocol @AskVenice privacy used to be a niche feature now it’s becoming a requirement for both finance and AI users don’t want every payment, prompt, balance, or interaction exposed by default the projects growing fastest are the ones making confidentiality invisible and easy to use

Privacy is defining the next generation of apps, both financial and agentic. Privacy-first AI platform @AskVenice ($VVV) has 3M+ users and is growing fast. NEAR is the infrastructure making it possible, from private inference to confidential execution. How NEAR powers Venice 🧵

@NEARProtocol network effects for privacy are massively underrated

Privacy is becoming the default expectation. And increasingly, the default experience on near.com. Turns out, confidentiality on near.com is ridiculously seamless.

@zacodil the important shift is that privacy is moving from “hide everything” to selective disclosure public verification where needed confidential execution where it matters that’s much closer to how real financial systems actually operate

The confidential shard is the main reason the market is paying attention to NEAR again. It lets a trading desk move size without other desks seeing it. A startup run payroll on a public chain without leaking salaries. A DeFi vault publish its NAV while keeping the strategy hidden. An AI agent run prompts that never reach the model provider in plaintext. Or at the consumer level: you can pay for coffee without the cafe pulling up every transaction you've ever made, and without whoever was watching your wallet learning where you eat lunch. All on one chain. Same wallet. Public verification still intact when you want it. Let me walk through how the mechanism works and why nobody else has shipped this. The shard is operated by a decentralized set of independent permissioned validators, but the execution runs inside encrypted hardware enclaves (TEEs). Validators process transactions as if they were running normal code, except they have no visibility into the data being processed. Nothing about the transaction makes it onto the public ledger. Not balances. Not order details. Not the address on the other side. A TEE-based bridge handles transfers between the private shard and NEAR mainnet. You still need to see your own balance somehow. That's what viewing keys are for. A private key the account holder keeps locally, used to decrypt their own state. Indexers can't read it, block explorers can't read it, and even the validators that just processed the transaction can't read it. The UX is a switch. Open near-dot-com, flip from your Main Account to your Confidential Account, move funds in. Send or swap from there. When you want it back on the public side, unshield. No ZK ceremony, no state sync, no separate wallet. Cross-chain isn't broken. Last week Alex Shevchenko sent 0.1 ETH from his NEAR account directly to the Ethereum Foundation. The EF received the ETH on Ethereum. No chain recorded who sent it. He said it felt like sending money in Revolut. For institutions there's a second piece. Optional selective disclosure. The validators don't see anything, but the account holder can hand a viewing key to an auditor. Compliance without broadcasting to the public chain. That has been the missing piece blocking serious money from entering DeFi. Privacy on a public blockchain used to mean leaving it. NEAR made it a switch on the account you already have.

@NEARProtocol @CryptoHayes @ilblackdragon once users experience confidential swaps, going fully public again starts feeling outdated

Who powers secure AI agents, confidential transactions, and intent-based execution at scale? Arthur Hayes (@CryptoHayes) and NEAR Co-Founder Illia Polosukhin (@ilblackdragon) just laid out how the privacy revolution runs on NEAR. 👇

@zacodil the interesting part is that NEAR didn’t abandon the original thesis it extended it the runtime, sharding, async architecture — all of it became the foundation for confidential execution, intents, and AI infrastructure

NEAR's original thesis didn't work. The pivot is brilliant. The original bet: build the best L1 runtime. Async Rust, WASM, sharded by design. Attract developers, get killer apps, win on technical merit. I joined for this thesis. What actually happened: DeFi capital stayed locked on Ethereum. New developers landed on Solana - Phantom wallet, memecoin culture, consumer DEX UX. NEAR ended up squeezed between two: better technology than both, market share from neither. "Best runtime" lost to network effects on one side and consumer wedge on the other. The pivot: stop competing for developers. Make crypto work with whatever they already use. The tech stack is purpose-built for this: - NEAR Intents: user signs one intent on NEAR ("swap X for Y, settle on chain Z"), solvers compete to execute it across whatever chains have the liquidity. No NEAR TVL needed. - MPC Chain Signatures: your NEAR account controls keys on Ethereum, Solana, BTC, anywhere. One identity, every chain. No new wallets, no bridge contracts. - Confidential Intents: same mechanism, execution inside hardware-secured enclaves. Sender invisible to the public chain. Already 42% of Intents volume - private execution is the default for nearly half of all activity. - NEAR AI agents: autonomous programs that compose all of the above. Result: a user opens existing wallet, sends ETH on Ethereum, USDC on Solana, BTC on Bitcoin from one balance. Buys ZEC and shields it in the same flow. Doesn't know NEAR is underneath, doesn't care. For privacy on existing chains, toggle one switch. Same wallet, no new tooling, transactions invisible to the public chain. The economics make it structurally better. Every other L1 burned hundreds of millions in treasury bootstrapping TVL through boosted APRs on DEX forks. Mercenary capital came in, incentives ended, TVL left. NEAR Intents needs zero TVL on NEAR - solvers route through multiple CEXes and DEXes, wherever the liquidity already lives. NEAR doesn't compete for liquidity, it connects to it. The original infrastructure investments map perfectly to what chain abstraction needs: sharded execution handles solver volume, WASM gives solver flexibility, MPC keys sign across any chain, TEE infrastructure delivers privacy. The runtime that "failed" turned out to be perfect for orchestration. NEAR didn't double down on the losing bet, and didn't quit. It pivoted - and caught every major narrative crypto is running on right now: - Chain abstraction (one identity across 35+ chains) - Privacy (the only cross-chain confidential execution layer at scale - including native ZEC shielding without leaving the wallet) - AI agents (founder who co-authored the Transformer paper, autonomous programs that transact privately across chains) - Stablecoin payments (real cross-chain flows, not VC slideware) Getting one narrative right is luck. Capturing four at once means the infrastructure was built before the narratives existed. Most protocols can't pivot. NEAR pivoted and won on multiple fronts simultaneously.

privacy in crypto is shifting from a niche feature to core infrastructure: payments swaps AI inference treasury management users increasingly expect confidentiality by default, not as an extra mode hidden somewhere in settings

@NEARProtocol privacy shouldn’t be a premium feature for wealthy users only

Private banking locks “discreet” financial services behind a $50K+ minimum. Confidential payments on near.com cost a chain fee. No gatekeepers. No wealth requirement. No exposed source wallet. NEAR makes confidentiality accessible to everyone.

@zacodil the important part is that the thesis is no longer speculative the infrastructure, confidential flows, intents volume, AI stack — most of it is already live and being used

NEAR becomes net deflationary at $175M daily Intents volume. That's just step one of the 20-40x case from Sal Ternullo (A100x Ventures) on Bankless: > Structural change. NEAR tokens fully unlocked, no more vesting cliffs. First time the chart isn't fighting mechanical sell pressure. > Buyback breakeven. NEAR Intents has processed $20B cumulative volume. At $175M daily, buyback pressure through Intents alone exceeds total protocol issuance. And that's BEFORE Ironclaw and NearAI value accrual mechanics. > The numbers. Fair value today: $4-6B FDV from Intents alone (2-4x from current). AI agents through Ironclaw + NearAI add the force multiplier. NEAR positioned as the leader for agentic interactions at scale. The math is here. How high does NEAR go now? Drop your number in replies.

@NEARProtocol @near_intents crypto spent years making everything transparent now the shift is making privacy usable not hiding from the system — just normal financial behavior without exposing every wallet, balance, and transfer publicly confidential cross-chain flows feel like the next major UX layer

Zcash DeFi (ZeFi) - Powered by @near_intents 👇

@NEARProtocol privacy should work with users, not against them confidential flows becoming normal is a big step

Move funds when you want. $68M moved confidentially out of near.com last month. Privacy is meant to work with you, not keep you trapped.

The next crypto products won’t win only by adding more features. They’ll win by making complex things feel simple: cross-chain movement, wallet flows, privacy, execution, and security. That’s why UX + confidentiality matter so much for the next stage of onchain adoption.

@NEARProtocol stablecoin fragmentation is mostly invisible until you actually try to move value across ecosystems

Stablecoins are becoming the corporate world’s preferred internet-native payment rail. The problem: everyone is choosing different ones. NEAR Intents removes the fragmentation. Send one stablecoin. Receive another. Instantly. Globally. Friction disappears.

@mila_arty manual DeFi looks like control but often it’s just more places to make execution mistakes the real upgrade is automation with risk boundaries

Most DeFi users still manage everything manually. Chasing APYs. Moving liquidity between protocols. Compounding rewards. Monitoring risk position by position. Manual management creates execution risk: missed rebalances, idle capital, emotional decisions, and fragmented exposure across protocols.

@NEARProtocol the real shift is when privacy stops feeling like a separate feature and starts becoming the default path for normal activity

Last month on near.com: 209M total activity. 87M of it confidential. The default is shifting.

@near_intents @NEARProtocol @near_ai 209M total activity. 87M confidential. The interesting part is not just that privacy is being added. It’s that confidential execution is becoming part of normal user flow.

balloonmorphism trend today, so naturally we dragged @NEARProtocol, @near_ai and NEAR Intents into it 🎈

Public-by-default made DeFi transparent. But it also made every serious strategy observable. The next step is not hiding everything. It is selective disclosure: privacy for execution, transparency for verification.

@NEARProtocol community becomes much more powerful when it turns into coordinated execution

The NEAR Legion is turning a global community into coordinated action for the AI era. 3K+ members across 125+ countries building, testing, educating, and growing the ecosystem together. Join the Legion. Start a City Node. Help shape private AI on NEAR. nearlegion.com

@zacodil public-by-default made DeFi transparent but it also made every serious strategy observable selective disclosure feels like the missing primitive

Personally, I'm waiting for confidential DeFi on NEAR. Public-by-default isn't a feature of DeFi - it's a limitation of current L1 architecture. Real finance runs on selective disclosure. Hedge funds don't publish their books. Market makers don't broadcast inventory. Treasuries don't expose flows. Privacy on positions, transparency on rules - that's how every working economy operates. Public chains today force the opposite tradeoff. Every position, every strategy, every counterparty visible to anyone watching the mempool. That works for retail speculation. It's why no real business runs at scale onchain. NEAR's confidential shards add the missing layer. The smart contract code stays public and auditable. The state it operates on is private - only the account owner holds the viewing keys. That ownership matters. Users can read their own data and selectively share that visibility with auditors, accountants, analytics services, or regulators they trust. The user controls disclosure, not the chain. Validators verify execution through hardware attestation without seeing user data. Protocol rules stay public; user activity stays private until the user chooses otherwise. Within the confidential shard, smart contracts can call each other in a single transaction at sub-second speed. A confidential AMM can read a lending pool's price and execute a swap in one atomic operation. ZK rollup approaches break here - private-to-public calls happen asynchronously, with the public part executing in a future block, so a confidential AMM literally cannot atomically read a public oracle. This isn't a retreat from decentralization. It's what decentralization looks like when it scales beyond retail speculation. Protocol rules stay public and verifiable. What stays private is who's doing what under those rules - and the user decides who, if anyone, gets to see. The alternatives each pay a different price: - Public L1s (Ethereum, Solana) leak by design - ZK rollups break atomic composability between private and public state; proof generation latency makes interactive DeFi impractical - FHE-based approaches (Zama, Fhenix) compose data freely but are 1000-10000x slower than plain EVM today - Custodial alternatives aren't DeFi NEAR's confidential shards optimize for what matters for adoption: atomic, low-latency composability inside a confidential environment, with public smart contract verifiability, and user-controlled disclosure. That's the combination other architectures can't match in 2026.