The AggLayer is redefining what’s possible in a multichain world—not just by connecting chains, but by making cross-chain interactions seamless, secure, and intuitive. At the heart of this transformation lies bridgeAndCall(), a powerful developer primitive that unlocks a new era of user experience (UX) in Web3.
With bridgeAndCall(), developers can abstract away the complexity of blockchain interoperability. Users no longer need to manage multiple wallets, sign redundant transactions, or understand which chain they're interacting with. Instead, they simply use applications—smoothly, instantly, and without friction.
This isn’t just an incremental improvement. It’s a foundational shift toward true chain abstraction, where the backend handles all cross-chain logistics while users enjoy a web-like experience.
👉 Discover how seamless cross-chain execution can transform your next project
What Is bridgeAndCall()?
In simple terms, bridgeAndCall() is a smart contract function that combines two critical operations:
- Bridge: Move assets or data from one chain to another.
- Call: Execute a specific function on the destination chain immediately after the asset arrives.
By merging these actions into a single atomic transaction, bridgeAndCall() eliminates the need for users to manually bridge, wait for confirmation, switch networks, and then interact with a new contract.
Imagine a user wanting to:
- Transfer USDC from Chain A to Chain B,
- Swap it for ETH on a DEX,
- Send the ETH to a gaming chain,
- And mint a rare NFT—all in one click.
With bridgeAndCall(), this entire flow becomes a single transaction, executed seamlessly across multiple chains.
This level of composability was previously unattainable due to fragmented liquidity, inconsistent security models, and poor UX. bridgeAndCall() solves these issues at the protocol layer.
The Anatomy of bridgeAndCall()
bridgeAndCall() is built on top of two foundational primitives within the AggLayer’s unified bridge:
- bridgeAsset() – Transfers tokens between chains.
- bridgeMessage() – Sends arbitrary data (e.g., smart contract instructions).
bridgeAndCall() wraps both functionalities together, enabling developers to send an asset + executable logic in one go.
When a developer uses bridgeAndCall(), they specify:
- The target chain,
- The asset to transfer,
- The destination contract address (callAddress),
- And the encoded function call (callData).
Once initiated, the transaction flows through the AggLayer using a secure, sandboxed execution model powered by pessimistic proofs—a novel zero-knowledge (ZK) mechanism that ensures safety even if some connected chains are malicious.
How bridgeAndCall() Works: Step-by-Step
The magic happens behind the scenes. Here’s how a typical bridgeAndCall() transaction unfolds:
- Initiate Bridging
A unique receiver address is generated on the destination chain. The system callsbridgeAsset()to lock the token on the source chain. - Attach Execution Logic
Alongside the asset,bridgeMessage()carries thecallDataand control parameters needed for post-arrival execution. - Propagate Across AggLayer
The transaction bundle (asset + message) is processed and validated via the unified bridge, secured by ZK proofs. - Claim Asset on Destination Chain
Upon arrival,claimAsset()releases the token to a temporary sandboxed address—initially empty, like an externally owned account (EOA). - Execute the Call
claimMessage()triggers the deployment of a special contract called JumpPoint to the sandbox address. This contract unpacks the message and invokes the specifiedcallAddresswithcallData. - Clean Up
After execution, JumpPoint self-destructs, wiping the sandbox clean—leaving no trace of intermediate state.
If everything succeeds, the intended logic runs exactly as programmed. If an error occurs, assets are safely routed to a fallback address.
The result? A complex cross-chain workflow completed atomically—with no user intervention beyond the initial click.
👉 See how developers are building frictionless dApps with cross-chain logic
Why bridgeAndCall() Matters for Web3
Today’s multichain landscape suffers from two major flaws:
- Fragmented liquidity: Capital is scattered across siloed chains.
- Terrible UX: Users face endless network switches, approvals, and gas fee confusion.
Traditional interoperability solutions have failed to solve this because they treat chains as separate entities that must be manually bridged. bridgeAndCall() flips this model: chains become interoperable by default, with execution abstracted away.
Developers gain unprecedented flexibility:
- Build cross-chain DeFi strategies that rebalance portfolios across chains automatically.
- Create NFT marketplaces where minting occurs on one chain while payment clears on another.
- Design gaming economies where in-game items move between specialized appchains instantly.
Even better: as the AggLayer evolves, these transactions will get faster and cheaper—making advanced cross-chain applications not only possible but practical.
FAQ: Common Questions About bridgeAndCall()
What makes bridgeAndCall() different from regular bridging?
Regular bridges only move assets. bridgeAndCall() moves assets and triggers immediate execution on the destination chain—all in one atomic operation.
Is bridgeAndCall() live yet?
Not yet—but it's actively being developed and tested. L2-to-L2 transactions are already possible in experimental environments, with full rollout expected in the coming months.
How does security work across chains?
Security is enforced through pessimistic proofs, a ZK-based mechanism that assumes each connected chain could be malicious. This ensures the unified bridge remains secure even if individual chains fail.
Can any chain join the AggLayer?
Any chain using compatible technology (like CDK) can integrate with the AggLayer and access bridgeAndCall(). This enables broad interoperability while maintaining sovereignty.
Do users need to know about chains when using bridgeAndCall()?
No. That’s the point—users interact with apps without needing to know which chain powers them. The AggLayer handles routing and execution invisibly.
What happens if a call fails on the destination chain?
Failed executions trigger a fallback mechanism. Assets are returned to a safe address, preventing loss even if logic errors occur mid-flow.
The Future Is Aggregated
The ultimate goal of Web3 isn’t more chains—it’s better experiences. The AggLayer, powered by innovations like bridgeAndCall(), brings us closer to that future.
Soon, developers won’t build on chains—they’ll build across them. Applications will span ecosystems effortlessly, leveraging aggregated liquidity and shared security without compromising performance or usability.
As Kunal Goel put it:
“Too many chains and too many rollups have created two problems for crypto – liquidity is fragmented, and the UX is shit.”
bridgeAndCall() tackles both.
It enables specialized appchains to focus on their core use cases—gaming, social, DeFi—without reinventing infrastructure. Everything else becomes accessible via composable cross-chain calls.
👉 Start exploring unified cross-chain development today
Final Thoughts
bridgeAndCall() isn’t just another tool—it’s a paradigm shift. It transforms the multichain experience from clunky and confusing into something fluid and intuitive.
For developers, it unlocks new design possibilities: cross-chain automations, atomic multi-step workflows, and truly decentralized applications that feel centralized in their simplicity.
For users? It means finally getting the kind of seamless digital experience they expect—no more bridging fatigue, no more network switching hell.
The AggLayer is building the foundation for Web3’s next phase: one where chains don’t compete, they cooperate.
And with bridgeAndCall(), that future is already in motion.