Start Solving

Catalyst is an entirely permissionless system. Since the system is componentized and components have no inherent trust elements with other components, they can be mixed and matched as desired by users. As a result, it is important that you validate orders in their entirety once received.

The general Catalyst flow is as follows:

1. The sponsor signs a Catalyst-compatible lock and sends it to the Catalyst order server.

2. The Catalyst order server preliminarily validates the order and obtains the allocator co-signature for the order. It is then broadcasted to solvers.

3. A solver submits the order’s output to the output settlement contract, starting the verification layer.

   Output Settlement

   The output settlement is denoted as the remoteFiller in the order struct.

4. The proof is delivered to the input chain through the validation layer.

   Validation Layer

   The validation layer is denoted as the localOracle and remoteOracle in the order struct.

5. The solver submits the order to the input settlement contract, verifying the delivery and unlocking the associated input tokens.

Orders

The Catalyst system does not define a strict order type, and as a result, there will be differences in how orders are expressed in various systems. Currently, only one order description is supported across all VMs:

struct CatalystCompactOrder {
    address user;
    uint256 nonce;
    uint256 originChainId;
    uint32 fillDeadline;
    address localOracle;
    uint256[2][] inputs;
    OutputDescription[] outputs;
}

Where uint256[2][] inputs === [uint256 tokenId, uint256 amount][] and OutputDescription:

struct OutputDescription {
    bytes32 remoteOracle;
    bytes32 remoteFiller;
    uint256 chainId;
    bytes32 token;
    uint256 amount;
    bytes32 recipient;
    bytes remoteCall;
    bytes fulfillmentContext;
}

The CatalystCompactOrder will be used to interface all functions on the input chain. Additionally, once hydrated with a signature, it allows one to verify the validity of an order.

The CatalystCompactOrder struct will be signed and stored as a witness in the appropriate lock/claim structure. For TheCompact, this is:

struct BatchCompact {
    address arbiter; // Associated settlement contract
    address sponsor; // CatalystCompactOrder.user
    uint256 nonce; // CatalystCompactOrder.nonce
    uint256 expires; // CatalystCompactOrder.fillDeadline
    uint256[2][] idsAndAmounts; // CatalystCompactOrder.inputs
    CatalystWitness witness;
}

struct CatalystWitness {
    uint32 fillDeadline; // CatalystCompactOrder.fillDeadline
    address localOracle; // CatalystCompactOrder.localOracle
    OutputDescription[] outputs; // CatalystCompactOrder.outputs
}

To validate an order, ensure that the sponsor and allocator signatures are valid for this EIP-712 signed structure.