> For the complete documentation index, see [llms.txt](https://frenspool.gitbook.io/frenspool-documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://frenspool.gitbook.io/frenspool-documentation/technical-details.md).

# Technical Details

Technical information for developers

This document provides comprehensive technical information about FrensPool's architecture, smart contracts, and integration points for developers who want to build on or interact with the platform.

### Architecture Overview

FrensPool uses a modern web3 architecture consisting of:

1. **Smart Contracts**: Solidity contracts deployed on Monad Testnet
2. **Frontend Application**: Next.js web application with React
3. **Backend Services**: Supabase for data indexing and user management
4. **Blockchain Interactions**: Ethers.js v6 for contract interactions
5. **State Management**: React context and hooks for frontend state
6. **Styling**: Tailwind CSS with shadcn/ui components

```mermaid
title FrensPool Architecture
graph TD
  A[Frontend (Next.js)] --> B[Smart Contracts (Solidity)]
  A --> C[Supabase Backend]
  B --> D[Monad Blockchain]
  B --> E[Chainlink Oracles]
  C --> F[Database]
  C --> G[Authentication]
  A --> H[Ethers.js]
  H --> B
```

### Smart Contract Details

#### Contract Address

**Monad Testnet**: `0x2535fe5De9A5BfAF6cf27316f141a5f67239E65A`

#### Contract Architecture

The FrensPool contract inherits from OpenZeppelin's `Ownable` and `ReentrancyGuard`:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract FrensPool is Ownable, ReentrancyGuard {
    // Contract implementation
}
```

Uses:

* `Ownable`: Access control
* `ReentrancyGuard`: Prevent reentrancy
* `AggregatorV3Interface`: Chainlink price feeds

#### Key Data Structures

**Enums**

```solidity
enum PoolStatus { Open, Closed, Resolved }
enum OracleType { Chainlink, Social, Manual }
enum Vote { Yes, No }
```

**Pool Struct**

```solidity
struct Pool {
    uint256 id;
    address creator;
    string question;
    uint256 buyIn;
    uint256 deadline;
    OracleType oracleType;
    PoolStatus status;
    uint256 totalYesVotes;
    uint256 totalNoVotes;
    uint256 totalAmount;
    bool outcome;
    address chainlinkFeed;
    uint256 targetPrice;
    bool isGreaterThan;
    mapping(address => Vote) votes;
    mapping(address => bool) hasVoted;
    mapping(address => bool) hasClaimed;
}
```

**Constants**

```solidity
uint256 public constant PLATFORM_FEE = 50;
uint256 public constant BASIS_POINTS = 10000;
```

#### Key Functions

**Create Pool**

```solidity
function createPool(string memory question, uint256 deadline, OracleType oracleType,
    address chainlinkFeed, uint256 targetPrice, bool isGreaterThan) external payable
```

**Cast Vote**

```solidity
function castVote(uint256 poolId, Vote vote) external payable nonReentrant
```

**Close Pool**

```solidity
function closePool(uint256 poolId) external
```

**Resolve Pool (Manual)**

```solidity
function resolvePoolManually(uint256 poolId, bool outcome) external
```

**Claim Winnings**

```solidity
function claimWinnings(uint256 poolId) external nonReentrant
```

#### Events

```solidity
event PoolCreated(uint256 indexed poolId, address indexed creator, string question, uint256 buyIn, uint256 deadline);
event VoteCast(uint256 indexed poolId, address indexed voter, Vote vote, uint256 amount);
event PoolResolved(uint256 indexed poolId, bool outcome);
event WinningsClaimed(uint256 indexed poolId, address indexed user, uint256 amount);
```

### Frontend Integration

#### Contract ABI

Refer to the `FRENS_POOL_ABI` for simplified interaction.

#### Connecting with Ethers.js

**Setup**

```ts
import { ethers } from "ethers";
import { FRENS_POOL_ABI } from "./abi";

const CONTRACT_ADDRESS = process.env.NEXT_PUBLIC_CONTRACT_ADDRESS;
const RPC_URL = process.env.NEXT_PUBLIC_RPC_URL;

export function getReadOnlyProvider() {
  return new ethers.JsonRpcProvider(RPC_URL);
}

export function getContractInstance(provider: any) {
  return new ethers.Contract(CONTRACT_ADDRESS, FRENS_POOL_ABI, provider);
}

export async function getSigner(provider: any) {
  return await provider.getSigner();
}
```

**Create Pool Example**

```ts
export async function createPoolOnChain(
  provider: any,
  question: string,
  deadline: string,
  buyInAmount: string,
  oracleType = 2,
  chainlinkFeed = ethers.ZeroAddress,
  targetPrice = "0",
  isGreaterThan = false,
): Promise<{ success: boolean; txHash: string }> {
  const deadlineTimestamp = Math.floor(new Date(deadline).getTime() / 1000);
  const buyInWei = ethers.parseEther(buyInAmount);
  const signer = await getSigner(provider);
  const contract = getContractInstance(signer);

  const tx = await contract.createPool(
    question,
    deadlineTimestamp,
    oracleType,
    chainlinkFeed,
    targetPrice,
    isGreaterThan,
    { value: buyInWei }
  );

  await tx.wait();
  return { success: true, txHash: tx.hash };
}
```

***

This documentation will continue to evolve as FrensPool adds features, optimizations, and mainnet support. For full ABI, helper functions, and additional integrations (e.g., Farcaster mini-app context), refer to the `frenspool-dev-kit` repo.