Edge

The Trust Primitive for Autonomous Agents EdgePass gives agents your rules, not your keys.

Live Demo → · npm → · Contract → · Docs →

The best infrastructure is invisible.

⚠️ Network status — read this before you mint anything

edge_pass_v2 is deployed to Sui testnet only. Mainnet cannot mint v2 passes yet — sdk.create() on mainnet throws rather than silently targeting a package that doesn't have the module. Use network: 'testnet' until v2 ships to mainnet.

New passes are always v2. There is no v1 creation path in the 2.x SDK — sdk.create() only ever mints v2.

v1 passes are read-only in the 2.x SDK. If you already hold a v1 pass (minted on mainnet before this release), you can still fetch(), inspect, and revoke() it — you cannot create a new one or spend against one.

edge_pass.move (v1) stays in this repo permanently. It's not dead code left over from before v2 — real v1 passes exist on Sui mainnet today, and the SDK's fetch()/revoke() need that module's functions to keep working for them, indefinitely.

The Problem

Every developer building an autonomous agent hits the same wall:

Option	Approach	Problem
A	Give the agent full wallet access	Catastrophic risk — unlimited exposure
B	Human approves every transaction	Defeats the purpose of automation
C	Build custom policy logic per app	6–8 weeks of infrastructure before any business logic

There is no Option D. No standard primitive for saying:

"This agent can spend up to $300, at these merchants, auto-approve under $50, ask me before anything over $100, and shut down in 48 hours — without ever touching my keys."

Edge is Option D.

What Edge Does

Edge is programmable trust infrastructure. Users define boundaries once. Agents execute freely within them. Unsafe actions escalate automatically.

The atomic unit is the EdgePass — a Sui Move object encoding a complete trust policy:

budget: $300  ·  auto-approve: < $50  ·  escalate: > $100  ·  merchants: [...]  ·  expiry: 48h

Without Edge, every developer builds the same infrastructure from scratch:

❌ Policy engine        who can the agent pay? how much?
❌ Escalation system    when does the human get notified?
❌ Audit trail          what did the agent do? prove it.
❌ Budget tracker       how much is left?
❌ Expiry system        when does authority end?
❌ Revocation           how do I stop it immediately?
❌ On-chain state       where does the policy live?

With Edge:

pnpm add @edge-protocol/sdk

const pass = await sdk.create(EdgePass.fromTemplate('festival', { agent }), signer);
const outcome = await sdk.execute(pass, { merchant, amount }, signer);
// ✅ policy enforced  ·  🗂 audit logged  ·  ✓ done

10 lines of code. 8 weeks of infrastructure. Gone.

🤖 Live AI Agent Demo

The real proof: an AI agent autonomously manages festival purchases within an EdgePass. Claude and Gemini both supported — model agnostic by design.

🧠 Agent:         "Shuttle from parking — $18.50 at Shuttle Express"
⚙️  PolicyEngine:  ✅ auto-approved · under $75 threshold · trusted merchant
⛓  Sui:           execute_transaction · Success · digest verifiable on Suiscan

🧠 Agent:         "Drinks for the group — $45 at Hydra Bar"
⚙️  PolicyEngine:  ✅ auto-approved · within policy limits
⛓  Sui:           execute_transaction · Success

🧠 Agent:         "VIP stage access — $220"
⚙️  PolicyEngine:  ⚠️  escalated · exceeds $150 threshold · agent paused
👤 User:          reviews and approves via modal
⛓  Sui:           execute_transaction · Success

🧠 Agent:         "ShadyTokens.xyz — quick flip"
⚙️  PolicyEngine:  🚫 blocked · merchant not in approved list · <1ms · never submitted

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
4 transactions executed autonomously
$188.50 spent · $311.50 remaining
0 wallet interruptions · every action verified on Suiscan
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📦 SDK Quickstart

npm install @edge-protocol/sdk
pnpm add @edge-protocol/sdk
yarn add @edge-protocol/sdk

Note: BigInt literal syntax (32n) requires TypeScript targeting ES2020+. For ES2019 apps use BigInt(32) * MIST_PER_SUI.

Create a trust boundary

import { EdgePass, MIST_PER_SUI } from '@edge-protocol/sdk';

const sdk = new EdgePass({ network: 'mainnet', enokiApiKey: 'YOUR_KEY' });

const pass = await sdk.create(
  EdgePass.fromTemplate('festival', {
    approvedMerchants: ['0xshuttle...', '0xhydrabar...', '0xstageaccess...'],
    agent: agentAddress,   // spends against the pass — this key signs execute()
    issuer: userAddress,   // grants/revokes — bookkeeping only, never sent on-chain
  }),
  signer
);

Execute autonomously

const outcome = await sdk.execute(pass, {
  merchant:      '0xshuttle...',        // address — must be in approvedMerchants
  merchantLabel: 'Shuttle Express',     // display only, not enforced
  amount:        BigInt(18_500_000_000), // 18.5 SUI in MIST
}, signer);

switch (outcome.status) {
  case 'approved':   console.log('executed:', outcome.digest); break;
  case 'escalated':  await notifyUser(outcome.reason); break;
  case 'blocked':    console.log('policy rejected:', outcome.reason); break;
}

Simulate before executing

// Zero network calls — predict the full session instantly
const plan = sdk.simulate(pass, decisions);
console.log(plan.summary);
// { approvedCount: 4, blockedCount: 1, escalatedCount: 1 }

// Show plan, then execute approved decisions
for (const decision of plan.approved) {
  await sdk.execute(pass, decision.request, signer);
}

Budget intelligence

const status = sdk.budgetStatus(pass);
// { spent, remaining, utilizationPct, isNearLimit, isExhausted }

sdk.isNearLimit(pass)      // true if > 80% spent
sdk.timeRemaining(pass)    // ms until expiry
sdk.isExpiringSoon(pass)   // true if < 1 hour remaining

Wrap any AI tool with policy enforcement

const safePurchase = EdgePass.withPolicy(pass, signer, sdk, async (request) => {
  return await processPayment(request);
});
// blocked/escalated never reach your tool logic
const { outcome, result } = await safePurchase({ merchant, amount });

React hook

import { useEdgePass } from '@edge-protocol/sdk/react';

const { pass, execute, simulate, budgetStatus, loading } = useEdgePass({
  passId, network: 'mainnet', enokiApiKey: KEY, signer,
  autoRefresh: true, // re-fetch after every approved execute
});

Preview without executing

const preview = sdk.validate(pass, { merchant, amount });
// { allowed: boolean, requiresEscalation: boolean, reason: string }

📋 Templates

Template	Budget	Escalate ≥	Max/tx	Expiry
`festival`	300 SUI	50 SUI	200 SUI	48h
`gaming`	50 SUI	2 SUI	10 SUI	4h
`subscription`	200 SUI	20 SUI	50 SUI	30d
`defi`	10,000 SUI	500 SUI	2,000 SUI	7d
`enterprise`	50,000 SUI	1,000 SUI	10,000 SUI	30d

⚙️ How It Works

User creates EdgePass (once)
         │
         ▼
Agent calls sdk.execute() — many times, autonomously
         │
         ├─▶ 🔍 Layer 1 — TypeScript PolicyEngine
         │         Pure TypeScript · no network · <1ms
         │         ├─ active? expired? merchant in allowlist?
         │         ├─ amount within budget? below maxPerTx? within velocity cap?
         │         ├─ amount > escalateAbove? → ⚠️  escalate (agent pauses)
         │         └─ amount ≤ escalateAbove? → ✅ auto-approve
         │         blocked/escalated NEVER touch the chain
         │
         ├─▶ ⚡ Layer 2 — Sui Move Contract (PTB, atomic)
         │         validate → execute → update spent → emit event
         │         if any assertion fails → everything reverts · no partial state
         │         cannot be bypassed · the chain is the source of truth
         │
         └─▶ 🗂 Walrus — immutable audit receipt
                   cryptographically committed · decentralized · permanent

The Two-Layer Security Model

This is Edge's most important architectural decision:

Layer 1 — TypeScript PolicyEngine    <1ms · zero network · developer convenience
Layer 2 — Sui Move Contract          atomic · tamper-proof · cannot be bypassed

Blocked/Escalated → Layer 1 catches them · never submitted to chain · no gas wasted
Approved          → Layer 1 + Layer 2 · both must pass · atomic execution

Layer 1 can be bypassed by a compromised agent runtime. Treat it as a UX convenience and gas optimization — not a security boundary.

Layer 2 cannot be bypassed. The Move contract validates the same five rules independently. A compromised SDK, a compromised agent, a compromised developer machine — none of these can circumvent the contract. The chain enforces the policy.

⚠️ zkLogin Salt Derivation Fix

Most zkLogin implementations call jwtToAddress(jwt, BigInt(0)) — hardcoding the salt as zero. This silently derives the wrong wallet address. Users can log in but their transactions fail or go to the wrong address.

The correct pattern: fetch the unique salt from Enoki before deriving the address.

Edge fixes this. Your users will have the correct wallet address derived from their Google identity.

🔷 Why This Is Only Possible on Sui

🔐 zkLogin — Invisible wallet from Google login. No seed phrase, no MetaMask. On Ethereum: weeks of account abstraction. On Sui: one API call.

⛽ Sponsored Transactions — Users never pay gas. Protocol-level primitive. On Ethereum: deploy and maintain a Paymaster contract. On Sui: one API key.

🧱 Programmable Transaction Blocks — Policy check + execution + state update — one atomic block. If any step fails, everything reverts. No partial state. No race conditions. Native to Sui.

📦 Object Model — EdgePass is a first-class owned object in the user's wallet. An agent executes against it without ever taking ownership. On Ethereum: a contract mapping the developer can modify. On Sui: an object only the owner can touch.

🗂 Walrus — Decentralized audit storage built by the same team as Sui. Byzantine fault-tolerant. Erasure-coded. Not IPFS. Not S3. Native.

You could build a worse version of Edge on Ethereum in months. On Sui it took 10 days — because every primitive was already there.

🔒 Security Model

sdk.validate()  →  TypeScript (instant preview, saves gas on rejections)
sdk.execute()   →  TypeScript + Move contract (atomic, tamper-proof, final)

The Move contract runs six assertions, in order, in the Sui VM before recording any spend:

assert!(pass.active, EPassInactive);
assert!(now <= pass.expires_at_ms, EPassExpired);
assert!(ctx.sender() == pass.agent, ENotAgent);
assert!(pass.approved_merchants.contains(&merchant), EMerchantNotApproved);
assert!(amount <= pass.max_per_transaction, EExceedsMaxPerTransaction);
assert!(pass.velocity_used + 1 <= pass.velocity_cap, EVelocityExceeded);  // skipped when velocity_cap == 0
assert!(pass.spent + amount <= pass.budget, EBudgetExceeded);

Notice escalateAbove isn't in that list — escalation is an off-chain routing decision the SDK's PolicyEngine makes, not a refusal the contract can enforce. The chain only knows hard yes/no answers: active, in-scope, under the per-transaction ceiling, under the velocity cap, under budget. If any assertion fails, the entire transaction reverts. A compromised agent cannot bypass the contract. The chain is the trust boundary.

Competitive Positioning

Edge is the policy layer for the agentic economy. It is not a payment rail.

Solution	Layer	Open Source	Sui Native	simulate()	3-line SDK
Edge Protocol	Policy enforcement	✅	✅	✅	✅
x402 (Coinbase)	Payment rail	✅	❌	❌	❌
ERC-4337	Account abstraction	✅	❌ EVM only	❌	❌
Trust Wallet Agent Kit	Wallet interactions	✅	Partial	❌	❌
Cobo Agentic Wallet	Custody	❌ Enterprise	❌	❌	❌
Skyfire	Identity + settlement	❌	❌	❌	❌

Edge complements x402, it does not compete with it.

x402 answers: how does money move from agent to merchant? Edge answers: should this agent be allowed to spend this money at all?

Edge (policy layer)  →  x402 (payment rail)  →  Settlement
"is this allowed?"       "move the money"

🌐 Use Cases

Vertical	Template	The agent does
🎪 Consumer / Festival	`festival`	Purchases at approved vendors, escalates big spends
🎮 Gaming	`gaming`	In-game micro-purchases within session budget
📦 Subscriptions	`subscription`	Recurring payments to approved services
📈 DeFi / Trading	`defi`	Trades on approved DEXes within risk parameters
🏢 Enterprise / Payroll	`enterprise`	Vendor payments with compliance audit trail
🤖 AI Agent Platforms	any	Any LLM making autonomous spending decisions
🏦 Institutional	`enterprise`	Fireblocks custody + Edge policy = complete stack

⛓ Move Contract

Network:   Sui Mainnet ✅
Package:   0x2ad62ac22e74172cc2e33cbebd7471fb16403831b3bdd1143d51935cefd1bbde

View on Suiscan →

🧪 Testing

cd packages/sdk && pnpm test

📋 PolicyEngine.validate()          11 tests ✓
📋 PolicyEngine helpers              7 tests ✓
📋 EdgePass.fromTemplate()           7 tests ✓
📋 EdgePass.create() validation      2 tests ✓
📋 Constants                         5 tests ✓
📋 Events system                     7 tests ✓

39 passed · 0 failed ✅

🚀 Local Development

git clone https://github.com/fluturecode/edge.git
cd edge && pnpm install

cp apps/web/.env.example apps/web/.env.local
# Add: NEXT_PUBLIC_ENOKI_API_KEY, NEXT_PUBLIC_GOOGLE_CLIENT_ID, ANTHROPIC_API_KEY, GOOGLE_API_KEY

cd apps/web && pnpm dev       # → http://localhost:3000
cd packages/sdk && pnpm test  # → 39 passing
cd packages/sdk && pnpm build

📁 Repository Structure

edge/
├── 📱 apps/web/                     Next.js 15 demo app
│   ├── app/
│   │   ├── page.tsx                 Login — terminal typewriter, zkLogin
│   │   ├── auth/callback/           zkLogin callback, Enoki address derivation
│   │   ├── dashboard/               Main dashboard, EdgePass card
│   │   ├── dashboard/create/        EdgePass creation + PTB preview
│   │   └── dashboard/agent/         🤖 AI agent demo — Claude + Gemini
│   ├── lib/
│   │   ├── signer.ts                zkLogin signer, gas coin resolution
│   │   ├── zklogin.ts               ZK proof generation via Enoki
│   │   ├── walrus.ts                Walrus HTTP API (write/read blobs)
│   │   └── seal.ts                  Seal policy serialization — not yet encrypted, see Roadmap
│   └── app/api/
│       ├── sign/route.ts            Transaction signing + Sui execution
│       ├── zkp/route.ts             ZK proof generation via Enoki
│       └── agent/route.ts           Claude/Gemini API for autonomous decisions
│
├── 📦 packages/sdk/                 @edge-protocol/sdk v2.0.0
│   └── src/
│       ├── core/
│       │   ├── EdgePass.ts             Main API + events + simulate() + withPolicy()
│       │   ├── PolicyEngine.ts         Validation + budget/velocity helpers (37 tests)
│       │   ├── ExecutionEngine.ts      PTB builder + chain execution + fetch (v1 + v2)
│       │   ├── IdempotencyRegistry.ts  Two-phase commit for createWithFireblocks()
│       │   └── withFireblocks.ts       Hardened Fireblocks settlement HOF
│       ├── compliance/
│       │   ├── ComplianceEngine.ts         AML / sanctions / risk screening (6th dimension)
│       │   └── DynamicIdentityBinding.ts   Binds passes to Dynamic enterprise identities
│       ├── audit/
│       │   └── WalrusAudit.ts           Real Walrus mainnet audit log storage
│       ├── react/
│       │   └── index.ts             useEdgePass, useBudgetStatus, useSimulate
│       └── utils/
│           ├── types.ts             All TypeScript types (v1 read-only + v2 create/spend)
│           └── constants.ts         Templates + Package IDs + MIST_PER_SUI
│
└── 📜 contracts/navis/
    └── sources/
        ├── edge_pass.move           v1 — deployed, read-only going forward
        └── edge_pass_v2.move        ✅ current — issuer/agent split, velocity limits

🗺 Roadmap

Phase 1 — Foundation ✅ shipped

✅ zkLogin onboarding — invisible wallet from Google (salt derivation fixed)
✅ EdgePass creation — real Move object on Sui mainnet
✅ PolicyEngine — pure TypeScript, zero network
✅ Two-layer enforcement — TypeScript preview + Move contract source of truth
✅ Human-in-the-loop escalation — agent pauses, awaits human approval via modal
✅ Events system — on('approved'), on('escalated'), on('blocked')
✅ simulate() — predict full session outcomes before touching the chain
✅ Budget helpers — budgetStatus(), isNearLimit(), timeRemaining()
✅ withPolicy() — wrap any AI tool with on-chain enforcement in one line
✅ React hooks — useEdgePass, useBudgetStatus, useSimulate
✅ 🤖 Live AI agent demo — Claude + Gemini, real autonomous decisions
✅ Seal policy serialization — lib/seal.ts turns the policy into a JSON string today; it is plaintext, not encrypted. Real Seal encryption and network storage are both still pending key server deployment
✅ Move contract — deployed to Sui mainnet
✅ SDK on npm — @edge-protocol/sdk

Phase 2 — Trust Layer ✅ shipped

✅ EdgePassV2 — issuer/agent separation: a human grants and revokes, an agent spends, neither can do the other's job
✅ Merchant scope can only narrow, never widen, after minting — not even the issuer can add merchants back
✅ Rolling velocity windows — velocityCap / velocityWindowMs, replaces the old maxTransactionsPerHour idea with an on-chain-enforced rate limit
✅ Hard per-transaction ceiling (maxPerTransaction) — required and enforced on chain, not just advisory
✅ On-chain denials — a blocked outcome can be recorded as an aborted transaction, so the refusal itself is independently verifiable on Suiscan
✅ Approved merchants moved from display names to addresses — enforceable, not just cosmetic
✅ Upgraded to @mysten/sui v2 + @mysten/walrus v1 — unblocked real Walrus storage
✅ Real Walrus blob storage — the demo app writes to public mainnet publishers with a local mock fallback only if every publisher is unreachable
✅ Two-Phase Commit / Idempotency — createWithFireblocks() with retry-safe idempotencyKey
✅ Compliance Engine (6th dimension) — AML / sanctions / risk screening, pluggable providers
✅ Dynamic Identity Binding — bind a pass to a Dynamic enterprise session via JWT

Phase 3 — Protocol & Business 📋 coming

⬜ Managed escalation dashboard — proprietary SaaS approval UI
⬜ On-chain policy signatures — tamper-proof policy commitment
⬜ Multi-token support — USDC, USDT, any Sui coin
⬜ Tool-use architecture — agent decides one transaction at a time, sees results
⬜ Enterprise guardrails — SOC2, SIEM
⬜ Cross-agent coordination — multi-agent quorum execution
⬜ Intent-based policies — natural language → on-chain rules
⬜ Cross-chain EdgePasses

💡 The Analogy

Before Stripe, every developer built their own payment processing. After Stripe, you call stripe.charge().

Edge is stripe.charge() for autonomous agent trust.

🏗 Open-Core Model

PROPRIETARY (future business):
  Managed escalation UI · Enterprise auth · Policy feeds · Compliance exports

OPEN SOURCE (always free):
  TypeScript SDK · Move contracts · Walrus audit parsers · PolicyEngine

The SDK, Move contracts, and PolicyEngine are and will always be open source.

📊 Why It Matters

The agentic economy is already here. Every autonomous agent that touches money needs a trust boundary. Today, every team builds their own. With Edge, every team ships in a day.

The best infrastructure is invisible.

Built with ♥ by @fluturecode for Sui Overflow 2026 — Agentic Web track.

pnpm add @edge-protocol/sdk

GitHub · npm · Sui · MIT License

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
apps/web		apps/web
contracts/navis		contracts/navis
packages/sdk		packages/sdk
.gitignore		.gitignore
HANDOFF.md		HANDOFF.md
LICENSE		LICENSE
README.md		README.md
package.json		package.json
pnpm-lock.yaml		pnpm-lock.yaml
pnpm-workspace.yaml		pnpm-workspace.yaml
tsconfig.json		tsconfig.json

Navigation Menu

Repository files navigation

Edge

⚠️ Network status — read this before you mint anything

The Problem

What Edge Does

🤖 Live AI Agent Demo

📦 SDK Quickstart

Create a trust boundary

Execute autonomously

Simulate before executing

Budget intelligence

Wrap any AI tool with policy enforcement

React hook

Preview without executing

📋 Templates

⚙️ How It Works

The Two-Layer Security Model

⚠️ zkLogin Salt Derivation Fix

🔷 Why This Is Only Possible on Sui

🔒 Security Model

Competitive Positioning

🌐 Use Cases

⛓ Move Contract

🧪 Testing

🚀 Local Development

📁 Repository Structure

🗺 Roadmap

Phase 1 — Foundation ✅ shipped

Phase 2 — Trust Layer ✅ shipped

Phase 3 — Protocol & Business 📋 coming

💡 The Analogy

🏗 Open-Core Model

📊 Why It Matters

About

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

Edge

⚠️ Network status — read this before you mint anything

The Problem

What Edge Does

🤖 Live AI Agent Demo

📦 SDK Quickstart

Create a trust boundary

Execute autonomously

Simulate before executing

Budget intelligence

Wrap any AI tool with policy enforcement

React hook

Preview without executing

📋 Templates

⚙️ How It Works

The Two-Layer Security Model

⚠️ zkLogin Salt Derivation Fix

🔷 Why This Is Only Possible on Sui

🔒 Security Model

Competitive Positioning

🌐 Use Cases

⛓ Move Contract

🧪 Testing

🚀 Local Development

📁 Repository Structure

🗺 Roadmap

Phase 1 — Foundation ✅ shipped

Phase 2 — Trust Layer ✅ shipped

Phase 3 — Protocol & Business 📋 coming

💡 The Analogy

🏗 Open-Core Model

📊 Why It Matters

About

Topics

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages