Providing Liquidity

    event SwapCreated(uint256 indexed swapId,
                      address indexed swapper,
                      uint256 sellAmt,
                      address sellToken,
                      uint256 minOut,
                      address buyToken,
                      uint256 minFulfillLiquidity,
                      uint256 expiration,
                      uint256 priceTolerated,
                      uint256 toleranceRange,
                      FulfillFeeParams fulfillFeeParams,
                      uint256 blockTimestamp,
                      OracleParams oracleParams,
                      BountyParams bountyParams,
                      uint256 gasCompensation);

    event SwapMatched(uint256 swapId,
                      uint256 fulfillmentFee,
                      address indexed matcher,
                      uint256 reportId,
                      address indexed swapper);

    struct FulfillFeeParams {
        uint48 startFulfillFeeIncrease; // timestamp at which order is created
        uint24 maxFee; // 1000 = 0.01%, max fulfillment fee you can pay
        uint24 startingFee; // 1000 = 0.01%, starting fee level
        uint24 roundLength; // round length in seconds
        uint16 growthRate; // 15000 = 1.5x per round
        uint16 maxRounds; // max rounds of increase
    }

    function calcFee(uint256 maxFee,
                     uint256 startingFee,
                     uint256 growthRate,
                     uint256 maxRounds,
                     uint256 startFulfillFeeIncrease,
                     uint256 roundLength) internal view returns (uint256) 
    {
        uint256 timeDelta = block.timestamp - startFulfillFeeIncrease;
        
        timeDelta = timeDelta / roundLength;
        if (timeDelta > maxRounds) {
            timeDelta = maxRounds;
        }

        uint256 currentFee = startingFee;

        for (uint256 i = 0; i < timeDelta; i++) {
            currentFee = (currentFee * growthRate) / 10000;
            if (currentFee >= maxFee) {
                return maxFee;
            }
        }
        
        return currentFee;
    }

    struct OracleParams {
        uint256 settlerReward; // settler reward in oracle game. settle function executes the swap.
        uint256 initialLiquidity; // oracle game initial liquidity in sellToken
        uint256 escalationHalt; // amount of sellToken at which oracle game stops escalating
        uint48 settlementTime; // round length of oracle game. if timeType true, in seconds, if false, blocks
        uint48 latencyBailout; // the swap can be canceled and refunded after this number of seconds pass with a matched swap but no oracle game initial report 
        uint48 maxGameTime; // if oracle game takes longer than this time in seconds, refund available. does not respect timeType, i.e., is ALWAYS in seconds
        uint32 blocksPerSecond; // network's blocks per second. 500 means 0.5 blocks per second versus wall clock
        uint24 disputeDelay; // disputes must wait this long after the last report to fire in the oracle game. if timeType true, in seconds, if false, blocks
        uint24 swapFee; // 1000 = 0.01%, swap fee amount paid to prior reporter in oracle game
        uint24 protocolFee; // 1000 = 0.01%, percentage levied of each swap in oracle game for protocolFeeRecipient's benefit.
        uint16 multiplier; // oracle game multiplier, 110 = 1.1x
        bool timeType; // true means oracle game is played in seconds, false for blocks
    }

    struct BountyParams {
        uint256 totalAmtDeposited; // max amount of bountyToken paid in the initial report bounty 
        uint256 bountyStartAmt; // starting amount of bountyToken in the initial report bounty
        uint256 roundLength; // length of time, in seconds, for each escalation round
        address bountyToken; // token bounty is paid in. address(0) is for ETH
        uint16 bountyMultiplier; // amount bounty escalate per round from bountyStartAmt. 14000 = 1.4x per round
        uint16 maxRounds; // maximum rounds of escalation
    }

    event SwapMatched(uint256 swapId,
                      uint256 fulfillmentFee, 
                      address indexed matcher, 
                      uint256 reportId, 
                      address indexed swapper);

function matchSwap(uint256 swapId,
                   bytes32 paramHashExpected)

keccak256(abi.encode(swaps[swapId]));

# How to compute paramHashExpected from SwapCreated event data
# pip install eth_abi web3

from eth_abi import encode
from web3 import Web3

ADDRESS_ZERO = "0x" + "0" * 40

def compute_swap_hash(e):
    # Nested structs must be expanded into tuples
    oracle_tuple = (
        e.oracleParams.settlerReward,
        e.oracleParams.initialLiquidity,
        e.oracleParams.escalationHalt,
        e.oracleParams.settlementTime,
        e.oracleParams.latencyBailout,
        e.oracleParams.maxGameTime,
        e.oracleParams.blocksPerSecond,
        e.oracleParams.disputeDelay,
        e.oracleParams.swapFee,
        e.oracleParams.protocolFee,
        e.oracleParams.multiplier,
        e.oracleParams.timeType
    )
    slippage_tuple = (e.priceTolerated, e.toleranceRange)
    fulfill_tuple = (
        e.fulfillFeeParams.startFulfillFeeIncrease,
        e.fulfillFeeParams.maxFee,
        e.fulfillFeeParams.startingFee,
        e.fulfillFeeParams.roundLength,
        e.fulfillFeeParams.growthRate,
        e.fulfillFeeParams.maxRounds
    )
    bounty_tuple = (
        e.bountyParams.totalAmtDeposited,
        e.bountyParams.bountyStartAmt,
        e.bountyParams.roundLength,
        e.bountyParams.bountyToken,
        e.bountyParams.bountyMultiplier,
        e.bountyParams.maxRounds
    )

    swap_tuple = (
        e.sellAmt, e.minOut, e.minFulfillLiquidity, e.expiration,
        0,                  # reportId (always 0 for new swap)
        e.gasCompensation,
        0,                  # start (always 0)
        0,                  # fulfillmentFee (always 0)
        e.sellToken, e.buyToken, e.swapper,
        ADDRESS_ZERO,       # matcher
        ADDRESS_ZERO,       # feeRecipient
        True, False, False, False,  # active, matched, finished, cancelled
        oracle_tuple, slippage_tuple, fulfill_tuple, bounty_tuple
    )

    SWAP_TYPE = "(uint256,uint256,uint256,uint256,uint256,uint256,uint48,uint24,address,address,address,address,address,bool,bool,bool,bool,(uint256,uint256,uint256,uint48,uint48,uint48,uint32,uint24,uint24,uint24,uint16,bool),(uint256,uint24),(uint48,uint24,uint24,uint24,uint16,uint16),(uint256,uint256,uint256,address,uint16,uint16))"

    return Web3.keccak(encode([SWAP_TYPE], [swap_tuple]))