Marketplace

Agro Crypto

Commodity markets

Demo · Simulated prices

WHEAT / dUSDC

Best ask · dUSDC/t
Simulated candles · one bar per tick

Order book

Price · dUSDC/tTonnes

Buy commodity

Trade documents
Additional requirements

Demo account

OrderPairTypeTonnesLimit / avg. fillStatusAction

Your orders will appear here.

Demo settlement contract
// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;

// Local teaching token. Its units have no monetary value.
contract DemoDollar {
    string public constant symbol = "dUSDC";
    uint8 public constant decimals = 6;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    constructor(address buyer) { balanceOf[buyer] = 150_000 * 1e6; }
    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }
    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        move(from, to, amount);
        return true;
    }
    function transfer(address to, uint256 amount) external returns (bool) {
        move(msg.sender, to, amount);
        return true;
    }
    function move(address from, address to, uint256 amount) private {
        require(to != address(0));
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
    }
}

contract GrainEscrow {
    enum Stage { Open, Funded, Dispatched, Disputed, Paid, Refunded }
    Stage public stage;
    DemoDollar public immutable token;
    address public immutable buyer;
    address public immutable seller;
    address public immutable reviewer;
    bytes32 public immutable lotKey;
    uint256 public immutable agreedAmount;
    uint256 public immutable agreedTonnes;
    uint256 public constant maxTonnes = 500;
    uint256 public tonnes;
    uint256 public deadline;
    bytes32 public dispatchRecord;
    // Slots 0..8 are the base dossier. Slots 9..14 are contractual conditions.
    uint256 public requiredMask;
    bytes32 public dossierRoot;
    event DossierApproved(bytes32 indexed root, uint256 requiredMask);
    event StageChanged(Stage indexed stage, address indexed actor);
    constructor(DemoDollar token_, address buyer_, address seller_, address reviewer_, bytes32 lot_, uint256 quantity_, uint256 amount_) {
        require(address(token_).code.length > 0);
        require(buyer_ != address(0) && seller_ != address(0) && reviewer_ != address(0));
        require(buyer_ != seller_ && seller_ != reviewer_ && buyer_ != reviewer_);
        require(lot_ != bytes32(0) && quantity_ > 0 && quantity_ <= maxTonnes && amount_ > 0);
        lotKey = lot_; agreedTonnes = quantity_; agreedAmount = amount_;
        token = token_; buyer = buyer_; seller = seller_; reviewer = reviewer_;
    }
    function fund(uint256 quantity, uint256 extras) external {
        require(msg.sender == buyer && stage == Stage.Open);
        require(quantity == agreedTonnes);
        require(extras < (1 << 6));
        requiredMask = 511 | (extras << 9);
        tonnes = quantity; deadline = block.timestamp + 7 days;
        setStage(Stage.Funded);
        require(token.transferFrom(buyer, address(this), agreedAmount));
    }
    function dispatch(bytes32 record) external {
        require(msg.sender == seller && stage == Stage.Funded && block.timestamp < deadline);
        require(record != bytes32(0)); dispatchRecord = record;
        setStage(Stage.Dispatched);
    }
    function approveDossier(bytes32[15] calldata documents, bytes32 manifestHash) external {
        require(msg.sender == reviewer && (stage == Stage.Dispatched || stage == Stage.Disputed));
        require(dossierRoot == bytes32(0) && manifestHash != bytes32(0));
        for (uint256 i = 0; i < documents.length; ++i) {
            bool expected = (requiredMask & (1 << i)) != 0;
            require(expected == (documents[i] != bytes32(0)));
            if (expected) {
                for (uint256 j = 0; j < i; ++j) require(documents[i] != documents[j]);
            }
        }
        dossierRoot = keccak256(abi.encode(address(this), tonnes, requiredMask, documents, manifestHash));
        emit DossierApproved(dossierRoot, requiredMask);
    }
    function acceptDelivery() external {
        require(msg.sender == buyer && stage == Stage.Dispatched);
        settle(true);
    }
    function claimLateRefund() external {
        require(msg.sender == buyer && stage == Stage.Funded && block.timestamp >= deadline);
        settle(false);
    }
    function openDispute() external {
        require((msg.sender == buyer || msg.sender == seller) && stage == Stage.Dispatched);
        setStage(Stage.Disputed);
    }
    function resolve(bool paySeller) external {
        require(msg.sender == reviewer && stage == Stage.Disputed);
        settle(paySeller);
    }
    function settle(bool paySeller) private {
        if (paySeller) require(dossierRoot != bytes32(0));
        setStage(paySeller ? Stage.Paid : Stage.Refunded);
        require(token.transfer(paySeller ? seller : buyer, agreedAmount));
    }
    function setStage(Stage next) private {
        stage = next;
        emit StageChanged(next, msg.sender);
    }
}