setServiceId(Number(e.target.value))} placeholder="Service ID" className="input" />

setInputData(e.target.value)}
        placeholder="Enter your prompt..."
        className="textarea"
      />
      <button
        onClick={handleRequest}
        disabled={!address || isLoading}
        className="btn btn-primary"
      >
        {isLoading ? 'Processing...' : 'Request Inference'}
      </button>
      {isSuccess && <p>Request submitted! Check back for results.</p>}
    </div>
  );
}
```

### Backend AI Agent Integration

```python theme={null}
# agent/inference_agent.py
import asyncio
from web3 import Web3
from eth_account import Account
import openai
import os

class InferenceAgent:
    def __init__(self):
        self.w3 = Web3(Web3.HTTPProvider(os.getenv('NEXIS_RPC_URL')))
        self.account = Account.from_key(os.getenv('AGENT_PRIVATE_KEY'))
        self.marketplace_address = os.getenv('MARKETPLACE_ADDRESS')
        self.marketplace_abi = self.load_abi('AIMarketplace.json')
        self.marketplace = self.w3.eth.contract(
            address=self.marketplace_address,
            abi=self.marketplace_abi
        )
        openai.api_key = os.getenv('OPENAI_API_KEY')

async def listen_for_requests(self):
        """Listen for new inference requests"""
        event_filter = self.marketplace.events.RequestCreated.create_filter(
            fromBlock='latest'
        )

print(f"Agent listening for requests...")

while True:
            for event in event_filter.get_new_entries():
                await self.handle_request(event)

await asyncio.sleep(2)  # Poll every 2 seconds

async def handle_request(self, event):
        """Process an inference request"""
        request_id = event['args']['requestId']
        service_id = event['args']['serviceId']

print(f"Processing request #{request_id}...")

# Get request details
        request = self.marketplace.functions.getRequest(request_id).call()
        input_data = request[3]  # inputData field

# Run AI inference
        try:
            output_data = await self.run_inference(input_data)

# Upload proof to IPFS
            proof_uri = await self.upload_proof(input_data, output_data)

# Submit result on-chain
            await self.submit_result(request_id, output_data, proof_uri)

print(f"Request #{request_id} completed successfully!")

except Exception as e:
            print(f"Error processing request #{request_id}: {e}")

async def run_inference(self, prompt: str) -> str:
        """Run AI model inference"""
        response = await openai.ChatCompletion.acreate(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "You are a helpful AI assistant."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=500
        )

return response.choices[0].message.content

async def upload_proof(self, input_data: str, output_data: str) -> str:
        """Upload proof of inference to IPFS"""
        # In production, upload to IPFS/Arweave
        # For now, return mock URI
        return f"ipfs://Qm{hash(input_data + output_data)}"

async def submit_result(self, request_id: int, output: str, proof_uri: str):
        """Submit inference result on-chain"""
        nonce = self.w3.eth.get_transaction_count(self.account.address)

txn = self.marketplace.functions.submitResult(
            request_id,
            output,
            proof_uri
        ).build_transaction({
            'from': self.account.address,
            'nonce': nonce,
            'gas': 500000,
            'gasPrice': self.w3.eth.gas_price,
        })

signed_txn = self.w3.eth.account.sign_transaction(
            txn,
            self.account.key
        )

tx_hash = self.w3.eth.send_raw_transaction(signed_txn.rawTransaction)
        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)

print(f"Result submitted in tx: {receipt['transactionHash'].hex()}")

def load_abi(self, filename: str):
        """Load contract ABI"""
        import json
        with open(f'abis/{filename}', 'r') as f:
            return json.load(f)['abi']

# Run the agent
if __name__ == '__main__':
    agent = InferenceAgent()
    asyncio.run(agent.listen_for_requests())
```

## Gas Optimization for AI Operations

### 1. Use Events for Large Data

```solidity theme={null}
// ❌ Expensive: Store output data on-chain
mapping(uint256 => string) public outputs;

function submitResult(uint256 requestId, string calldata output) external {
    outputs[requestId] = output; // Very expensive!
}

// ✅ Cheap: Emit event with data
event ResultSubmitted(
    uint256 indexed requestId,
    string output,
    bytes32 outputHash
);

function submitResult(uint256 requestId, string calldata output) external {
    bytes32 outputHash = keccak256(bytes(output));
    emit ResultSubmitted(requestId, output, outputHash);
    // Off-chain indexer will store the full output
}
```

### 2. Batch Operations

```solidity theme={null}
// ❌ Multiple transactions
for (uint i = 0; i < 10; i++) {
    marketplace.requestInference(serviceId, inputs[i]);
}

// ✅ Single batch transaction
function requestInferenceBatch(
    uint256 serviceId,
    string[] calldata inputs
) external payable {
    require(msg.value >= inputs.length * pricePerRequest, "Insufficient payment");

for (uint i = 0; i < inputs.length; i++) {
        _createRequest(serviceId, inputs[i]);
    }
}
```

### 3. Optimize Storage

```solidity theme={null}
// ❌ Expensive: Multiple storage slots
struct Request {
    address requester;        // 20 bytes
    uint256 serviceId;        // 32 bytes
    uint256 payment;          // 32 bytes
    bool completed;           // 1 byte
    uint256 timestamp;        // 32 bytes
}

// ✅ Packed: Uses fewer storage slots
struct Request {
    address requester;        // 20 bytes
    uint96 payment;           // 12 bytes } Same slot
    uint64 timestamp;         // 8 bytes  }
    uint32 serviceId;         // 4 bytes  } Same slot
    bool completed;           // 1 byte   }
}
```

## Common Design Patterns

### 1. Pull Over Push Payments

```solidity theme={null}
// ✅ Pull pattern: Users withdraw their earnings
mapping(address => uint256) public pendingWithdrawals;

function submitResult(uint256 requestId) external {
    // Instead of sending payment directly:
    // payable(agentOwner).transfer(payment); // ❌ Push

// Credit the account:
    pendingWithdrawals[agentOwner] += payment; // ✅ Pull
}

function withdraw() external {
    uint256 amount = pendingWithdrawals[msg.sender];
    pendingWithdrawals[msg.sender] = 0;

(bool success, ) = payable(msg.sender).call{value: amount}("");
    require(success, "Transfer failed");
}
```

### 2. Circuit Breaker Pattern

```solidity theme={null}
import "@openzeppelin/contracts/security/Pausable.sol";

contract AIMarketplace is Pausable {
    function requestInference(...) external payable whenNotPaused {
        // Function only works when not paused
    }

function emergencyPause() external onlyOwner {
        _pause();
    }

function unpause() external onlyOwner {
        _unpause();
    }
}
```

### 3. Oracle Pattern for Off-Chain Data

```solidity theme={null}
contract PriceOracle {
    mapping(uint256 => uint256) public servicePrices;
    address public oracle;

modifier onlyOracle() {
        require(msg.sender == oracle, "Not oracle");
        _;
    }

function updatePrice(uint256 serviceId, uint256 newPrice) external onlyOracle {
        servicePrices[serviceId] = newPrice;
    }
}
```

## Testing Strategies

### Unit Tests

* Test individual contract functions
* Mock external dependencies
* Cover edge cases and error conditions

### Integration Tests

* Test contract interactions
* Use actual contract addresses on testnet
* Test full user workflows

### Fuzzing Tests

```solidity theme={null}
// Foundry fuzzing example
function testFuzz_RequestInference(uint256 payment) public {
    vm.assume(payment >= PRICE_PER_REQUEST);
    vm.assume(payment <= 100 ether);

vm.deal(user, payment);
    vm.prank(user);
    marketplace.requestInference{value: payment}(0, "Fuzz input");
}
```

### Load Tests

```typescript theme={null}
// Test with many concurrent requests
describe("Load Testing", () => {
  it("Should handle 100 concurrent requests", async () => {
    const promises = [];
    for (let i = 0; i < 100; i++) {
      promises.push(
        marketplace.connect(users[i % 10]).requestInference(
          0,
          `Request ${i}`,
          { value: PRICE }
        )
      );
    }
    await Promise.all(promises);
  });
});
```

## Production Deployment Checklist

* [ ] **Security Audit**: Get contracts audited by reputable firm
* [ ] **Test Coverage**: Achieve >90% code coverage
* [ ] **Gas Optimization**: Profile and optimize expensive operations
* [ ] **Upgrade Strategy**: Implement proxy pattern if needed
* [ ] **Monitoring**: Setup event indexing and alerts
* [ ] **Documentation**: Write complete API documentation
* [ ] **Emergency Procedures**: Define pause/upgrade procedures
* [ ] **Testnet Validation**: Run on testnet for 2+ weeks
* [ ] **Bug Bounty**: Launch bug bounty program
* [ ] **Mainnet Deployment**: Deploy with ceremony/multisig

## Resources

<CardGroup cols={2}>
  <Card title="Testnet Tokens" icon="faucet" href="/developers/testnet-tokens">
    Get test NZT for development
  </Card>

<Card title="Smart Contracts Reference" icon="file-contract" href="/developers/smart-contracts">
    Complete contract documentation
  </Card>

<Card title="RPC API Methods" icon="code" href="/developers/rpc-calls">
    Available RPC endpoints
  </Card>

<Card title="Example dApps" icon="github" href="https://github.com/nexis-network/examples">
    View complete examples on GitHub
  </Card>
</CardGroup>

## Next Steps

1. **Get Testnet Tokens**: Visit the [faucet](/developers/testnet-tokens) to get test NZT
2. **Deploy Your First Contract**: Follow the [quickstart guide](/quickstart)
3. **Integrate AI Agents**: Register an agent and create your first task
4. **Join the Community**: Get help on [Discord](https://discord.gg/nexis)

***

<Note>
  Need help? Join our [Developer Discord](https://discord.gg/nexis) or check [GitHub Discussions](https://github.com/Nexis-AI/Nexis-appchain/discussions) for community support.
</Note>