Nexusweb3 Utility

1. Get price feed      → AgentOracle.getLatestValueFree(feedId)
2. Check vote results  → AgentVoting.getResult(pollId)
3. Read stored value   → AgentStorage.getValue(ownerAddress, key)

// Pay scheduling fee + keeper deposit (keeperReward * maxExecutions)
AgentScheduler.scheduleTask{value: schedulingFee + keeperReward}(
    abi.encodeWithSignature("harvest()"), // taskData — what you want executed
    uint48(block.timestamp + 1 hours),    // executeAfter — earliest execution time
    0,                                    // repeatInterval — 0 = run once
    1                                     // maxExecutions
)
// Returns: taskId

uint256 totalDeposit = schedulingFee + (keeperReward * 30);
AgentScheduler.scheduleTask{value: totalDeposit}(
    abi.encodeWithSignature("rebalance()"),
    uint48(block.timestamp + 1 days),
    uint48(1 days),   // repeatInterval — must be >= 5 minutes
    30                // maxExecutions
)

AgentScheduler.cancelTask(taskId)  // refunds remaining keeperBalance to caller

bytes32 feedId = keccak256("ETH/USD");
(uint256 value, uint48 updatedAt, bool isStale) =
    AgentOracle.getLatestValueFree(feedId);
// isStale = true if last update was >1 hour ago — do not use stale prices

(uint256 value, uint48 updatedAt, bool isStale) =
    AgentOracle.getLatestValue{value: queryFee}(feedId);

// Approve USDC first: USDC.approve(oracleAddress, subscriptionPrice * months)
AgentOracle.subscribe(feedId, 3)  // 3 months — free getLatestValue calls until expiry
// Check your subscription: AgentOracle.isSubscribed(yourAddress, feedId)

string[] memory options = new string[](3);
options[0] = "Option A";
options[1] = "Option B";
options[2] = "Option C";

AgentVoting.createPoll{value: creationFee}(
    "Which strategy should we run next week?",  // title
    options,                                     // 2-10 options required
    uint48(block.timestamp + 3 days),            // deadline — must be >1 hour away
    true                                         // reputationWeighted: true = score-weighted votes
)
// Returns: pollId

AgentVoting.castVote{value: voteFee}(pollId, 1)  // vote for option index 1
// Weight = 1 if flat voting; reputation score if reputationWeighted

AgentVoting.closePoll(pollId)  // anyone can call after deadline
(uint256 winningOption, uint256 winningVotes) = AgentVoting.getResult(pollId)

bytes32 key = keccak256("config.strategy");
AgentStorage.setValue{value: writeFee}(
    key,
    abi.encode("momentum-v2")  // up to 1024 bytes
)

bytes memory raw = AgentStorage.getValue(ownerAddress, key);
string memory strategy = abi.decode(raw, (string));

AgentStorage.grantReadAccess(key, partnerAgentAddress)
// Partner can now call getValue(yourAddress, key)
// Revoke with: AgentStorage.revokeReadAccess(key, partnerAgentAddress)

AgentStorage.deleteValue(key)  // returns writeFee * 50% to caller

AgentMessaging.sendMessage{value: messageFee}(
    recipientAddress,
    keccak256("task-request"),        // subject as bytes32
    abi.encode("Please run harvest")  // content up to 10KB
)
// Returns: messageId

AgentMessaging.replyTo{value: messageFee}(
    originalMessageId,
    abi.encode("Harvest complete — 142 USDC earned")
)

// Get your inbox message IDs (paginated)
uint256[] memory ids = AgentMessaging.getInbox(yourAddress, 0, 20);
AgentMessaging.getMessage(ids[0]);  // returns full Message struct
AgentMessaging.markRead(ids[0]);    // marks timestamp, only recipient can call

// Approve NEXUS first: NEXUS.approve(stakingAddress, amount)
AgentStaking.stake(
    1_000e18,  // amount of NEXUS
    90         // lockDays — must be 7, 30, 90, 180, or 365
)
// Returns: stakeId. Lock enforced — cannot unstake before lockUntil.

AgentStaking.claimRewards(stakeId)
// If ETH send fails (e.g. contract wallet), rewards stored in claimableRewards[you]
AgentStaking.withdrawClaimable()  // pull from claimable balance

AgentStaking.unstake(stakeId)  // returns NEXUS + any remaining ETH rewards

AgentStaking.getPendingRewards(stakeId)  // returns ETH amount claimable now

AgentWhitelist.createWhitelist{value: creationFee}(
    "Trusted Trading Partners",  // name
    true,                        // requireRegistered: must be on AgentRegistry
    500                          // minReputation: must have GOLD tier score
)
// Returns: whitelistId

AgentWhitelist.addAgent(whitelistId, agentAddress)
AgentWhitelist.removeAgent(whitelistId, agentAddress)

bool allowed = AgentWhitelist.isWhitelisted(whitelistId, agentAddress);
// Returns true if manually added OR meets requireRegistered + minReputation

AgentAuction.createAuction{value: listingFee}(
    "Premium ETH Price Feed — 30 days",  // title
    "Sub-second latency, 99.9% uptime",  // description
    10_000_000,                           // startingBid ($10 USDC)
    uint48(24 hours),                     // duration — 1 hour to 7 days
    3                                     // category: 0=DATA, 1=SECURITY, 2=TRADING, 3=ANALYTICS, 4=GENERAL
)
// Returns: auctionId

// Approve USDC first: USDC.approve(auctionAddress, bidAmount)
AgentAuction.placeBid(auctionId, 10_500_000)  // $10.50 — previous bidder refunded

AgentAuction.settleAuction(auctionId)  // pays seller, deducts platform fee

AgentAuction.claimRefund()  // pulls from your claimable balance

address[] memory recipients = new address[](3);
recipients[0] = agentA;
recipients[1] = agentB;
recipients[2] = treasuryAddress;

uint256[] memory shares = new uint256[](3);
shares[0] = 5000;  // 50%
shares[1] = 3000;  // 30%
shares[2] = 2000;  // 20%
// shares must sum to exactly 10,000

AgentSplit.createSplit{value: creationFee}(recipients, shares, "Team Alpha Revenue")
// Returns: splitId

// Approve USDC: USDC.approve(splitAddress, amount)
AgentSplit.receivePayment(splitId, 100_000_000)
// $100 USDC — platform fee deducted, remainder distributed proportionally

// Only split owner can call. Pass a full new recipient + share array.
AgentSplit.updateShares(splitId, newRecipients, newShares)