@moltium/world-core 0.1.0 → 0.1.1

package/README.md

@@ -1,15 +1,6 @@
 # @moltium/world-core
 
-World runtime for creating agent simulation environments with A2A-based admission and blockchain validation.
-
-## Features
-
-- **A2A Protocol Integration** — Discover and communicate with Moltium agents via A2A
-- **Blockchain Validation** — On-chain agent registration and soulbound NFT membership on Monad
-- **Configurable Persistence** — SQLite, PostgreSQL, Redis, MongoDB, or LevelDB backends
-- **Flexible Admission Rules** — Skill-based, tag-based, and custom evaluators
-- **World Simulation Engine** — Tick-based execution with rule enforcement
-- **Entry Fee System** — MON token payment with soulbound NFT access control
+This package requires [Foundry](https://getfoundry.sh/) to be installed for smart contract deployment.
 
 ## Installation
 
@@ -17,51 +8,34 @@ World runtime for creating agent simulation environments with A2A-based admissio
 npm install @moltium/world-core
 ```
 
-## Quick Start
+The package will automatically run `forge install` during installation to fetch OpenZeppelin dependencies. If Foundry is not installed, you'll need to run it manually:
 
-```typescript
-import { World, createWorldApp } from '@moltium/world-core';
-import type { WorldConfig } from '@moltium/world-core';
+```bash
+cd node_modules/@moltium/world-core
+forge install
+```
 
-const config: WorldConfig = {
-  name: 'Trading Arena',
-  description: 'Autonomous trading simulation',
-  
-  server: {
-    port: 4000,
-    host: 'localhost',
-  },
-  
-  admission: {
-    maxAgents: 50,
-    requiredSkills: ['trading', 'analysis'],
-  },
-  
-  simulation: {
-    tickIntervalMs: 5000,
-  },
-  
-  persistence: {
-    type: 'sqlite',
-    sqlite: { filename: './world.db' },
-  },
-  
-  blockchain: {
-    rpcUrl: process.env.MONAD_RPC_URL!,
-    privateKey: process.env.DEPLOYER_PRIVATE_KEY!,
-    entryFee: 0.5, // MON tokens
-    requireMembership: true,
-  },
-};
+## What's Included
 
-const world = new World(config);
-await world.init();
-await world.start();
-```
+- TypeScript SDK for world management
+- Solidity smart contracts:
+  - `AgentRegistry.sol` - Agent registration and metadata
+  - `WorldMembership.sol` - Soulbound NFT membership tokens
+  - `WorldToken.sol` - ERC20 world currency template
+- Foundry deployment scripts
+- Test suite
+
+## Foundry Dependencies
+
+This package uses Foundry submodules for contract dependencies. The following will be auto-installed:
+
+- `openzeppelin-contracts` - Standard token implementations
+
+These are cloned into the `lib/` folder when you run `forge install`.
 
-## Documentation
+## Usage
 
-See the [implementation plan](../../world_implementation.md) for detailed architecture and API documentation.
+See the [@moltium/world-cli](https://www.npmjs.com/package/@moltium/world-cli) package for creating and deploying worlds.
 
 ## License
 

package/foundry.toml

@@ -0,0 +1,27 @@
+[profile.default]
+src = "contracts"
+out = "out"
+libs = ["lib"]
+solc_version = "0.8.24"
+optimizer = true
+optimizer_runs = 200
+via_ir = false
+
+# Monad network configuration
+[rpc_endpoints]
+monad = "${MONAD_RPC_URL}"
+
+[etherscan]
+monad = { key = "${MONAD_ETHERSCAN_KEY}", url = "https://explorer.monad.xyz/api" }
+
+# Test configuration
+[profile.default.fuzz]
+runs = 256
+
+[profile.default.invariant]
+runs = 256
+depth = 15
+
+eth-rpc-url="https://testnet-rpc.monad.xyz"
+chain_id = 10143
+evm_version = "prague"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moltium/world-core",
-    "version": "0.1.0",
+    "version": "0.1.1",
     "description": "World runtime for creating agent simulation environments with A2A-based admission and blockchain validation",
     "license": "MIT",
     "type": "module",
@@ -16,7 +16,12 @@
     "types": "./dist/index.d.ts",
     "files": [
         "dist",
-        "contracts"
+        "contracts",
+        "test",
+        "script",
+        "scripts",
+        "foundry.toml",
+        "remappings.txt"
     ],
     "scripts": {
         "build": "tsup",
@@ -24,8 +29,10 @@
         "test": "vitest run",
         "test:watch": "vitest",
         "clean": "rm -rf dist",
-        "compile-contracts": "cd contracts && hardhat compile",
-        "test-contracts": "cd contracts && hardhat test"
+        "compile-contracts": "forge build",
+        "test-contracts": "forge test",
+        "install-forge-deps": "forge install",
+        "postinstall": "bash scripts/postinstall.sh || true"
     },
     "publishConfig": {
         "access": "public"

package/remappings.txt

@@ -0,0 +1,2 @@
+@openzeppelin/=lib/openzeppelin-contracts/
+forge-std/=lib/forge-std/src/

package/script/Deploy.s.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {Script, console} from "forge-std/Script.sol";
+import {AgentRegistry} from "../contracts/AgentRegistry.sol";
+import {WorldMembership} from "../contracts/WorldMembership.sol";
+import {WorldToken} from "../contracts/WorldToken.sol";
+
+/**
+ * Foundry deployment script for Monad network
+ * 
+ * Usage:
+ *   forge script script/Deploy.s.sol:DeployScript --rpc-url monad --broadcast --verify
+ */
+contract DeployScript is Script {
+    function run() external {
+        // Load environment variables
+        uint256 deployerPrivateKey = vm.envUint("DEPLOYER_PRIVATE_KEY");
+        string memory worldName = vm.envOr("WORLD_NAME", string("TestWorld"));
+        uint256 entryFee = vm.envOr("ENTRY_FEE_MON", uint256(0.1 ether));
+        bool deployToken = vm.envOr("DEPLOY_WORLD_TOKEN", false);
+        
+        vm.startBroadcast(deployerPrivateKey);
+        
+        // 1. Deploy AgentRegistry
+        console.log("Deploying AgentRegistry...");
+        AgentRegistry agentRegistry = new AgentRegistry();
+        console.log("AgentRegistry deployed to:", address(agentRegistry));
+        
+        // 2. Deploy WorldMembership
+        console.log("\nDeploying WorldMembership...");
+        console.log("  World Name:", worldName);
+        console.log("  Entry Fee:", entryFee / 1 ether, "MON");
+        WorldMembership membership = new WorldMembership(worldName, entryFee);
+        console.log("WorldMembership deployed to:", address(membership));
+        
+        // 3. Deploy WorldToken (optional)
+        address tokenAddress = address(0);
+        if (deployToken) {
+            string memory tokenName = vm.envOr("TOKEN_NAME", string("World Token"));
+            string memory tokenSymbol = vm.envOr("TOKEN_SYMBOL", string("WORLD"));
+            uint256 initialSupply = vm.envOr("TOKEN_INITIAL_SUPPLY", uint256(1000000));
+            uint8 decimals = uint8(vm.envOr("TOKEN_DECIMALS", uint256(18)));
+            
+            console.log("\nDeploying WorldToken...");
+            console.log("  Name:", tokenName);
+            console.log("  Symbol:", tokenSymbol);
+            console.log("  Initial Supply:", initialSupply);
+            console.log("  Decimals:", decimals);
+            
+            WorldToken token = new WorldToken(tokenName, tokenSymbol, initialSupply, decimals);
+            tokenAddress = address(token);
+            console.log("WorldToken deployed to:", tokenAddress);
+        }
+        
+        vm.stopBroadcast();
+        
+        // Print summary
+        console.log("\n=====================================");
+        console.log("Deployment Summary");
+        console.log("=====================================");
+        console.log("AgentRegistry:   ", address(agentRegistry));
+        console.log("WorldMembership: ", address(membership));
+        if (deployToken) {
+            console.log("WorldToken:      ", tokenAddress);
+        }
+        console.log("=====================================");
+        
+        console.log("\nAdd these to your .env file:");
+        console.log("AGENT_REGISTRY_ADDRESS=", address(agentRegistry));
+        console.log("WORLD_MEMBERSHIP_ADDRESS=", address(membership));
+        if (deployToken) {
+            console.log("WORLD_TOKEN_ADDRESS=", tokenAddress);
+        }
+    }
+}

package/scripts/deploy.js

@@ -0,0 +1,83 @@
+const hre = require("hardhat");
+
+/**
+ * Deploy all world contracts to Monad network
+ * 
+ * Usage:
+ *   npx hardhat run scripts/deploy.js --network monad
+ */
+async function main() {
+    console.log("Deploying World SDK contracts to Monad...\n");
+
+    const [deployer] = await hre.ethers.getSigners();
+    console.log("Deploying with account:", deployer.address);
+    console.log("Account balance:", (await hre.ethers.provider.getBalance(deployer.address)).toString(), "\n");
+
+    // 1. Deploy AgentRegistry
+    console.log("Deploying AgentRegistry...");
+    const AgentRegistry = await hre.ethers.getContractFactory("AgentRegistry");
+    const agentRegistry = await AgentRegistry.deploy();
+    await agentRegistry.waitForDeployment();
+    const agentRegistryAddress = await agentRegistry.getAddress();
+    console.log("✅ AgentRegistry deployed to:", agentRegistryAddress, "\n");
+
+    // 2. Deploy WorldMembership
+    const worldName = process.env.WORLD_NAME || "TestWorld";
+    const entryFee = hre.ethers.parseEther(process.env.ENTRY_FEE_MON || "0.1"); // Default 0.1 MON
+
+    console.log("Deploying WorldMembership...");
+    console.log("  World Name:", worldName);
+    console.log("  Entry Fee:", hre.ethers.formatEther(entryFee), "MON");
+
+    const WorldMembership = await hre.ethers.getContractFactory("WorldMembership");
+    const worldMembership = await WorldMembership.deploy(worldName, entryFee);
+    await worldMembership.waitForDeployment();
+    const membershipAddress = await worldMembership.getAddress();
+    console.log("✅ WorldMembership deployed to:", membershipAddress, "\n");
+
+    // 3. Deploy WorldToken (optional)
+    let worldTokenAddress = null;
+    if (process.env.DEPLOY_WORLD_TOKEN === "true") {
+        const tokenName = process.env.TOKEN_NAME || "World Token";
+        const tokenSymbol = process.env.TOKEN_SYMBOL || "WORLD";
+        const initialSupply = process.env.TOKEN_INITIAL_SUPPLY || "1000000";
+        const decimals = parseInt(process.env.TOKEN_DECIMALS || "18");
+
+        console.log("Deploying WorldToken...");
+        console.log("  Name:", tokenName);
+        console.log("  Symbol:", tokenSymbol);
+        console.log("  Initial Supply:", initialSupply);
+        console.log("  Decimals:", decimals);
+
+        const WorldToken = await hre.ethers.getContractFactory("WorldToken");
+        const worldToken = await WorldToken.deploy(tokenName, tokenSymbol, initialSupply, decimals);
+        await worldToken.waitForDeployment();
+        worldTokenAddress = await worldToken.getAddress();
+        console.log("✅ WorldToken deployed to:", worldTokenAddress, "\n");
+    }
+
+    // Summary
+    console.log("=====================================");
+    console.log("Deployment Summary");
+    console.log("=====================================");
+    console.log("AgentRegistry:    ", agentRegistryAddress);
+    console.log("WorldMembership:  ", membershipAddress);
+    if (worldTokenAddress) {
+        console.log("WorldToken:       ", worldTokenAddress);
+    }
+    console.log("=====================================\n");
+
+    console.log("Add these to your .env file:");
+    console.log(`AGENT_REGISTRY_ADDRESS=${agentRegistryAddress}`);
+    console.log(`WORLD_MEMBERSHIP_ADDRESS=${membershipAddress}`);
+    if (worldTokenAddress) {
+        console.log(`WORLD_TOKEN_ADDRESS=${worldTokenAddress}`);
+    }
+}
+
+main()
+    .then(() => process.exit(0))
+    .catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });

package/scripts/postinstall.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# Post-install script for @moltium/world-core
+# Installs Foundry dependencies if forge is available
+
+if command -v forge &> /dev/null; then
+    echo "📦 Installing Foundry dependencies..."
+    cd "$(dirname "$0")" || exit 1
+    forge install --no-commit
+    echo "✅ Foundry dependencies installed"
+else
+    echo "⚠️  Foundry not found - skipping dependency installation"
+    echo "   Install Foundry from https://getfoundry.sh/"
+    echo "   Then run: cd node_modules/@moltium/world-core && forge install"
+fi

package/test/AgentRegistry.t.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {Test} from "forge-std/Test.sol";
+import {AgentRegistry} from "../contracts/AgentRegistry.sol";
+
+contract AgentRegistryTest is Test {
+    AgentRegistry public registry;
+    address public agent1 = address(0x1);
+    address public agent2 = address(0x2);
+    
+    function setUp() public {
+        registry = new AgentRegistry();
+    }
+    
+    function testRegisterAgent() public {
+        vm.prank(agent1);
+        registry.registerAgent("http://localhost:3000", "Agent1");
+        
+        assertTrue(registry.isAgentValid(agent1));
+        
+        AgentRegistry.AgentInfo memory info = registry.getAgent(agent1);
+        assertEq(info.walletAddress, agent1);
+        assertEq(info.agentUrl, "http://localhost:3000");
+        assertEq(info.name, "Agent1");
+        assertTrue(info.isActive);
+    }
+    
+    function testCannotRegisterTwice() public {
+        vm.startPrank(agent1);
+        registry.registerAgent("http://localhost:3000", "Agent1");
+        
+        vm.expectRevert("Agent already registered");
+        registry.registerAgent("http://localhost:3001", "Agent1Updated");
+        vm.stopPrank();
+    }
+    
+    function testCannotRegisterSameUrl() public {
+        vm.prank(agent1);
+        registry.registerAgent("http://localhost:3000", "Agent1");
+        
+        vm.prank(agent2);
+        vm.expectRevert("URL already registered");
+        registry.registerAgent("http://localhost:3000", "Agent2");
+    }
+    
+    function testDeactivateAgent() public {
+        vm.startPrank(agent1);
+        registry.registerAgent("http://localhost:3000", "Agent1");
+        assertTrue(registry.isAgentValid(agent1));
+        
+        registry.deactivateAgent();
+        assertFalse(registry.isAgentValid(agent1));
+        vm.stopPrank();
+    }
+    
+    function testReactivateAgent() public {
+        vm.startPrank(agent1);
+        registry.registerAgent("http://localhost:3000", "Agent1");
+        registry.deactivateAgent();
+        assertFalse(registry.isAgentValid(agent1));
+        
+        registry.activateAgent();
+        assertTrue(registry.isAgentValid(agent1));
+        vm.stopPrank();
+    }
+    
+    function testGetWalletByUrl() public {
+        vm.prank(agent1);
+        registry.registerAgent("http://localhost:3000", "Agent1");
+        
+        address wallet = registry.getWalletByUrl("http://localhost:3000");
+        assertEq(wallet, agent1);
+    }
+    
+    function testEmptyUrlReverts() public {
+        vm.prank(agent1);
+        vm.expectRevert("Agent URL cannot be empty");
+        registry.registerAgent("", "Agent1");
+    }
+    
+    function testEmptyNameReverts() public {
+        vm.prank(agent1);
+        vm.expectRevert("Agent name cannot be empty");
+        registry.registerAgent("http://localhost:3000", "");
+    }
+}

package/test/WorldMembership.t.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {Test} from "forge-std/Test.sol";
+import {WorldMembership} from "../contracts/WorldMembership.sol";
+
+contract WorldMembershipTest is Test {
+    WorldMembership public membership;
+    address public worldOwner = address(this);
+    address public agent1 = address(0x1);
+    address public agent2 = address(0x2);
+    uint256 public entryFee = 0.1 ether;
+    
+    function setUp() public {
+        membership = new WorldMembership("TestWorld", entryFee);
+        vm.deal(worldOwner, 100 ether);
+    }
+    
+    function testMintMembership() public {
+        membership.mintMembership{value: entryFee}(agent1);
+        
+        assertTrue(membership.hasMembership(agent1));
+        assertEq(membership.totalMembers(), 1);
+        assertEq(membership.balanceOf(agent1), 1);
+    }
+    
+    function testCannotMintWithInsufficientFee() public {
+        vm.expectRevert("Insufficient entry fee");
+        membership.mintMembership{value: 0.05 ether}(agent1);
+    }
+    
+    function testCannotMintDuplicate() public {
+        membership.mintMembership{value: entryFee}(agent1);
+        
+        vm.expectRevert("Agent already has membership");
+        membership.mintMembership{value: entryFee}(agent1);
+    }
+    
+    function testRevokeMembership() public {
+        membership.mintMembership{value: entryFee}(agent1);
+        assertTrue(membership.hasMembership(agent1));
+        
+        membership.revokeMembership(agent1);
+        assertFalse(membership.hasMembership(agent1));
+        assertEq(membership.balanceOf(agent1), 0);
+    }
+    
+    function testSoulboundTransferReverts() public {
+        membership.mintMembership{value: entryFee}(agent1);
+        uint256 tokenId = membership.agentToToken(agent1);
+        
+        vm.prank(agent1);
+        // Using try-catch to silence erc20-unchecked-transfer warning
+        // Note: This is an ERC721 call, not ERC20, and we expect it to revert
+        try membership.transferFrom(agent1, agent2, tokenId) {
+            fail("Expected transfer to revert");
+        } catch Error(string memory reason) {
+            assertEq(reason, "WorldMembership: Token is soulbound and cannot be transferred");
+        }
+    }
+    
+    function testWithdrawFees() public {
+        membership.mintMembership{value: entryFee}(agent1);
+        membership.mintMembership{value: entryFee}(agent2);
+        
+        uint256 balanceBefore = address(this).balance;
+        membership.withdrawFees();
+        uint256 balanceAfter = address(this).balance;
+        
+        assertEq(balanceAfter - balanceBefore, entryFee * 2);
+    }
+    
+    function testUpdateEntryFee() public {
+        uint256 newFee = 0.2 ether;
+        membership.updateEntryFee(newFee);
+        assertEq(membership.entryFee(), newFee);
+    }
+    
+    function testOnlyOwnerCanMint() public {
+        // hoax sets both msg.sender and provides ETH
+        hoax(agent1, 1 ether);
+        vm.expectRevert();
+        membership.mintMembership{value: entryFee}(agent2);
+    }
+    
+    function testOnlyOwnerCanRevoke() public {
+        membership.mintMembership{value: entryFee}(agent1);
+        
+        vm.prank(agent2);
+        vm.expectRevert();
+        membership.revokeMembership(agent1);
+    }
+    
+    // Allow this contract to receive ether
+    receive() external payable {}
+}