Smart Contracts

address public implementation;
address public agentRegistry;
address public feeManager;
address public treasury;
mapping(address => bool) public isEscrow;

function createEscrow(
    bytes32 userSalt,
    address seller,
    address agent,           // address(0) for locked
    address token,
    uint256 amount,
    uint256 buyerProtectionTime,
    bytes32 termsHash,
    uint256 version,
    address expectedEscrow   // Safety check
) external returns (address escrow);

function quoteCreateEscrow(
    bytes32 userSalt,
    address seller,
    address agent,
    address token,
    uint256 amount,
    uint256 buyerProtectionTime
) external view returns (
    address predictedAddress,
    uint256 creationFee,
    uint256 assignmentFee
);

struct Agent {
    bool registered;
    bool available;
    uint256 stablecoinStake;
    uint256 tokenStake;
    uint256 assignmentFeeBps;
    uint256 disputeFeeBps;
    uint256 activeCases;
    uint256 lastCaseTimestamp;
}
mapping(address => Agent) public agents;

function register(
    uint256 stablecoinAmount,
    uint256 tokenAmount,
    uint256 assignmentFeeBps,
    uint256 disputeFeeBps
) external;

function addStake(uint256 stablecoinAmount, uint256 tokenAmount) external;
function withdrawStake(uint256 stablecoinAmount, uint256 tokenAmount) external;

function validateAgentForContract(
    address agent,
    uint256 contractValueWad  // 18-decimal normalized
) external view returns (bool);

struct TokenConfig {
    bool whitelisted;
    uint8 decimals;
    uint256 creationFeeBps;
    uint256 minCreationFee;
    uint256 maxCreationFee;
}
mapping(address => TokenConfig) public tokenConfigs;

function quoteCreationFee(
    address token,
    uint256 amount
) external view returns (uint256 fee);

rawFee = amount * feeBps / 10000
fee = clamp(rawFee, minFee, maxFee)

// Core parties
address public buyer;
address public seller;
address public agent;

// Funds
address public token;
uint256 public amount;

// Time parameters
uint256 public buyerProtectionTime;
uint256 public sellerAcceptDeadline;
uint256 public fulfilledAt;

// State
EscrowState public state;
bytes32 public termsHash;

// Split negotiation
uint256 public proposedBuyerBps;
uint256 public proposedSellerBps;
address public splitProposer;

enum EscrowState {
    PENDING,        // 0
    ACTIVE,         // 1
    FULFILLED,      // 2
    RELEASED,       // 3 (terminal)
    REFUNDED,       // 4 (terminal)
    DISPUTED,       // 5
    AGENT_INVITED,  // 6
    SPLIT,          // 7 (terminal)
    AGENT_RESOLVED  // 8 (terminal)
}

function accept() external;  // Seller only, PENDING -> ACTIVE
function decline() external; // Seller only, PENDING -> REFUNDED

function markFulfilled() external; // Seller only, ACTIVE -> FULFILLED

function release() external; // Buyer only, -> RELEASED

function sellerRefund() external; // Seller only, -> REFUNDED

function openDispute() external; // Buyer only, -> DISPUTED

function inviteAgent() external; // Either party, DISPUTED -> AGENT_INVITED

function agentResolve(
    uint256 buyerBps,
    uint256 sellerBps
) external; // Agent only, -> AGENT_RESOLVED

function proposeSplit(uint256 buyerBps, uint256 sellerBps) external;
function approveSplit() external;
function executeSplit() external;

event EscrowCreated(
    address indexed escrow,
    address indexed buyer,
    address indexed seller,
    address agent,
    address token,
    uint256 amount,
    uint256 fee
);

event Accepted(address indexed seller);
event Declined(address indexed seller);
event Fulfilled(address indexed seller, uint256 timestamp);
event Released(address indexed buyer, uint256 amount);
event Refunded(address indexed seller, uint256 amount);
event DisputeOpened(address indexed buyer);
event AgentInvited(address indexed inviter, address agent);
event AgentResolved(address agent, uint256 buyerAmount, uint256 sellerAmount);
event SplitProposed(address indexed proposer, uint256 buyerBps, uint256 sellerBps);
event SplitExecuted(uint256 buyerAmount, uint256 sellerAmount);