Chain abstraction overview update

docs/2.build/1.chain-abstraction/what-is.md

@@ -1,61 +1,129 @@
 ---
 id: what-is
-title: What is Chain Abstraction? 
+title: What is Chain Abstraction?
 ---
-
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
-import {CodeTabs, Language, Github} from "@site/src/components/codetabs"
-
-The idea behind `chain abstraction` is quite simple: **blockchain** technology should be **abstracted away** from the user experience. In other words, people should **not realize** when they are **using a blockchain**, nor **which blockchain** they are using.
+import {CodeTabs, Language, Github} from "@site/src/components/codetabs";
 
 ![img](/docs/assets/welcome-pages/chain-abstraction-landing.png)
 
-To help on this task, NEAR Protocol provides services that allow to **create** and **recover accounts** using **email addresses**, use the account **without acquiring funds**, and **control accounts** in **other chains**. All in the most **seamless** way possible.
+# What is Chain Abstraction?
 
----
+Blockchain development today faces a critical challenge: users need to understand complex blockchain concepts, manage multiple wallets, and deal with different networks just to use basic applications. Chain abstraction solves this by making blockchain technology invisible to end users while preserving all of the underlying benefits.
 
-## Relayers: Cover gas fees
-Allowing users to start using a dApp without having to acquire funds is a powerful tool to increase user adoption. NEAR Protocol provides a service that allows developers to subsidize gas fees for their users.
+## Why Chain Abstraction Matters
 
-This concept, known as "Account Abstraction" in other chains, is a **built-in feature** in NEAR. User can wrap transactions in messages known as **meta-transaction**, that any other account can relay to the network.
+For **developers**, chain abstraction means:
 
-:::tip
-In NEAR the relayers simply attach NEAR to cover gas fees, and pass the transaction to the network. There, the transaction is executed as if the **user had sent it**.
+- Building cross-chain applications without managing multiple blockchain integrations
+- Focusing on application logic instead of blockchain complexity
+- Reaching users regardless of their preferred blockchain network
+
+For **users**, it means:
+
+- Using blockchain applications as easily as traditional web apps
+- No need to understand which blockchain they're interacting with or if they are even using one
+- A seamless experience across different networks and tokens
+
+:::info Example
+Imagine building a digital art marketplace where users can purchase NFTs from different blockchains (Ethereum, Solana, etc.). Without chain abstraction, you'd need to:
+
+- Implement multiple blockchain connections
+- Handle different wallet types
+- Manage cross-chain transfers
+- Build complex UIs to explain blockchain concepts
+
+With chain abstraction, both you and your users just focus on the core experience: browsing and trading art. All blockchain complexity is handled automatically behind the scenes.
 :::
 
-<hr subclass="subsection" />
+## Overview
+
+NEAR's chain abstraction framework consists of three core technologies that work together to create seamless cross-chain experiences:
+
+1. [**Intent / Solver Layer**](#intent--solver-layer): A decentralized system where users express desired outcomes (like "swap Token A for Token B at the best price") without specifying technical details. A network of solvers then competes to fulfill these intents optimally, handling complex cross-chain operations behind the scenes.
+
+2. [**Chain Signatures**](#chain-signatures): Enables NEAR accounts, including smart contracts, to sign and execute transactions on other blockchains (like Bitcoin or Ethereum), allowing cross-chain interactions.
+
+3. [**OmniBridge**](#omnibridge): A trustless multi-chain asset bridge that combines Chain Signatures for cross-chain transaction execution with a verification layer allowing NEAR smart contracts to confirm transactions on foreign chains. This creates a fully trustless system where NEAR can both initiate and verify cross-chain operations.
+
+### Intent / Solver Layer
+
+The Intent / Solver Layer (aka [NEAR Intents](https://pages.near.org/blog/introducing-near-intents/)) is a new type of transaction that allows information, requests, assets, and actions to be exchanged between users, services, and AI agents.
 
-## Multi-chain signatures: One account, multiple chains 
-Currently, users and applications are siloed in different chains. This means that a user needs to create a new account for each chain they want to use. This is not only cumbersome for the user, but also for the developer who needs to maintain different codebases for each chain.
+This represents a paradigm shift in how users and AI agents interact with blockchain networks. Instead of directly executing complex transactions across multiple chains, users simply declare what they want to achieve, and the network determines how to make it happen.
 
-NEAR Protocol provides a multi-chain signature service that allows users to use their NEAR Account to sign transactions in **other chains**. This means that a user can use the same account to interact with **Ethereum**, **Binance Smart Chain**, **Avalanche**, and **NEAR**.
+Here's how it works:
+
+1. **Users/Agents Submit Intents**: Express desired outcomes without specifying the technical details (e.g., "Get the best price for my Bitcoin across all DEXs and CEXs")
+2. **Solver Network Competes**: A decentralized network of solvers (both AI agents and traditional market makers) compete to fulfill these intents optimally
+3. **Cross-Chain Execution**: The best solution is automatically executed, potentially spanning multiple chains and services
+
+:::info Example
+Instead of a user having to:
+
+1. Bridge assets between chains
+2. Find the best trading venues
+3. Execute multiple transactions
+4. Handle different wallet requirements
+
+They simply submit an intent: "Swap Token A for Token B at the best price"
+The Intent Layer handles all complexity across Web2 and Web3 behind the scenes.
+:::
+
+For developers, the Intent Layer provides:
+
+- A unified framework for building cross-chain applications
+- Access to both AI agents and traditional solvers for transaction optimization
+- Built-in liquidity aggregation across DeFi and CeFi
+- Support for complex use cases beyond simple swaps, including:
+  - Cross-chain stablecoin operations
+  - DeFi programmability for non-smart contract assets
+  - Account-based trading (AccountFi)
+  - AI agent interactions and negotiations
 
 :::info
-Multi-chain signatures work by combining **smart contracts** that produce signatures, with indexers that listen for these signatures, and relayers that submit the transactions to other networks. This allows users to hold assets and use applications in **any** network, only needing to have a single NEAR account.
+NEAR Intents are designed to power both traditional DeFi operations and the emerging AI economy, creating a unified transaction framework for Web2 and Web3 interactions.
 :::
 
-<hr subclass="subsection" />
+### Chain Signatures
 
-## Fast-Auth: Email onboarding
-One of the first barriers that new users face when entering the world of Web3 is the need to create a crypto wallet. This generally implies the need to choose a wallet, create and store a recovery phrase, and obtain deposit funds to start using the account.
+Chain Signatures enable NEAR accounts, including smart contracts, to sign and execute transactions across many blockchain protocols. By using [Multi-Party Computation (MPC)](../../1.concepts/abstraction/chain-signatures.md#multi-party-computation-service), this technology allows a single NEAR account to control accounts and assets on external chains like Bitcoin, Ethereum, and Base.
 
-With FastAuth, users only need to provide an email address to create a NEAR account. Using the same email address the user will be able to use their account across applications and devices.
+Key benefits include:
 
-:::warning
-FastAuth is being deprecated, stay tuned for updates
-:::
+- Single Account, Multi-Chain Operations: Manage multiple blockchain interactions from one NEAR account
+- Reduced Development Overhead: Write smart contracts on NEAR that directly sign cross-chain transactions
+- Secure Transaction Signing: Leverage decentralized MPC for trustless signature generation
 
----
+For example, this enables dApps built on NEAR to interact with Bitcoin's UTXO model or Ethereum's account model, powering use cases like cross-chain DeFi protocols, atomic swaps, and NFT marketplaces.
+
+:::tip
+To learn more about Chain Signatures, the concepts, and how to implement it, check these articles:
+
+- [What are Chain Signatures?](../../1.concepts/abstraction/chain-signatures.md)
+- [Getting started with Chain Signatures](chain-signatures/getting-started.md)
+- [Implementing Chain Signatures](chain-signatures/chain-signatures.md)
+
+:::
 
-## Chain Abstraction: The Holistic View
+### OmniBridge
 
-The combination of these services allows to create a **seamless** user experience, in which users can use blockchain-based applications without realizing they are using a blockchain.
+The [OmniBridge](https://github.com/Near-One/omni-bridge) extends NEAR's chain abstraction capabilities by combining two key elements: Chain Signatures for cross-chain transaction execution, and a verification layer that allows NEAR smart contracts to confirm the state and transactions on foreign chains. This creates a trustless bridge where NEAR contracts can both initiate and verify cross-chain operations.
 
-Users will simply login with an email, and a **zero-fund** account will be created for them. No seed phrases to remember, no private keys to safe keep, and no need to acquire funds.
+1. **Chain Signatures Integration**:
+   - NEAR smart contracts can generate derivation addresses on other blockchains
+   - These contracts can directly sign and execute transactions on external chains
 
-Once having their account, apps can ask the user to create meta-transactions and send them to any relayer. The relayer will pass the transaction to the network, attaching NEAR to pay for the execution fees. The transaction will then be executed as if the user had sent it, since the relayer is only there to attach NEAR to the submission.   
+2. **State Verification Layer (Omniprover)**:
+   - Allows NEAR smart contracts to verify the state and transactions on foreign chains
+   - Supports different verification methods based on the target chain (e.g., light client proofs)
+   - Ensures trustless verification of incoming transfers and state changes from external chains
+   - For example, when receiving assets from Ethereum, NEAR contracts can verify the deposit actually occurred
 
-If the user wants to interact with other blockchains, they can use their account to interact with a multi-chain signature relayer, which will relay the transaction to the right network, covering GAS fees.
+3. **Decentralized Relayer Network**:
+   - Open participation model for relayers
+   - Trustless and incentivized system
+   - Ensures efficient transaction processing and state updates across chains
 
-As an example, this would allow users to collect NFTs across different chains, without ever needing to explicitly create an account or acquire crypto. All with just a single email login.
+This architecture creates a fully trustless bridge by combining NEAR's ability to execute transactions on foreign chains (via Chain Signatures) with the capability to independently verify the results of those transactions (via Omniprover).

website/yarn.lock

@@ -5382,9 +5382,9 @@ caniuse-api@^3.0.0:
     lodash.uniq "^4.5.0"
 
 caniuse-lite@^1.0.0, caniuse-lite@^1.0.30001538, caniuse-lite@^1.0.30001565, caniuse-lite@^1.0.30001587, caniuse-lite@^1.0.30001599:
-  version "1.0.30001640"
-  resolved "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001640.tgz"
-  integrity sha512-lA4VMpW0PSUrFnkmVuEKBUovSWKhj7puyCg8StBChgu298N1AtuF1sKWEvfDuimSEDbhlb/KqPKC3fs1HbuQUA==
+  version "1.0.30001692"
+  resolved "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001692.tgz"
+  integrity sha512-A95VKan0kdtrsnMubMKxEKUKImOPSuCpYgxSQBo036P5YYgVIcOYJEgt/txJWqObiRQeISNCfef9nvlQ0vbV7A==
 
 capability@^0.2.5:
   version "0.2.5"