Being a dev , I’ve always wish there was a way to send someone an onchain bug report they could actually run. So that’s the idea I’d like to see built on X Layer with @TapeOutWorld.
Say a user deposits 100 units into a vault. They withdraw 30, receive a reward of 10, and the vault reconciles their balance to 80. Then they try to withdraw another 50, and the transaction reverts.
The transaction hash gets the developer to the revert. The next step is figuring out how the vault got there. What failed , Which transactions changed the balance before the withdrawal? Which version of the contract was running? What did the reconciliation update? By the time a second developer picks up the issue, they may have to reconstruct the whole sequence before they can try a fix.
I’d call the tool DSRN, short for Deterministic State Replay Network. The main thing it would produce is a file called a Replay Capsule.
A developer could attach it to an issue so the next person has the starting state, the ordered transactions, the relevant contract versions, and a description of what was expected.
A replay adapter would use that information to run the scenario against the actual contracts in a compatible local environment.
The capsule would also say where its information came from. Maybe the transactions came directly from the chain, the starting state was reconstructed from an earlier block, and a response from an offchain service was unavailable.
The developer opening the capsule can see those gaps and judge how much of the original run they can reproduce.
This is where I’d use TapeOut. The protocol team could encode the vault’s withdrawal rule in a versioned TapeOut circuit. Give the contract and the circuit the same modeled starting state and withdrawal request.
If the circuit says the request should succeed and the balance should end at 30, while the contract reverts and leaves it at 80, the comparison points the developer to the first event where the two results differ. The result would name the circuit version and the rule it checked, so another developer can repeat that comparison against the same reference.
I’d start with one vault on X Layer, one replay adapter, and one scenario that goes all the way from a reported revert to a repeatable test.
After a fix, the team could keep the capsule in CI and run it before each contract upgrade. The reviewer on the next upgrade would have a concrete case to run, with the same inputs and expected behavior that exposed the original bug.
I can see the same workflow helping a lending team investigate a liquidation that happens only after an oracle update and an interest accrual.
They could share the sequence with an auditor or run it against a proposed upgrade. Both people would start with the same case and see exactly which part of the behavior the reference model covers.
If you maintain or audit contracts, what’s one failure you’d want to hand someone as a runnable file?..
Pitching DRSN for the @TapeOutWorld x @XLayerOfficial Idea to be built Onchain..
Little explainer of what DRSN would do 👇
we started building flow(@use_flowapp).. a week ago..
from a simple idea “why make users bridge their assets first before you receive your payment”.
then we found a gem called @near_intents which routes payment across chains. Using near intents to power flow and provisioning users wallet through @out_layer we made the first version of flow available and working on mainnet.
Submitted for the @NEARProtocol Hackathon and built for #NEARHackathon..
We’ve built the mvp, now we’re making flow available to users all over anywhere..
starting from flow earn where users deposit near and earn yield through LiNEAR or Deposit USDC on Near into Burrow finance to earn yield on a given APY..
what did we ship this week?
- improved AI: Flow ai is now capable of creating your payment links and sending assets from your flow wallet with just a single confirmation..
- Cashflow Insights: You can now monitor your cashflow on your flow wallet directly from your app.. check the month your spent more and the month you made more..
- Language: we improved language for user who don’t read English..
- Live Transaction Timeline: Track how your money moves till it settles onchain..
- Flow ID: users get unique flow id for sending assets to another flow user..
And that’s it for this week shipping.. More soon.
Flow is not stopping here till everyone starts using it as their go to payment app..
Use flow…
What did we ship this week in flow?
From building flow for the @NEARProtocol Hackathon. We’ve pushed further to turn flow into a consumer first payment app..
Here’s what’s new…
You should never have to tell a customer 'sorry, I only accept this token on this specific network' to get paid online. That single piece of friction is why we built FLOW, a multi-chain wallet and payment link platform built on NEAR.
When someone asks to get paid in crypto, the payment usually turns into a coordination problem before any value moves. If I hold SOL on Solana and you want NEAR on @NEARProtocol , one of us has to deal with bridges, swap routes, gas tokens, and wrong-chain risk just to settle one transfer.
Most payment tools force the sender and recipient onto the same blockchain. We built FLOW to reverse that constraint. The recipient decides what asset and network they want to receive. The sender chooses a supported asset they already hold on their own chain. The infrastructure coordinates the route and settlement between them.
People should be able to send, request, and receive digital payments without organizing their workflow around blockchain boundaries. Someone sending an invoice or splitting an expense should not have to tell the payer which DEX to open or which gas token to buy first. That gap between what blockchain rails can do and how ordinary payment tools work is why we started building FLOW.
Here is what FLOW offers today around one account:
Automatic multi-chain wallet setup: Sign in with Google or an email code, and FLOW provisions permanent account-linked wallet addresses across NEAR, Solana, Ethereum, and Base (sharing one EVM address across Ethereum and Base while keeping network state distinct).
Shareable Payment Links with guest checkout: Create a request specifying the exact asset and amount you want to receive, such as 150 NEAR on NEAR Protocol, and share a link. Your sender opens it in any browser with no FLOW account required, chooses from supported tokens across external chains (like SOL on Solana), and gets a live deposit address and quote.
Once they send funds, FLOW settles the requested asset directly into your wallet.
Direct Receive and instant Convert: View verified same-network deposit addresses filtered by network capabilities, move assets directly on-chain, and convert between supported holdings with live quotes updating as you type.
Activity tracking and Flow AI: Review transaction history backed by on-chain verification, and ask plain-language questions inside the wallet to check balances, confirm recent settlements, or inspect routes.
Choosing NEAR as the core foundation was a technical decision rather than a branding choice. Two parts of the NEAR stack made this workflow practical without building brittle custom bridges for every asset pair.
First, @near_intents and the 1Click protocol power our cross-chain quote discovery and exact-output routing (EXACT_OUTPUT). When a payer chooses SOL on Solana to settle a 150 NEAR payment link, 1Click resolves the route, signed quote terms, and origin-chain deposit instructions, while FLOW tracks deadlines, refund rules, and delivery.
Second, @out_layer and NEAR policy sponsorship handle automated multi-chain custody provisioning. Onboarding a user into four networks at once usually breaks down at wallet setup and permissions. FLOW registers wallets through OutLayer while funding and enforcing on-chain custody policies on NEAR via store_wallet_policy with default-deny rules, rejecting unrestricted wallets (policy: "none") before activation.
Chain abstraction only matters to users when it reaches checkout. Pairing intent-based cross-chain liquidity with policy-backed wallet provisioning shows a practical model where networks remain an implementation detail instead of a burden on the sender or recipient.
Right now, FLOW combines multi-chain custody across NEAR, Solana, Ethereum, and Base with cross-chain Payment Links powered by NEAR Intents. Next, our focus is tightening live mainnet settlement monitoring, expanding direct execution guardrails, and opening payment links up for broader merchant and developer workflows.
If you are building around NEAR Intents, chain abstraction, or crypto payments, we would appreciate your feedback on the architecture and user flow.
Shipping some final updates and tightening security before letting flow go live to users..
Building for the @NEARProtocol Hackathon.. Building Longterm
Demo soon #NEARHackathon..
Most AI agent demos skip the hardest question in crypto: what happens when an autonomous agent with a wallet hallucinates or encounters a prompt injection?
It only takes one prompt injection hidden inside untrusted web content, or one hallucinated floating-point decimal, to drain a balance. But the alternative is equally broken: requiring a human to manually click and approve every single micro-transaction for API queries, RPC calls, or compute completely destroys the point of an autonomous agent.
I built Mandate for the #NEARHackathon to solve this problem.
Mandate is a deterministic spending firewall and execution runtime for autonomous AI agents on NEAR Protocol and OutLayer Intel SGX hardware TEE enclaves.
The core architecture follows a simple rule: AI proposes. Mandate enforces. The user controls. OutLayer executes.
Here is how it works under the hood.
Instead of handing private keys to an LLM or storing them in environment variables where they can leak, keys never leave an @out_layer Intel SGX hardware enclave. The agent runs in its normal software runtime with zero key access.
When an agent needs to pay for resources or settle a task, it proposes a financial intent. That proposal is immediately intercepted by Mandate's policy engine.
The engine does not ask an LLM for permission. It runs pure, deterministic TypeScript checks with exact integer yoctoNEAR math using BigInt. It evaluates:
Mandate active status and expiration windows.
Provider-side TEE policy synchronization.
Explicit recipient allowlists.
Per-transaction ceilings.
Total budget headroom and Compare-And-Swap (CAS) atomic reservations in PostgreSQL.
Single-use idempotency guards to eliminate duplicate spends.
If any check fails, such as an unverified recipient or an amount that breaches the limit, the transaction is rejected instantly on the server. Zero network traffic reaches the hardware enclave, and zero funds leave the vault.
If all policy checks pass, Mandate checks the user's Human Approval Threshold.
Small operational payments below the threshold execute autonomously in seconds. Operations exceeding the threshold pause safely, creating a pending review ticket in the user's dashboard.
When an operation is cleared for execution, Mandate mints an HMAC-SHA256 sealed capability ticket bound to the exact execution parameters with a strict 60-second expiration window.
The OutLayer Intel SGX enclave inspects this capability ticket. If the ticket signature or parameters do not match, the enclave refuses to sign. If valid, the enclave signs the transaction in hardware memory and broadcasts it to NEAR Testnet. Once broadcast, Mandate independently reconciles the receipt directly against NEAR RPC and commits the record to an immutable, SHA-256 hash-chained audit ledger.
Everything described here is fully built, tested, and running on NEAR Testnet:
Live web app: https://t.co/m0a6ujRah2
Codebase & test suites: https://t.co/ye5HxYiwFT
Onchain testnet proof: https://t.co/GaGodOMKvu
Autonomous agents should be able to execute financial workflows safely. Deterministic boundaries and hardware enclave custody make that possible without handing over the keys.
what happens when a payer has Usdc on Solana chain but the recipient needs Near On Near Protocol?
That’s what’s flow is for.. Bring any asset from any chain to pay with.
Flow settles exactly what the recipient needs not what you send..
Building for the #NEARHacakthon
Giving an AI agent raw private keys is an existential risk no treasury can take.
Yet keeping treasury operations 100% manual is a recipe for capital erosion, slow execution, and human error.
This is the dilemma every modern digital-asset business faces.
Here is how MOI solves it through deterministic Spending Limits.
Across emerging markets and digital-first businesses, companies earn in local currency (like cNGN) but settle global expenses, SaaS, and vendors in USD.
Managing this manually means:
• Constant exposure to overnight FX volatility and currency erosion
• Manual calculation of reserve rebalancing
• Slow execution through high-slippage liquidity pools
• Friction across invoice settlement and ledger reconciliation
The obvious future is autonomous finance: letting software and AI agents monitor balances, rebalance portfolios, and execute transactions at machine speed.
The roadblock?
LLMs hallucinate. Prompts get injected. An agent with raw, unrestricted keys can drain an entire treasury in a single transaction.
In MOI, an agent never touches raw funds, and an AI never executes financial transactions based on natural language alone.
Instead, the treasury owner defines an immutable, cryptographic Spending Mandate.
A Mandate is not a prompt. It is a deterministic policy contract that sits directly between the agent and the blockchain. It establishes mathematical boundaries on what software is allowed to touch:
• Per-Transaction Hard Caps: Strict maximums on any single trade (e.g., max 500 USD₮)
• 24-Hour Velocity Limits: Rolling daily ceilings preventing velocity attacks (e.g., max 2,500 USD₮/day)
• Reserve Floors: Non-negotiable minimum balances an agent cannot draw below
• Allowed Currency Corridors: Whitelisted execution pairs (e.g., cNGN - USD₮ on Celo Mainnet)
• Mandatory First-Trade Owner Approval: An agent cannot execute its first trade in any corridor without explicit owner authorization
• Instant Emergency Kill Switch: One-click global freeze that halts all agent execution permissions instantly
MOI separates intelligence from execution authority:
1. Non-Custodial Ownership: Your treasury remains in your non-custodial wallet. Funds never enter a custodial pool.
2. The 18-Rule Deterministic Policy Engine: When an agent proposes a rebalance or payment, the proposal is intercepted by MOI's engine. It must clear 18 deterministic checks (R01–R18) covering asset validity, velocity, slippage caps, and reserve floors. If even one rule fails, the transaction is rejected before reaching the chain.
Moi introduces Three Risk Modes:
• Monitor Only: Agent observes balances and calculates drift, but has zero signing capability.
• Approval Required: Agent prepares trades and requests owner signature.
• Autonomous Mode: Agent executes autonomously strictly within the mandate limits.
MOI is a live infrastructure operating on Celo Mainnet:
• Real-Time Drift Detection: Set target portfolio weights (e.g., 70% USD₮ / 30% cNGN).
• MOI monitors reserve drift in real time and proposes rebalancing the moment thresholds are breached.
• Institutional FX Liquidity: When rebalancing, MOI routes through Textile FX v2 Request-for-Quote (RFQ) liquidity, securing firm institutional pricing with 0.00% slippage.
Why build MOI?..
• Traditional Multisigs are Secure, but completely manual. Every routine rebalance or micro-payment requires human coordination and gas overhead.
• Raw Agent Wallets: Autonomous, but dangerous. Zero deterministic boundary between code and total capital loss.
• MOI: Autonomous treasury operations, strictly within your rules.
You set the limits. Software does the work. Your capital stays protected.
Autonomous treasury operations. Within your rules.
Day 4: Building Mandate In public:
How do you give an AI agent the ability to spend money without giving it unrestricted control over your funds?
That’s what we’re building with Mandate.
The financial control plane for AI agents. It gives users a way to assign spending authority to their agents, define exactly what they’re allowed to do, and enforce those rules before money moves.
The problem with simply connecting an agent to a wallet is that access and authority become too closely tied together.
An agent might need funds to complete a task, but that doesn’t mean it should have unlimited permission to spend them, choose any recipient or operate outside the user’s intended budget.
Mandate introduces a policy layer between an agent’s decisions and financial execution.
Here’s how it works:
You create an agent and give it a dedicated wallet. You then create a mandate that defines its financial authority.
That includes:
Total spending budget.
Maximum amount per transaction.
Approved recipients and categories.
Approval thresholds for transactions that require human authorization.
Mandate expiry and other spending conditions.
When an agent needs to make a payment, Mandate evaluates the request against the rules the user has defined.
It checks whether the transaction is permitted, whether sufficient budget is available, and whether additional approval is required.
Approved spending goes through a controlled execution process, with budget reservations and safeguards designed to prevent duplicate or unauthorized execution.
OutLayer handles the protected execution, while NEAR Testnet provides the transaction network where activity can be confirmed and verified.
Users can also follow their agents’ financial activity, including transaction history and execution status.
We’re not building another AI wallet or simply giving agents access to blockchain transactions.
We’re separating the ability to propose a financial action from the authority to approve and execute it.
An agent can decide that a payment is needed. But it doesn’t get to decide whether that payment is within the authority granted to it.
That authority belongs to the user.
The distinction matters because autonomous agents need more than wallets. They need enforceable boundaries, spending accountability and a clear relationship between what they are allowed to do and what they actually execute.
That’s the principle behind Mandate:
AI proposes. Mandate enforces. The user controls. OutLayer executes.
We’ve deployed the Mandate Private Beta on NEAR Testnet for testing.
Giving it access to limited number of users to start exploring the platform, connect your wallet, create agents, configure spending mandates and experience the controlled execution workflow.
We’re starting with the financial control layer that autonomous agents need today. As Mandate evolves, we’ll expand its capabilities and integrations, but the foundation remains the same:
Give agents the freedom to work, without giving up control of your money.
Mandate is live on Testnet.
A little video of what mandate does… More soon….👇