Discovering Pools

POE supports an unbounded number of pools — one per ordered (tokenX, tokenY) pair. Integrators do not have to hard-code each market: the Factory keeps a registry, so you can enumerate pools or look them up by pair on-chain.

The Factory address is the same on every supported chain (see POE Contracts):

Factory: 0x78120F2C0EBF0cc8B7E7749e62D36e6523dD711D

Factory Lookup API

interface IFactory {
    // Total number of pools ever created.
    function getPoolsLength() external view returns (uint256);

    // Index-based access. `poolId` is in [0, getPoolsLength()).
    function getPoolAt(uint256 poolId) external view returns (address);

    // Look up a pool by its ordered token pair. Returns address(0) if no pool exists.
    function getPool(address tokenX, address tokenY) external view returns (address);

    event PoolCreated(
        uint256 indexed poolId,
        address indexed pool,
        address tokenX,
        address tokenY,
        bytes data
    );
}

The pair ordering matters — getPool(tokenY, tokenX) is a different (typically non-existent) entry from getPool(tokenX, tokenY). Use the same ordering the pool was created with.

Listing every pool

Enumerate [0, getPoolsLength()) and resolve each pool to its token pair:

IFactory factory = IFactory(0x78120F2C0EBF0cc8B7E7749e62D36e6523dD711D);

uint256 n = factory.getPoolsLength();
for (uint256 i = 0; i < n; ++i) {
    address pool = factory.getPoolAt(i);
    (address tokenX, address tokenY) = IBasePool(pool).getTokens();
    // ...
}

The pool exposes the pair via getTokens() (returns the same (tokenX, tokenY) tuple the pool was initialized with) and its current balances via getBalances(). See Tracking Liquidity for the full pool read API.

TypeScript

import { ethers } from 'ethers';

const FACTORY = '0x78120F2C0EBF0cc8B7E7749e62D36e6523dD711D';

const FACTORY_ABI = [
    'function getPoolsLength() view returns (uint256)',
    'function getPoolAt(uint256 poolId) view returns (address)',
    'function getPool(address tokenX, address tokenY) view returns (address)',
];

const POOL_ABI = [
    'function getTokens() view returns (address tokenX, address tokenY)',
    'function getBalances() view returns (uint256 totalX, uint256 totalY)',
];

async function listPools(provider: ethers.Provider) {
    const factory = new ethers.Contract(FACTORY, FACTORY_ABI, provider);
    const n: bigint = await factory.getPoolsLength();

    const pools = await Promise.all(
        Array.from({ length: Number(n) }, async (_, i) => {
            const address: string = await factory.getPoolAt(i);
            const pool = new ethers.Contract(address, POOL_ABI, provider);
            const { tokenX, totalX, tokenY, totalY } =
                Object.assign({}, await pool.getTokens(), await pool.getBalances());
            return { address, tokenX, tokenY, totalX, totalY };
        })
    );

    return pools;
}

Python

from web3 import Web3

FACTORY = '0x78120F2C0EBF0cc8B7E7749e62D36e6523dD711D'

factory_abi = [
    {"name": "getPoolsLength", "type": "function", "inputs": [],
     "outputs": [{"type": "uint256"}], "stateMutability": "view"},
    {"name": "getPoolAt", "type": "function",
     "inputs": [{"name": "poolId", "type": "uint256"}],
     "outputs": [{"type": "address"}], "stateMutability": "view"},
    {"name": "getPool", "type": "function",
     "inputs": [{"name": "tokenX", "type": "address"},
                {"name": "tokenY", "type": "address"}],
     "outputs": [{"type": "address"}], "stateMutability": "view"},
]

pool_abi = [
    {"name": "getTokens", "type": "function", "inputs": [],
     "outputs": [{"name": "tokenX", "type": "address"},
                 {"name": "tokenY", "type": "address"}],
     "stateMutability": "view"},
]

def list_pools(w3: Web3):
    factory = w3.eth.contract(address=w3.to_checksum_address(FACTORY), abi=factory_abi)
    n = factory.functions.getPoolsLength().call()
    pools = []
    for i in range(n):
        address = factory.functions.getPoolAt(i).call()
        pool = w3.eth.contract(address=address, abi=pool_abi)
        token_x, token_y = pool.functions.getTokens().call()
        pools.append({"address": address, "token_x": token_x, "token_y": token_y})
    return pools

Looking up a specific pair

If you already know the ordered pair, skip enumeration:

address pool = factory.getPool(tokenX, tokenY);
require(pool != address(0), "No pool for this pair");

The first ordering you try may not match — pool creation pins a single direction. If getPool(a, b) returns zero, try getPool(b, a) before concluding the pair isn't listed.

Reacting to new pools

Pool creation emits a PoolCreated event from the Factory. Indexers and integrators can subscribe to this to discover new markets without polling:

event PoolCreated(
    uint256 indexed poolId,
    address indexed pool,
    address tokenX,
    address tokenY,
    bytes data
);

poolId is the index used by getPoolAt; data is the per-pool initialization blob (currently maxValue (12 bytes) | oracle (20 bytes)).