@agirails/sdk 2.0.0 → 2.0.1-beta

package/src/__tests__/utils/NonceManager.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Tests for Nonce Manager
+ */
+
+import {
+  InMemoryNonceManager,
+  DIDScopedNonceManager,
+  createNonceManager
+} from '../../utils/NonceManager';
+
+describe('InMemoryNonceManager', () => {
+  let manager: InMemoryNonceManager;
+
+  beforeEach(() => {
+    manager = new InMemoryNonceManager();
+  });
+
+  describe('getNextNonce', () => {
+    it('should return 1 for first nonce', () => {
+      expect(manager.getNextNonce('agirails.delivery.v1')).toBe(1);
+    });
+
+    it('should increment for multiple calls', () => {
+      expect(manager.getNextNonce('agirails.delivery.v1')).toBe(1);
+      manager.recordNonce('agirails.delivery.v1', 1);
+      expect(manager.getNextNonce('agirails.delivery.v1')).toBe(2);
+      manager.recordNonce('agirails.delivery.v1', 2);
+      expect(manager.getNextNonce('agirails.delivery.v1')).toBe(3);
+    });
+
+    it('should track nonces separately per message type', () => {
+      manager.recordNonce('agirails.delivery.v1', 5);
+      manager.recordNonce('agirails.quote.v1', 10);
+
+      expect(manager.getNextNonce('agirails.delivery.v1')).toBe(6);
+      expect(manager.getNextNonce('agirails.quote.v1')).toBe(11);
+    });
+  });
+
+  describe('recordNonce', () => {
+    it('should update current nonce', () => {
+      manager.recordNonce('agirails.delivery.v1', 5);
+      expect(manager.getCurrentNonce('agirails.delivery.v1')).toBe(5);
+    });
+
+    it('should throw if nonce is not strictly increasing', () => {
+      manager.recordNonce('agirails.delivery.v1', 5);
+
+      expect(() => manager.recordNonce('agirails.delivery.v1', 5))
+        .toThrow('Nonce must be strictly increasing');
+
+      expect(() => manager.recordNonce('agirails.delivery.v1', 3))
+        .toThrow('Nonce must be strictly increasing');
+    });
+
+    it('should allow gaps in nonces', () => {
+      manager.recordNonce('agirails.delivery.v1', 1);
+      manager.recordNonce('agirails.delivery.v1', 10);
+
+      expect(manager.getCurrentNonce('agirails.delivery.v1')).toBe(10);
+    });
+  });
+
+  describe('getCurrentNonce', () => {
+    it('should return 0 for unused message type', () => {
+      expect(manager.getCurrentNonce('agirails.unknown.v1')).toBe(0);
+    });
+
+    it('should return last recorded nonce', () => {
+      manager.recordNonce('agirails.delivery.v1', 42);
+      expect(manager.getCurrentNonce('agirails.delivery.v1')).toBe(42);
+    });
+  });
+
+  describe('resetNonce', () => {
+    it('should reset nonce to 0', () => {
+      manager.recordNonce('agirails.delivery.v1', 10);
+      manager.resetNonce('agirails.delivery.v1');
+
+      expect(manager.getCurrentNonce('agirails.delivery.v1')).toBe(0);
+      expect(manager.getNextNonce('agirails.delivery.v1')).toBe(1);
+    });
+  });
+
+  describe('getAllNonces', () => {
+    it('should return all nonces as object', () => {
+      manager.recordNonce('agirails.delivery.v1', 5);
+      manager.recordNonce('agirails.quote.v1', 10);
+
+      const nonces = manager.getAllNonces();
+
+      expect(nonces).toEqual({
+        'agirails.delivery.v1': 5,
+        'agirails.quote.v1': 10
+      });
+    });
+
+    it('should be empty for new manager', () => {
+      expect(manager.getAllNonces()).toEqual({});
+    });
+  });
+
+  describe('constructor with initialNonces', () => {
+    it('should initialize with provided nonces', () => {
+      const manager = new InMemoryNonceManager({
+        'agirails.delivery.v1': 100,
+        'agirails.quote.v1': 200
+      });
+
+      expect(manager.getCurrentNonce('agirails.delivery.v1')).toBe(100);
+      expect(manager.getCurrentNonce('agirails.quote.v1')).toBe(200);
+    });
+  });
+});
+
+describe('DIDScopedNonceManager', () => {
+  const did1 = 'did:ethr:84532:0x1111111111111111111111111111111111111111';
+  const did2 = 'did:ethr:84532:0x2222222222222222222222222222222222222222';
+
+  let manager: DIDScopedNonceManager;
+
+  beforeEach(() => {
+    manager = new DIDScopedNonceManager(did1);
+  });
+
+  describe('DID scoping', () => {
+    it('should track nonces per DID', () => {
+      manager.recordNonceForDID(did1, 'agirails.delivery.v1', 5);
+      manager.recordNonceForDID(did2, 'agirails.delivery.v1', 10);
+
+      expect(manager.getNextNonceForDID(did1, 'agirails.delivery.v1')).toBe(6);
+      expect(manager.getNextNonceForDID(did2, 'agirails.delivery.v1')).toBe(11);
+    });
+
+    it('should use current DID for simple methods', () => {
+      manager.recordNonce('agirails.delivery.v1', 5);
+
+      expect(manager.getCurrentNonce('agirails.delivery.v1')).toBe(5);
+      expect(manager.getNextNonce('agirails.delivery.v1')).toBe(6);
+    });
+
+    it('should allow switching DID context', () => {
+      manager.recordNonce('agirails.delivery.v1', 5);
+
+      manager.switchDID(did2);
+      expect(manager.getCurrentNonce('agirails.delivery.v1')).toBe(0);
+
+      manager.recordNonce('agirails.delivery.v1', 10);
+
+      manager.switchDID(did1);
+      expect(manager.getCurrentNonce('agirails.delivery.v1')).toBe(5);
+    });
+  });
+
+  describe('getAllNonces', () => {
+    it('should return nested structure', () => {
+      manager.recordNonceForDID(did1, 'agirails.delivery.v1', 5);
+      manager.recordNonceForDID(did1, 'agirails.quote.v1', 3);
+      manager.recordNonceForDID(did2, 'agirails.delivery.v1', 10);
+
+      const nonces = manager.getAllNonces();
+
+      expect(nonces).toEqual({
+        [did1]: {
+          'agirails.delivery.v1': 5,
+          'agirails.quote.v1': 3
+        },
+        [did2]: {
+          'agirails.delivery.v1': 10
+        }
+      });
+    });
+  });
+
+  describe('constructor with initialNonces', () => {
+    it('should initialize DID with provided nonces', () => {
+      const manager = new DIDScopedNonceManager(did1, {
+        'agirails.delivery.v1': 100
+      });
+
+      expect(manager.getCurrentNonce('agirails.delivery.v1')).toBe(100);
+      expect(manager.getNextNonce('agirails.delivery.v1')).toBe(101);
+    });
+  });
+});
+
+describe('createNonceManager factory', () => {
+  it('should create InMemoryNonceManager when no DID provided', () => {
+    const manager = createNonceManager();
+    expect(manager).toBeInstanceOf(InMemoryNonceManager);
+  });
+
+  it('should create DIDScopedNonceManager when DID provided', () => {
+    const manager = createNonceManager('did:ethr:84532:0x...');
+    expect(manager).toBeInstanceOf(DIDScopedNonceManager);
+  });
+
+  it('should pass initialNonces to manager', () => {
+    const manager = createNonceManager(undefined, {
+      'agirails.delivery.v1': 50
+    });
+
+    expect(manager.getCurrentNonce('agirails.delivery.v1')).toBe(50);
+  });
+});

package/src/__tests__/utils/canonicalJson.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Tests for Canonical JSON Utilities (AIP-4 §3.6)
+ */
+
+import { canonicalJsonStringify, computeCanonicalHash, computeResultHash } from '../../utils/canonicalJson';
+import { keccak256, toUtf8Bytes } from 'ethers';
+
+describe('Canonical JSON Utilities', () => {
+  describe('canonicalJsonStringify', () => {
+    it('should sort object keys alphabetically', () => {
+      const obj = { z: 1, a: 2, m: 3 };
+      const result = canonicalJsonStringify(obj);
+      expect(result).toBe('{"a":2,"m":3,"z":1}');
+    });
+
+    it('should handle nested objects', () => {
+      const obj = {
+        b: { y: 1, x: 2 },
+        a: { z: 3, w: 4 }
+      };
+      const result = canonicalJsonStringify(obj);
+      expect(result).toBe('{"a":{"w":4,"z":3},"b":{"x":2,"y":1}}');
+    });
+
+    it('should handle arrays', () => {
+      const obj = { items: [3, 1, 2], name: 'test' };
+      const result = canonicalJsonStringify(obj);
+      expect(result).toBe('{"items":[3,1,2],"name":"test"}');
+    });
+
+    it('should produce deterministic output', () => {
+      const obj1 = { a: 1, b: 2, c: 3 };
+      const obj2 = { c: 3, b: 2, a: 1 };
+
+      expect(canonicalJsonStringify(obj1)).toBe(canonicalJsonStringify(obj2));
+    });
+
+    it('should handle special characters', () => {
+      const obj = { text: 'hello "world"', emoji: '🎉' };
+      const result = canonicalJsonStringify(obj);
+      expect(result).toContain('hello \\"world\\"');
+      expect(result).toContain('🎉');
+    });
+
+    it('should handle null and boolean values', () => {
+      const obj = { isTrue: true, isFalse: false, nothing: null };
+      const result = canonicalJsonStringify(obj);
+      expect(result).toBe('{"isFalse":false,"isTrue":true,"nothing":null}');
+    });
+  });
+
+  describe('computeCanonicalHash', () => {
+    it('should compute keccak256 hash of canonical JSON', () => {
+      const obj = { a: 1, b: 2 };
+      const hash = computeCanonicalHash(obj);
+
+      // Hash should be 0x-prefixed, 66 chars (0x + 64 hex)
+      expect(hash).toMatch(/^0x[a-f0-9]{64}$/);
+    });
+
+    it('should produce same hash for semantically equal objects', () => {
+      const obj1 = { a: 1, b: 2, c: 3 };
+      const obj2 = { c: 3, b: 2, a: 1 }; // Different order
+
+      const hash1 = computeCanonicalHash(obj1);
+      const hash2 = computeCanonicalHash(obj2);
+
+      expect(hash1).toBe(hash2);
+    });
+
+    it('should produce different hashes for different objects', () => {
+      const obj1 = { a: 1, b: 2 };
+      const obj2 = { a: 1, b: 3 };
+
+      const hash1 = computeCanonicalHash(obj1);
+      const hash2 = computeCanonicalHash(obj2);
+
+      expect(hash1).not.toBe(hash2);
+    });
+  });
+
+  describe('computeResultHash', () => {
+    it('should alias computeCanonicalHash', () => {
+      const obj = { txId: '0xabc', result: 'test' };
+
+      const hash1 = computeResultHash(obj);
+      const hash2 = computeCanonicalHash(obj);
+
+      expect(hash1).toBe(hash2);
+    });
+  });
+
+  describe('AIP-4 Test Vector (§10.1)', () => {
+    it('should match AIP-4 canonical JSON test vector', () => {
+      const input = {
+        txId: '0x7d87c3b8e23a5c9d1f4e6b2a8c5d9e3f1a7b4c6d8e2f5a3b9c1d7e4f6a8b2c5d',
+        serviceType: 'ocr',
+        result: { text: 'test', confidence: 1.0 },
+        createdAt: 1700000000,
+        provider: 'did:ethr:0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'
+      };
+
+      const canonical = canonicalJsonStringify(input);
+
+      // Expected output from AIP-4 §10.1
+      const expected = '{"createdAt":1700000000,"provider":"did:ethr:0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb","result":{"confidence":1,"text":"test"},"serviceType":"ocr","txId":"0x7d87c3b8e23a5c9d1f4e6b2a8c5d9e3f1a7b4c6d8e2f5a3b9c1d7e4f6a8b2c5d"}';
+
+      expect(canonical).toBe(expected);
+    });
+
+    it('should compute correct hash for test vector', () => {
+      const input = {
+        txId: '0x7d87c3b8e23a5c9d1f4e6b2a8c5d9e3f1a7b4c6d8e2f5a3b9c1d7e4f6a8b2c5d',
+        serviceType: 'ocr',
+        result: { text: 'test', confidence: 1.0 },
+        createdAt: 1700000000,
+        provider: 'did:ethr:0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'
+      };
+
+      const hash = computeResultHash(input);
+
+      // Compute expected hash manually
+      const canonical = '{"createdAt":1700000000,"provider":"did:ethr:0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb","result":{"confidence":1,"text":"test"},"serviceType":"ocr","txId":"0x7d87c3b8e23a5c9d1f4e6b2a8c5d9e3f1a7b4c6d8e2f5a3b9c1d7e4f6a8b2c5d"}';
+      const expectedHash = keccak256(toUtf8Bytes(canonical));
+
+      expect(hash).toBe(expectedHash);
+    });
+  });
+
+  describe('Cross-language compatibility', () => {
+    it('should handle numbers without decimals', () => {
+      const obj = { value: 1.0 };
+      const result = canonicalJsonStringify(obj);
+
+      // JavaScript serializes 1.0 as 1 (no decimal)
+      expect(result).toBe('{"value":1}');
+    });
+
+    it('should handle large numbers', () => {
+      const obj = { timestamp: 1700000000, amount: 1000000000000 };
+      const result = canonicalJsonStringify(obj);
+
+      expect(result).toBe('{"amount":1000000000000,"timestamp":1700000000}');
+    });
+
+    it('should handle unicode strings', () => {
+      const obj = { text: 'Hello 世界 🌍' };
+      const result = canonicalJsonStringify(obj);
+
+      expect(result).toContain('Hello 世界 🌍');
+    });
+  });
+});

package/src/abi/EscrowVault.json

@@ -1,133 +1,65 @@
 [
   {
-    "type": "constructor",
     "inputs": [
-      { "name": "_token", "type": "address", "internalType": "address" },
-      { "name": "_kernel", "type": "address", "internalType": "address" }
+      {"name": "kernel", "type": "address"},
+      {"name": "txId", "type": "bytes32"},
+      {"name": "token", "type": "address"},
+      {"name": "amount", "type": "uint256"},
+      {"name": "beneficiary", "type": "address"}
     ],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "token",
-    "inputs": [],
-    "outputs": [{ "name": "", "type": "address", "internalType": "address" }],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "kernel",
-    "inputs": [],
-    "outputs": [{ "name": "", "type": "address", "internalType": "address" }],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "escrows",
-    "inputs": [{ "name": "", "type": "bytes32", "internalType": "bytes32" }],
-    "outputs": [
-      { "name": "requester", "type": "address", "internalType": "address" },
-      { "name": "provider", "type": "address", "internalType": "address" },
-      { "name": "amount", "type": "uint256", "internalType": "uint256" },
-      { "name": "releasedAmount", "type": "uint256", "internalType": "uint256" },
-      { "name": "active", "type": "bool", "internalType": "bool" }
-    ],
-    "stateMutability": "view"
+    "name": "createEscrow",
+    "outputs": [{"name": "escrowId", "type": "bytes32"}],
+    "stateMutability": "nonpayable",
+    "type": "function"
   },
   {
-    "type": "function",
-    "name": "createEscrow",
     "inputs": [
-      { "name": "escrowId", "type": "bytes32", "internalType": "bytes32" },
-      { "name": "requester", "type": "address", "internalType": "address" },
-      { "name": "provider", "type": "address", "internalType": "address" },
-      { "name": "amount", "type": "uint256", "internalType": "uint256" }
+      {"name": "escrowId", "type": "bytes32"},
+      {"name": "recipients", "type": "address[]"},
+      {"name": "amounts", "type": "uint256[]"}
     ],
+    "name": "disburse",
     "outputs": [],
-    "stateMutability": "nonpayable"
+    "stateMutability": "nonpayable",
+    "type": "function"
   },
   {
-    "type": "function",
-    "name": "verifyEscrow",
     "inputs": [
-      { "name": "escrowId", "type": "bytes32", "internalType": "bytes32" },
-      { "name": "requester", "type": "address", "internalType": "address" },
-      { "name": "provider", "type": "address", "internalType": "address" },
-      { "name": "amount", "type": "uint256", "internalType": "uint256" }
+      {"name": "escrowId", "type": "bytes32"}
     ],
+    "name": "escrows",
     "outputs": [
-      { "name": "isActive", "type": "bool", "internalType": "bool" },
-      { "name": "escrowAmount", "type": "uint256", "internalType": "uint256" }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "type": "function",
-    "name": "payoutToProvider",
-    "inputs": [
-      { "name": "escrowId", "type": "bytes32", "internalType": "bytes32" },
-      { "name": "amount", "type": "uint256", "internalType": "uint256" }
+      {"name": "kernel", "type": "address"},
+      {"name": "txId", "type": "bytes32"},
+      {"name": "token", "type": "address"},
+      {"name": "amount", "type": "uint256"},
+      {"name": "beneficiary", "type": "address"},
+      {"name": "released", "type": "bool"}
     ],
-    "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }],
-    "stateMutability": "nonpayable"
+    "stateMutability": "view",
+    "type": "function"
   },
   {
-    "type": "function",
-    "name": "refundToRequester",
-    "inputs": [
-      { "name": "escrowId", "type": "bytes32", "internalType": "bytes32" },
-      { "name": "amount", "type": "uint256", "internalType": "uint256" }
-    ],
-    "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "payout",
+    "anonymous": false,
     "inputs": [
-      { "name": "escrowId", "type": "bytes32", "internalType": "bytes32" },
-      { "name": "recipient", "type": "address", "internalType": "address" },
-      { "name": "amount", "type": "uint256", "internalType": "uint256" }
+      {"indexed": true, "name": "escrowId", "type": "bytes32"},
+      {"indexed": true, "name": "kernel", "type": "address"},
+      {"indexed": true, "name": "txId", "type": "bytes32"},
+      {"indexed": false, "name": "token", "type": "address"},
+      {"indexed": false, "name": "amount", "type": "uint256"}
     ],
-    "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }],
-    "stateMutability": "nonpayable"
-  },
-  {
-    "type": "function",
-    "name": "remaining",
-    "inputs": [{ "name": "escrowId", "type": "bytes32", "internalType": "bytes32" }],
-    "outputs": [{ "name": "", "type": "uint256", "internalType": "uint256" }],
-    "stateMutability": "view"
-  },
-  {
-    "type": "event",
     "name": "EscrowCreated",
-    "anonymous": false,
-    "inputs": [
-      { "name": "escrowId", "type": "bytes32", "indexed": true, "internalType": "bytes32" },
-      { "name": "requester", "type": "address", "indexed": true, "internalType": "address" },
-      { "name": "provider", "type": "address", "indexed": true, "internalType": "address" },
-      { "name": "amount", "type": "uint256", "indexed": false, "internalType": "uint256" }
-    ]
-  },
-  {
-    "type": "event",
-    "name": "EscrowPayout",
-    "anonymous": false,
-    "inputs": [
-      { "name": "escrowId", "type": "bytes32", "indexed": true, "internalType": "bytes32" },
-      { "name": "recipient", "type": "address", "indexed": true, "internalType": "address" },
-      { "name": "amount", "type": "uint256", "indexed": false, "internalType": "uint256" }
-    ]
+    "type": "event"
   },
   {
-    "type": "event",
-    "name": "EscrowCompleted",
     "anonymous": false,
     "inputs": [
-      { "name": "escrowId", "type": "bytes32", "indexed": true, "internalType": "bytes32" },
-      { "name": "totalReleased", "type": "uint256", "indexed": false, "internalType": "uint256" }
-    ]
+      {"indexed": true, "name": "escrowId", "type": "bytes32"},
+      {"indexed": false, "name": "recipients", "type": "address[]"},
+      {"indexed": false, "name": "amounts", "type": "uint256[]"}
+    ],
+    "name": "EscrowReleased",
+    "type": "event"
   }
 ]
 

package/src/builders/DeliveryProofBuilder.ts

@@ -19,10 +19,9 @@ import { AIP4DeliveryProofTypes, AIP4DeliveryProofData, EIP712Domain } from '../
 
 /**
  * AGIRAILS Delivery Schema UID (Base Sepolia)
- * Deployed 2025-11-23 - AIP-4 delivery proof schema
- * Schema: bytes32 txId, string resultCID, bytes32 resultHash, uint256 deliveredAt
+ * TODO: Update after schema deployment
  */
-export const AGIRAILS_DELIVERY_SCHEMA_UID = '0x1b0ebdf0bd20c28ec9d5362571ce8715a55f46e81c3de2f9b0d8e1b95fb5ffce';
+export const AGIRAILS_DELIVERY_SCHEMA_UID = '0x0000000000000000000000000000000000000000000000000000000000000000'; // PENDING
 
 /**
  * Delivery proof build parameters

package/src/config/networks.ts

@@ -1,20 +1,5 @@
 import { ethers } from 'ethers';
 
-// ============================================================================
-// SECURITY FIX (C-7): RPC URL Configuration
-// ============================================================================
-// Environment variables take priority over hardcoded defaults.
-// This prevents accidental API key leakage if developers modify this file.
-// Public RPC endpoints are used as fallbacks for ease of use.
-//
-// Set these environment variables to use your own RPC provider:
-//   BASE_SEPOLIA_RPC - Custom RPC for Base Sepolia testnet
-//   BASE_MAINNET_RPC - Custom RPC for Base Mainnet
-// ============================================================================
-
-const BASE_SEPOLIA_RPC_URL = process.env.BASE_SEPOLIA_RPC || 'https://sepolia.base.org';
-const BASE_MAINNET_RPC_URL = process.env.BASE_MAINNET_RPC || 'https://mainnet.base.org';
-
 /**
  * Network configuration
  */
@@ -29,7 +14,6 @@ export interface NetworkConfig {
     usdc: string;
     eas: string; // EAS contract address
     easSchemaRegistry: string; // EAS SchemaRegistry contract
-    agentRegistry?: string; // AIP-7 Agent Registry (optional until deployed)
   };
   eas: {
     deliverySchemaUID: string; // AIP-4 delivery proof schema
@@ -46,18 +30,16 @@ export interface NetworkConfig {
 export const BASE_SEPOLIA: NetworkConfig = {
   name: 'Base Sepolia',
   chainId: 84532,
-  rpcUrl: BASE_SEPOLIA_RPC_URL,
+  rpcUrl: 'https://sepolia.base.org',
   blockExplorer: 'https://sepolia.basescan.org',
   contracts: {
-    // Redeployed 2025-12-10 by Arha (new deployer wallet 0x42a2f11555b9363fb7ebdcdc76d7cb26e01dcb00)
-    actpKernel: '0xD199070F8e9FB9a127F6Fe730Bc13300B4b3d962',
-    escrowVault: '0x948b9Ea081C4Cec1E112Af2e539224c531d4d585',
+    // Redeployed 2025-11-25 by Arha (fixed auto-transition in linkEscrow, optimizer-runs 200)
+    actpKernel: '0x6aDB650e185b0ee77981AC5279271f0Fa6CFe7ba',
+    escrowVault: '0x921edE340770db5DB6059B5B866be987d1b7311F',
     usdc: '0x444b4e1A65949AB2ac75979D5d0166Eb7A248Ccb', // MockUSDC
     // EAS contracts (Base native deployment)
     eas: '0x4200000000000000000000000000000000000021',
-    easSchemaRegistry: '0x4200000000000000000000000000000000000020',
-    // AIP-7 Agent Registry (deployed 2025-12-11)
-    agentRegistry: '0xFed6914Aa70c0a53E9c7Cc4d2Ae159e4748fb09D'
+    easSchemaRegistry: '0x4200000000000000000000000000000000000020'
   },
   eas: {
     // Deployed 2025-11-23 - AIP-4 delivery proof schema
@@ -71,18 +53,14 @@ export const BASE_SEPOLIA: NetworkConfig = {
 
 /**
  * Base Mainnet Configuration
- *
- * WARNING: Mainnet contracts are NOT YET DEPLOYED.
- * Using 'base-mainnet' will throw an error until contracts are deployed.
- * Use 'base-sepolia' for testnet development.
  */
 export const BASE_MAINNET: NetworkConfig = {
   name: 'Base Mainnet',
   chainId: 8453,
-  rpcUrl: BASE_MAINNET_RPC_URL,
+  rpcUrl: 'https://mainnet.base.org',
   blockExplorer: 'https://basescan.org',
   contracts: {
-    // NOT DEPLOYED: Will throw error via validateNetworkConfig()
+    // TODO: Update after mainnet deployment
     actpKernel: '0x0000000000000000000000000000000000000000',
     escrowVault: '0x0000000000000000000000000000000000000000',
     usdc: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // Official USDC on Base
@@ -91,7 +69,7 @@ export const BASE_MAINNET: NetworkConfig = {
     easSchemaRegistry: '0x4200000000000000000000000000000000000020'
   },
   eas: {
-    // NOT DEPLOYED: Requires mainnet schema registration
+    // TODO: Deploy delivery schema to mainnet
     deliverySchemaUID: '0x0000000000000000000000000000000000000000000000000000000000000000'
   },
   gasSettings: {
@@ -133,8 +111,7 @@ export function getNetwork(network: string): NetworkConfig {
       escrowVault: config.contracts.escrowVault,
       usdc: config.contracts.usdc,
       eas: config.contracts.eas,
-      easSchemaRegistry: config.contracts.easSchemaRegistry,
-      agentRegistry: config.contracts.agentRegistry
+      easSchemaRegistry: config.contracts.easSchemaRegistry
     },
     eas: {
       deliverySchemaUID: config.eas.deliverySchemaUID