Universal Arc Kit

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.

---

1. 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.

1. 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.

1. 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.

1. 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.

1. 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.

1. Developer Experience

For developers, this feels like single-chain development.

They write:

function increment() external {
    count++;
}

They do NOT write:

• Bridge logic
• Messaging code
• Relayer logic
• Cross-chain verification

Everything is abstracted.

1. 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

1. 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.

1. 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.

1. 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.

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.