🎯 ARC-ID Predict Market {STILL UPDATE}

Deployed Contracts

Features

Network

📁 Project Structure

arc-network/
├── circle-entity-secret/ # Tutorial 1 — Entity Secret & Dev-Controlled Wallets
├── hello-arc/ # Tutorial 2 — Deploy & interact with smart contracts
├── erc8004-quickstart/ # Tutorial 3 — Register an AI agent (ERC-8004)
├── monitor-events/ # Tutorial 4 — Live on-chain event monitoring
├── deploy-contracts/ # Tutorial 5 & 6 — Deploy & interact with ERC tokens
├── app-kit-bridge/ # Tutorial 7 — Bridge USDC via CCTP V2
├── package.json
├── tsconfig.json
└── README.md

🛠 Tech Stack

🌐 Network Info

✅ Prerequisites

⚡ Quick Start

# Clone the repo
git clone https://github.com/frankxeth/arc-network.git
cd arc-network
# Install root dependencies
npm install
# Navigate to any tutorial and run it
cd circle-entity-secret
npm start

Tutorial 1 — Circle Entity Secret & Dev-Controlled Wallet

What You'll Learn

Setup

cd circle-entity-secret
npm install

CIRCLE_API_KEY=your_circle_api_key
CIRCLE_ENTITY_SECRET=your_entity_secret

How to Get Your Entity Secret

Key Code — generate.mjs

import { generateEntitySecret } from "@circle-fin/developer-controlled-wallets";
const secret = generateEntitySecret();
console.log("Your Entity Secret:", secret);

Key Code — create-wallet.mjs

import { initiateDeveloperControlledWalletsClient } from "@circle-fin/developer-controlled-wallets";
const client = initiateDeveloperControlledWalletsClient({
 apiKey: process.env.CIRCLE_API_KEY,
 entitySecret: process.env.CIRCLE_ENTITY_SECRET,
});
// Step 1: Create a Wallet Set
const walletSet = await client.createWalletSet({ name: "Prass Arc WalletSet" });
console.log("✅ Wallet Set ID:", walletSet.data?.walletSet?.id);
// Step 2: Create a Wallet on Arc Testnet (SCA type)
const wallet = await client.createWallets({
 blockchains: ["ARC-TESTNET"],
 count: 1,
 walletSetId: walletSet.data?.walletSet?.id,
 accountType: "SCA",
});
console.log("✅ Wallet Address:", wallet.data?.wallets?.[0]?.address);

Key Code — transfer.mjs

// Send 1 USDC from Wallet A to Wallet B
const tx = await client.createTransaction({
 walletId: WALLET_A_ID,
 tokenId: USDC_TOKEN_ID,
 destinationAddress: WALLET_B_ADDRESS,
 amounts: ["1"],
 fee: { type: "level", config: { feeLevel: "MEDIUM" } },
});
// Poll for completion
for (let i = 0; i < 30; i++) {
 await new Promise(r => setTimeout(r, 3000));
 const status = await client.getTransaction({ id: tx.data?.id });
 const state = status.data?.transaction?.state;
 console.log(`Status: ${state}`);
 if (state === "COMPLETE") {
 console.log("🎉 Transfer complete! Tx Hash:", status.data?.transaction?.txHash);
 break;
 }
}

Run

node generate.mjs # generate entity secret
node register.mjs # register it to Circle Console
node create-wallet.mjs # create wallets
node transfer.mjs # transfer USDC

Tutorial 2 — Deploy Smart Contract (HelloArchitect)

What You'll Learn

Setup

cd hello-arc
npm install

Smart Contract — HelloArchitect.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;
contract HelloArchitect {
 string private greeting;
 event GreetingChanged(string newGreeting);
 constructor() {
 greeting = "Hello Architect!";
 }
 function setGreeting(string memory newGreeting) public {
 greeting = newGreeting;
 emit GreetingChanged(newGreeting);
 }
 function getGreeting() public view returns (string memory) {
 return greeting;
 }
}

Deploy Script — scripts/deploy.js

const hre = require("hardhat");
async function main() {
 const HelloArchitect = await hre.ethers.getContractFactory("HelloArchitect");
 const contract = await HelloArchitect.deploy();
 await contract.waitForDeployment();
 console.log("✅ Contract deployed to:", await contract.getAddress());
}
main().catch((error) => { console.error(error); process.exit(1); });

Run

npx hardhat compile
npx hardhat run scripts/deploy.js --network arc-testnet
node scripts/interact.js

Deployed Contract

Tutorial 3 — Register an AI Agent (ERC-8004)

What You'll Learn

Setup

cd erc8004-quickstart
npm install

OWNER_PRIVATE_KEY=0x...
VALIDATOR_PRIVATE_KEY=0x...

ERC-8004 Registry Contracts (Arc Testnet)

Flow

Owner Wallet
 │── register(metadataURI) ──────────────► Identity Registry (mint NFT)
 │ │
 │ agentId returned via Transfer event
 │
Validator Wallet
 │── giveFeedback(agentId, score=95) ─────► Reputation Registry
 │
Owner Wallet
 │── validationRequest(validator, agentId) ► Validation Registry
 │
Validator Wallet
 │── validationResponse(requestHash, 100) ► Validation Registry
 │
 └── getValidationStatus(requestHash) ────► response: 100 (KYC PASSED ✅)

Key Code — index.ts (excerpt)

// Step 1: Register agent identity → mints an ERC-721 NFT
const registerTx = await ownerWalletClient.writeContract({
 address: IDENTITY_REGISTRY,
 abi: identityAbi,
 functionName: "register",
 args: [METADATA_URI],
 account: ownerAccount,
});
// Step 2: Get the agent's token ID from Transfer event
const transferLogs = await publicClient.getLogs({
 address: IDENTITY_REGISTRY,
 event: parseAbiItem("event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"),
 args: { to: ownerAccount.address },
 fromBlock: receipt.blockNumber,
 toBlock: receipt.blockNumber,
});
const agentId = transferLogs[transferLogs.length - 1].args.tokenId!;
// Step 3: Validator gives reputation feedback
await reputationContract.write.giveFeedback(
 [agentId, 95n, 0, "successful_trade", "", "", "", feedbackHash],
 { account: validatorAccount }
);
// Step 4: KYC validation — request then respond
await ownerWalletClient.writeContract({ functionName: "validationRequest", args: [validatorAccount.address, agentId, requestURI, requestHash] });
await validatorWalletClient.writeContract({ functionName: "validationResponse", args: [requestHash, 100, "", zeroHash, "kyc_verified"] });

Run

npm start

── Step 1: Wallets ──
 Owner: 0xE1769629A3C94Cf8d5dE5FBabCAF8B18944d810C
 Validator: 0xefCa26C30942fA3b55ed67BE12A787a0B7AD9376
── Step 2: Register agent identity ──
 ✅ Registration confirmed!
── Step 3: Retrieve agent ID ──
 Agent ID: 1
 URI: ipfs://bafkreibdi...
── Step 4: Record reputation ──
 ✅ Reputation confirmed!
── Step 5: Request validation ──
 ✅ Validation request confirmed!
── Step 6: Validation response ──
 ✅ Validation response confirmed!
── Step 7: Check validation ──
 Response: 100 (100 = passed)
 Tag: kyc_verified
── ✅ Complete ──
 ✓ Identity registered
 ✓ Reputation recorded
 ✓ Validation verified

Deployed Wallets

Tutorial 4 — Monitor Contract Events

What You'll Learn

Setup

cd monitor-events
npm install

Key Code — index.ts

import { createPublicClient, http, parseAbiItem } from "viem";
import { arcTestnet } from "viem/chains";
const CONTRACT_ADDRESS = "0x1a2F5E6B63887855D829CD440a07f34AAAb44be6";
const client = createPublicClient({
 chain: arcTestnet,
 transport: http(),
});
// 1. Fetch past events (last 9000 blocks)
const latestBlock = await client.getBlockNumber();
const logs = await client.getLogs({
 address: CONTRACT_ADDRESS,
 event: parseAbiItem("event GreetingChanged(string newGreeting)"),
 fromBlock: latestBlock - 9000n,
 toBlock: "latest",
});
console.log(`Found ${logs.length} past event(s)`);
// 2. Watch for new events in real-time
client.watchEvent({
 address: CONTRACT_ADDRESS,
 event: parseAbiItem("event GreetingChanged(string newGreeting)"),
 onLogs: (logs) => {
 for (const log of logs) {
 console.log(`🆕 New greeting: "${log.args.newGreeting}"`);
 console.log(` Tx: https://testnet.arcscan.app/tx/${log.transactionHash}`);
 }
 },
});
console.log("👂 Watching for new events... (Ctrl+C to stop)");

Run

npm start

Tutorial 5 — Deploy Contracts via Circle Contracts SDK

What You'll Learn

Setup

cd deploy-contracts
npm install

CIRCLE_API_KEY=your_circle_api_key
CIRCLE_ENTITY_SECRET=your_entity_secret
WALLET_ID=your_sca_wallet_id
WALLET_ADDRESS=your_wallet_address

Key Code — deploy-erc20.ts

import { initiateSmartContractPlatformClient } from "@circle-fin/smart-contract-platform";
const contractSdk = initiateSmartContractPlatformClient({
 apiKey: process.env.CIRCLE_API_KEY,
 entitySecret: process.env.CIRCLE_ENTITY_SECRET,
});
const response = await contractSdk.deployContractTemplate({
 id: "a1b74add-23e0-4712-88d1-6b3009e85a86", // ERC-20 template ID
 blockchain: "ARC-TESTNET",
 name: "MyTokenContract",
 walletId: process.env.WALLET_ID,
 templateParameters: {
 name: "MyToken",
 symbol: "MTK",
 defaultAdmin: process.env.WALLET_ADDRESS,
 primarySaleRecipient: process.env.WALLET_ADDRESS,
 },
 fee: { type: "level", config: { feeLevel: "MEDIUM" } },
});
console.log(JSON.stringify(response.data, null, 2));

Run

npx tsx deploy-erc20.ts
npx tsx deploy-erc721.ts
npx tsx deploy-erc1155.ts
npx tsx deploy-airdrop.ts

Deployed Contracts

Tutorial 6 — Interact with Contracts

Operations Covered

Key Code — interact-erc20.ts

import { initiateDeveloperControlledWalletsClient } from "@circle-fin/developer-controlled-wallets";
const sdk = initiateDeveloperControlledWalletsClient({
 apiKey: process.env.CIRCLE_API_KEY,
 entitySecret: process.env.CIRCLE_ENTITY_SECRET,
});
// Mint 1 token (18 decimals)
const mint = await sdk.createContractExecutionTransaction({
 walletId: process.env.WALLET_ID,
 abiFunctionSignature: "mintTo(address,uint256)",
 abiParameters: [process.env.WALLET_ADDRESS, "1000000000000000000"],
 contractAddress: process.env.CONTRACT_ADDRESS,
 fee: { type: "level", config: { feeLevel: "MEDIUM" } },
});
console.log("Mint:", mint.data);
// Transfer 1 token to recipient
const transfer = await sdk.createContractExecutionTransaction({
 walletId: process.env.WALLET_ID,
 abiFunctionSignature: "transfer(address,uint256)",
 abiParameters: [process.env.RECIPIENT_WALLET_ADDRESS, "1000000000000000000"],
 contractAddress: process.env.CONTRACT_ADDRESS,
 fee: { type: "level", config: { feeLevel: "MEDIUM" } },
});
console.log("Transfer:", transfer.data);

Run

npx tsx interact-erc20.ts
npx tsx interact-erc721.ts
npx tsx interact-erc1155.ts
npx tsx interact-airdrop.ts

Tutorial 7 — Bridge USDC via App Kit (CCTP V2)

What You'll Learn

Setup

cd app-kit-bridge
npm install

PRIVATE_KEY=0x_your_wallet_private_key

How CCTP V2 Works

Ethereum Sepolia Arc Testnet
 │ │
 │ burn 1 USDC on Sepolia │
 │ ─────────────────────────────────────► │
 │ Circle Attestation Service │
 │ (cross-chain message relay) │
 │ │ mint 1 USDC on Arc
 │ ◄─────────────────────────────────────── │

Key Code — index.ts

import { AppKit } from "@circle-fin/app-kit";
import { createViemAdapterFromPrivateKey } from "@circle-fin/adapter-viem-v2";
const kit = new AppKit();
const adapter = createViemAdapterFromPrivateKey({
 privateKey: process.env.PRIVATE_KEY as string,
});
// Bridge 1 USDC from Ethereum Sepolia to Arc Testnet
const result = await kit.bridge({
 from: { adapter, chain: "Ethereum_Sepolia" },
 to: { adapter, chain: "Arc_Testnet" },
 amount: "1.00",
});
console.log("Bridge result:", result);

Run

npm start

Completed Transaction

💼 Wallet Addresses

📚 Resources

👤 Author

📄 License