Universal Arc Kit

Demo

About

Universal App Kit — Clear and Improved Explanation 1. What Is This Project? **Universal App Kit** is a system that lets users interact with apps on another blockchain **without switching networks or bridging tokens**. Instead of moving assets between chains, users send an **intent** (a signed request), and the system executes it on their behalf on the destination chain. In simple terms: > Users stay on their favorite chain, but their actions happen on another chain automatically. --- 2. The Main Problem It Solves In normal multi-chain apps, users must: * Manually change networks * Bridge tokens (slow and risky) * Pay gas on multiple chains * Confirm many transactions * Learn complex UX This creates friction and reduces adoption. 3. The Core Idea: “Intent Forwarding” Instead of directly calling a contract on another chain, users say: “I want this action to happen on Arc.” This request is called an **intent**. The system then: 1. Records the intent on the source chain 2. Detects it with a relayer 3. Executes it on Arc 4. Reports the result The user only signs one transaction. --- ### 4. System Architecture (Three Layers) The system works using three connected parts. A. Source Chain (User Side) Examples: Ethereum, Somnia, Sepolia Contains: * `ArcGateway.sol` Role: * Accepts user transactions * Stores nonce * Emits intent events Users only interact with this contract. No business logic runs here. B. Off-Chain Relayer (Backend Service) A Node.js program that runs continuously. Role: * Listens to blockchain events * Reads new intents * Verifies them * Sends execution transactions to Arc * Retries failures * Stores history This replaces traditional bridges. It moves messages, not tokens. . Arc Chain (Execution Layer) Contains: * `ArcExecutor.sol` * Application contracts Role: * Checks relayer permissions * Executes user intent * Calls target contract * Emits results This is where real logic happens. 5. Main Smart Contracts #### ArcGateway.sol (Source Chain) Purpose: Collect intents What it does: * Receives `forwardIntent()` calls * Increments user nonce * Emits `IntentForwarded` * Keeps no app state It is lightweight and cheap. #### ArcExecutor.sol (Arc Chain) Purpose: Execute intents What it does: * Verifies relayer * Checks nonce * Prevents replay * Calls target contract * Uses try/catch * Emits `IntentExecuted` This is the core security layer. --- #### Counter.sol (Demo App) A normal Solidity contract. It proves that: * Developers don’t need cross-chain code * No special SDK * No messaging logic Apps work like normal. 6. Universal Arc Account Each external wallet maps to one Arc account. So: * MetaMask * Phantom * Coinbase Wallet * Any EVM wallet All become one identity on Arc. Benefits: * Unified profile * Cross-wallet continuity * Account abstraction support * Better UX Users feel like they have one account across chains. 7. Complete Transaction Flow Let’s follow one real action. --- #### Step 1: User Sends Intent User calls: ``` gateway.forwardIntent(targetContract) ``` On Ethereum or Somnia. Gas: ~50k --- #### Step 2: Event Is Emitted Gateway emits: ``` IntentForwarded(user, target, nonce, timestamp) ``` This is stored in blockchain logs. Step 3: Relayer Detects Event Relayer polls: ``` queryFilter(IntentForwarded) ``` Every few seconds. Finds new intent. Step 4: Validation Relayer checks: * Is nonce correct? * Is relayer authorized? * Has this intent run before? Prevents abuse. --- Step 5: Execution on Arc Relayer sends tx: ``` executor.execute(user, target) ``` Relayer pays gas. #### Step 6: Contract Call Executor calls: ``` target.function() ``` Inside try/catch. State updates. Step 7: Result Event Executor emits: ``` IntentExecuted(user, target, success) ``` Frontend updates UI. Total time: 10–30 seconds. 8. Developer Experience For developers, this feels like single-chain development. They write: ```solidity function increment() external { count++; } ``` They do NOT write: * Bridge logic * Messaging code * Relayer logic * Cross-chain verification Everything is abstracted. 9. Frontend and Backend Structure Frontend (`/src`) Handles: * Wallet connection * Intent signing * Status tracking * History display * UI components Important parts: * `IntentForwarder.tsx` → sends intents * `useIntent.ts` → logic hook * `IntentHistory.tsx` → logs Backend (`/web3-hardhat-intent`) Handles: * Smart contracts * Relayer service * Deployment scripts * Tests Includes: * `contracts/` → Solidity * `relayer/` → Node backend * `scripts/` → deploy/setup * `test/` → integration tests 10. Security Design The system includes: 1. Nonce-based replay protection 2. Relayer whitelist 3. On-chain event verification 4. Try/catch execution 5. Full audit trail This prevents: * Double execution * Fake intents * Unauthorized calls * Silent failures --- ### 11. Why This Is Better Than Bridges | Bridges | Universal App Kit | | --------------- | ----------------- | | Moves tokens | Moves intents | | Needs liquidity | No liquidity | | Hack-prone | Lower risk | | Slow | Faster | | Wrapped assets | No wrapping | No locked funds. No pools. No synthetic tokens. 12. Real Use Cases This system is useful for: * Cross-chain dApps * AI agent platforms * Web3 games * DeFi automation * Onboarding new users * Account abstraction systems Any app that wants multi-chain users with single-chain UX. 13. In Very Simple Terms Universal App Kit is: A system that lets users use apps on another blockchain without leaving their current blockchain. It works by: 1. Recording what the user wants 2. Sending it to a relayer 3. Executing it remotely 4. Returning the result All automatically.

How it's made

Here’s a clear, detailed explanation you can use: I built Universal App Kit using a modular Web3 stack that combines smart contracts, an off-chain relayer, and a modern frontend. On the blockchain side, I used Solidity and Hardhat to develop and test the core contracts: ArcGateway for collecting user intents on source chains, ArcExecutor for executing them on Arc, and example application contracts. These contracts are connected through an event-based system, where intents are emitted as logs and later consumed by the relayer. For the backend, I built a Node.js and TypeScript relayer using ethers.js. This service continuously monitors source-chain events, validates nonces and permissions, and submits execution transactions to Arc. It also handles retries, error recovery, and maintains intent history. This layer replaces traditional bridges and is critical for reliability. The frontend is built with Next.js, React, and TypeScript. It connects to wallets using standard Web3 libraries and lets users sign a single transaction to forward intents. Custom React hooks manage wallet state, intent tracking, and UI updates in real time. Environment-based configuration is used to support multiple chains and deployments. Partner technologies like Hardhat, ethers.js, and RPC providers made development and testing much faster by providing stable tooling, local simulations, and reliable network access. They reduced the need to build infrastructure from scratch. One notable “hacky” part of the system is the event-driven cross-chain design. Instead of using complex messaging protocols or bridges, I relied purely on on-chain events and an off-chain listener. This makes the system simpler, cheaper, and easier to debug. Another practical optimization is keeping ArcGateway stateless and lightweight, which minimizes gas costs and reduces attack surface. Overall, the project pieces together Solidity contracts, a TypeScript relayer, and a React frontend into a clean pipeline where user intents flow from one chain to another automatically, giving a multi-chain experience with single-chain simplicity.