Basic Market Making API

This page explains how market makers can interact with the Liquorice RFQ WebSocket API using their own inventory

1. Getting started

Connecting to maker API

• Production: wss://api.liquorice.tech/v1/maker/ws

Include the following headers with the WebSocket request

• Authorization: Basic <base64(maker:token)>

• index (optional) - index of the connected client (between 0 and 9). Allows multiple connections with the same credentials.

The WebSocket server sends Ping message every 30 seconds.

2. Managing token approvals

Standard approvals

Token approval must be granted solely to the Liquorice Balance Manager smart contract address. Giving standard approval is the most gas efficient way to trade. Important note: providing approval to any other Liquorice address outside of Balance Manager may compromise the security of your funds, as it does not guarantee the same level of protection. Approvals should be given strictly to the Balance Manager address.

Permit2

Liquorice integrates with the Uniswap Permit2 contract.

To use Permit2, first grant standard token approval to address: 0x000000000022d473030f116ddee9f6b43ac78ba3

3. Publishing Price Levels

Maker needs to publish indicative quotes (price levels) to the API. These should be published for every supported pair. Note that WETH/USDC and USDC/WETH are considered different pairs and should be published separately.

Published price levels will expire in 30 seconds. Desired frequency of update is no more than once every second.

Schema

{
  messageType: "priceLevels",
  message: {
    chainId: 1,
    baseToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
    quoteToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    levels: [
      ["2999.5", "0.5"],
      ["3000.5", "1"],
      ["3002.0", "2"]
    ], 
    // Optional solver parameter
    // Providing it will make price levels visible only to that solver
    solver?: "solver-name"
  }
}

Assuming that trader wants to swap 2 WETH for USDC, the maker would be buying 0.5 WETH for 2999.5 USDC, 1 WETH for 3000.5 USDC, and another 0.5 WETH for 3002.0 USDC

Your smallest level sets your minimum trade size — RFQs below it are not routed to you, as RFQs above your total depth already are not.

4. Receiving RFQ

When a trader or intent system requests a quote, Liquorice forwards the request to market makers using the following format:

{
  messageType: "rfq";
  message: {
    /// Chain ID (e.g for ArbitrumOne chainId = 42161)
    chainId: number;
    /// Name of the solver requesting the quote
    solver: string;
    /// UUID of the originating solver RFQ
    solverRfqId: string;
    /// UUID of the RFQ
    rfqId: string;
    /// Hex-encoded 32-byte nonce
    nonce: string;
    /// Address of token to be sent by trader
    baseToken: string;
    /// Address of the token to be received by trader
    quoteToken: string;
    /// Address of the account receiving quoteToken   
    trader: string;
    /// Address of the account sending baseToken
    effectiveTrader: string;
    /// Note: Exactly one of the following two fields must be present
    /// Amount of baseToken with up to 18 decimal places, e.g. 100000000 (1 WBTC)
    baseTokenAmount?: string;
    /// Amount of quoteToken with up to 18 decimal places
    quoteTokenAmount?: string;
    /// Reference prices for the requested token pair 
    referencePrices: {
      uniV4?: string
    },
    /// Optional metadata that provides context about the intent origin
    intentMetadata?: {
        source: 'cow_protocol';
        content: { 
            /// CoW auction ID
            auctionId: number;
        }
    }
  };
}

• The RFQ will include either baseTokenAmount or quoteTokenAmount, but not both.

  • When baseTokenAmount is specified, the trader (order initiator) is requesting the amount of quoteToken they would receive in exchange for a specific amount of baseToken.

  • When quoteTokenAmount is specified, the trader (order initiator) is requesting the amount of baseToken they need to provide to receive a specific amount of quoteToken.

• intentMetadata - For the moment, only CoW Protocol is supported. If this parameter is absent, it means that the quote is requested for another intent system.

5. Providing Quote

Send the quote response through the same WebSocket connection using the following format:

{
  messageType: "rfqQuote",
  message: {
    /// UUID of the RFQ (must match rfqId of the received RFQ message)
    rfqId: string,
    /// Quote levels
    levels: [{...}]
  }
}

Market makers can provide multiple quote levels with different amounts, but the quoted amounts must not exceed those specified in the RFQ.

Example For an RFQ where:

• baseToken = ETH

• quoteToken = USDT

• baseTokenAmount = 1 ETH

The resulting quote may contain these levels:

Level 0: Exchange 1 ETH for 3,000 USDT

Level 1: Exchange 0.5 ETH for 1,502 USDT

Level 2: Exchange 0.1 ETH for 310 USDT

Quote level Lite

Use this type of quote level for simple and gas-efficient swaps.

Note: supports only Standard approvals

{
    /// Type identifier for the quote level
    type: "lite",
    /// Quote level expiration UNIX timestamp (seconds)
    expiry: number,
    /// Address of the LiquoriceSettlement contract
    settlementContract: string,
    /// Address of the signign account.
    /// The quoteToken will be transferred from this address during the settlement
    signer: string,
    /// Optional address of the baseToken recipieint
    /// If omitted, the signer address will be used as the recipient
    recipient?: string,
    /// Address of token to be sent by trader
    baseToken: string,
    /// Address of the token to be received by trader
    quoteToken: string,
    /// Amount of baseToken with up to 18 decimal places, e.g. 100000000 (1 WBTC)
    baseTokenAmount: string,
    /// Amount of quoteToken with up to 18 decimal places
    quoteTokenAmount: string,
    /// Minimum amount of quoteToken to receive for partial fills,
    /// with up to 18 decimal places
    minQuoteTokenAmount?: string,
    /// 0x-prefixed signature for this quote level
    signature: string,
}

Signature schema

The following Solidity code demonstrates how to create an EIP-712 signature by hashing RFQ and quote level data.

To implement this in your preferred programming language, port the code below and populate values from the corresponding RFQ and quote level objects.

bytes32 constant EIP712_DOMAIN_TYPEHASH = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;

bytes32 constant SINGLE_ORDER_TYPEHASH = keccak256(
  'Single(string rfqId,uint256 nonce,address trader,address effectiveTrader,address baseToken,address quoteToken,uint256 baseTokenAmount,uint256 quoteTokenAmount,uint256 minFillAmount,uint256 quoteExpiry,address recipient)'
);

bytes32 constant DOMAIN_NAME = keccak256('LiquoriceSettlement');
bytes32 constant DOMAIN_VERSION = keccak256('2'); 
bytes32 constant DOMAIN_SEPARATOR = keccak256(
  abi.encode(
    EIP712_DOMAIN_TYPEHASH,
    DOMAIN_NAME,
    DOMAIN_VERSION,
    block.chainid, // rfq.chainId
    address(this)  // quoteLevel.settlementContract
  )
);

bytes32 hash = keccak256(
 abi.encodePacked(
   '\x19\x01',
   DOMAIN_SEPARATOR,
   keccak256(
     // split into two chunks to avoid stack too deep — the split is part of
     // the encoding only, the result is a plain concatenation
     bytes.concat(
       abi.encode(
         SINGLE_ORDER_TYPEHASH,
         keccak256(bytes(_order.rfqId)),        // rfq.rfqId
         _order.nonce,                          // rfq.nonce
         _order.trader                          // rfq.trader
       ),
       abi.encode(
         _order.effectiveTrader,                // rfq.effectiveTrader
         _order.baseToken,                      // quoteLevel.baseToken
         _order.quoteToken,                     // quoteLevel.quoteToken
         _order.baseTokenAmount,                // quoteLevel.baseTokenAmount
         _order.quoteTokenAmount,               // quoteLevel.quoteTokenAmount
         _order.minFillAmount,                  // quoteLevel.minQuoteTokenAmount ?? quoteTokenAmount
         _order.quoteExpiry,                    // quoteLevel.expiry
         _order.recipient                       // quoteLevel.recipient ?? quoteLevel.signer
       )
     )
   )
 )
);

Sign the resulting hash with the signer's private key.

Check yourself

Use the following example to verify your hashing implementation. The RFQ and quote level payloads below should produce this hash:

0xb28994f0cadae3455a0045443e89ed48fa30925bd7ec994738a498c2882fb007

// RFQ part of the hash
{
  "chainId": 42161,
  "rfqId": "c99d2e3f-702b-49c9-8bb8-43775770f2f3",
  "nonce": "0000000000000000000000000000000000000000000000000000000000000000",
  "trader": "0x48426Ef27C3555D44DACDD647D8f9bd0A7C06155",
  "effectiveTrader": "0x033F42e758cEbEbC70Ee147F56ff92C9f7CA45F4"
}

// Quote level part of the hash
{
  "settlementContract": "0x48426Ef27C3555D44DACDD647D8f9bd0A7C06155",
  "signer": "0x29AF25A562c618f1DC70d675d4d505C8821bD092",
  "recipient": "0x033F42e758cEbEbC70Ee147F56ff92C9f7CA45F4",
  "baseToken": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
  "quoteToken": "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
  "baseTokenAmount": "1",
  "quoteTokenAmount": "2",
  "minQuoteTokenAmount": "1",
  "expiry": 1715787259
}

Quote level Extended

Use this quote level type for customizations that require hooks and interactions.

It supports both Standard and Permit2 approvals.

{
    /// Type identifier for the quote level
    type: "ext",
    /// Quote level expiration UNIX timestamp (seconds)
    expiry: number,
    /// Address of the LiquoriceSettlement contract
    settlementContract: string,
    /// Address of the signign account.
    /// The quoteToken will be transferred from this address during the settlement
    signer: string,
    /// Optional address of the baseToken recipieint
    /// If omitted, system will assume that `signer` is the baseToken recipient
    recipient?: string,
    /// Data of token to be sent by trader
    baseTokenData: {
        /// Token address
        address: string,
        /// Total amount of baseToken to take from effectiveTrader,
        /// with up to 18 decimal places
        amount: string,     
        /// Part of the amount to transfer to the recipieint
        toRecipient?: string,
        /// Part of the amount to repay token debt with
        toRepay?: string,
        /// Part of the amount to supply as collateral
        toSupply?: string, 
    },
    /// Data of token to be received by trader
    quoteTokenData: {
        /// Token address
        address: string,
        /// Total amount of quoteToken to take from signer,
        /// with up to 18 decimal places
        amount: string,
        /// Minimum amount of quoteToken to take for partial fills,
        minAmount?: string,     
        /// Part of the amount to be transferred from `signer`
        toTrader?: string,
        /// Part of the amount to be filled by withdrawing collateral
        toWithdraw?: string,
        /// Part of the amount to be filled by borrowing
        toBorrow?: string,
    },
    // Optional before hooks to execute on settlement
    beforeHooks?: [{
        to: string,
        calldata: string,
        value": "string,
    }],
    // Optional interactions to execute on settlement
    interactions?: [{
        to: string,
        calldata: string,
        value": "string,
    }],
    // Optional after hooks to execute on settlement
    afterHooks?: [{
        to: string,
        calldata: string,
        value": "string,
    }],
    /// Token approval type: "Standard" or "Permit2".
    /// If omitted, standard approval will be used
    approvalType?: string,
    /// 0x-prefixed signature for this quote level
    signature: string,
}

Signature schema

The following Solidity code demonstrates how to create an EIP-712 signature by hashing RFQ and quote level data.

To implement this in your preferred programming language, port the code below and populate values from the corresponding RFQ and quote level objects.

bytes32 constant EIP712_DOMAIN_TYPEHASH = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;

bytes32 constant SETTLE_ORDER_TYPEHASH = keccak256(
  'Order(string rfqId,uint256 nonce,address trader,address effectiveTrader,uint256 quoteExpiry,address recipient,uint256 minFillAmount,uint8 makerFlags,BaseTokenData baseTokenData,QuoteTokenData quoteTokenData)BaseTokenData(address addr,uint256 amount,uint256 toRecipient,uint256 toRepay,uint256 toSupply,bool lockedCollateral)QuoteTokenData(address addr,uint256 amount,uint256 toTrader,uint256 toWithdraw,uint256 toBorrow,bool lockedCollateral)'
);
bytes32 constant BASE_TOKEN_DATA_TYPEHASH = keccak256(
  'BaseTokenData(address addr,uint256 amount,uint256 toRecipient,uint256 toRepay,uint256 toSupply,bool lockedCollateral)'
);
bytes32 constant QUOTE_TOKEN_DATA_TYPEHASH = keccak256(
  'QuoteTokenData(address addr,uint256 amount,uint256 toTrader,uint256 toWithdraw,uint256 toBorrow,bool lockedCollateral)'
);

bytes32 constant DOMAIN_NAME = keccak256('LiquoriceSettlement');
bytes32 constant DOMAIN_VERSION = keccak256('2'); // CHANGED: was '1'
bytes32 constant DOMAIN_SEPARATOR = keccak256(
  abi.encode(
    EIP712_DOMAIN_TYPEHASH,
    DOMAIN_NAME,
    DOMAIN_VERSION,
    block.chainid, // rfq.chainId
    address(this)  // quoteLevel.settlementContract
  )
);

// Hash base token data
bytes32 baseTokenDataHash = keccak256(
  abi.encode(
    BASE_TOKEN_DATA_TYPEHASH,
    _baseTokenData.addr,        // quoteLevel.baseTokenData.address
    _baseTokenData.amount,      // quoteLevel.baseTokenData.amount
    _baseTokenData.toRecipient, // quoteLevel.baseTokenData.toRecipient ?? 0
    _baseTokenData.toRepay,     // quoteLevel.baseTokenData.toRepay     ?? 0
    _baseTokenData.toSupply,    // quoteLevel.baseTokenData.toSupply    ?? 0
    true                        // Use locked collateral, always true
  )
);

// Hash quote token data
bytes32 quoteTokenDataHash = keccak256(
  abi.encode(
    QUOTE_TOKEN_DATA_TYPEHASH,
    _quoteTokenData.addr,       // quoteLevel.quoteTokenData.address
    _quoteTokenData.amount,     // quoteLevel.quoteTokenData.amount
    _quoteTokenData.toTrader,   // quoteLevel.quoteTokenData.toTrader   ?? 0
    _quoteTokenData.toWithdraw, // quoteLevel.quoteTokenData.toWithdraw ?? 0
    _quoteTokenData.toBorrow,   // quoteLevel.quoteTokenData.toBorrow   ?? 0
    true                        // Use locked collateral, always true
  )
);

// Assemble resulting hash
bytes32 hash = keccak256(
  abi.encodePacked(
    '\x19\x01',
    DOMAIN_SEPARATOR,
    keccak256(
      bytes.concat(
        abi.encode(
          SETTLE_ORDER_TYPEHASH,
          keccak256(bytes(_order.rfqId)),  // rfq.rfqId
          _order.nonce,                    // rfq.nonce
          _order.trader,                   // rfq.trader
          _order.effectiveTrader,          // rfq.effectiveTrader
          _order.quoteExpiry,              // quoteLevel.expiry
          _order.recipient,                // quoteLevel.recipient ?? quoteLevel.signer
          _order.minFillAmount,            // resolved quoteLevel.quoteTokenData.minAmount
          1                                // Maker flags, always 1
        ),
        baseTokenDataHash,
        quoteTokenDataHash
      )
    )
  )
);

Sign the resulting hash with the signer's private key.

Check yourself

Use the following example to verify your hashing implementation. The RFQ and quote level payloads below should produce this hash:

0x26865cac5f41bd33fb0056da7d6a79082976eaf10d10f8fb01f8f436ae8b0249

// RFQ part of the hash
{
  "chainId": 42161,
  "rfqId": "c99d2e3f-702b-49c9-8bb8-43775770f2f3",
  "nonce": "0000000000000000000000000000000000000000000000000000000000000000",
  "trader": "0x48426Ef27C3555D44DACDD647D8f9bd0A7C06155",
  "effectiveTrader": "0x033F42e758cEbEbC70Ee147F56ff92C9f7CA45F4"
}

// Quote level part of the hash
{
  "settlementContract": "0x48426Ef27C3555D44DACDD647D8f9bd0A7C06155",
  "signer": "0x29AF25A562c618f1DC70d675d4d505C8821bD092",
  "recipient": "0x033F42e758cEbEbC70Ee147F56ff92C9f7CA45F4",
  "expiry": 1715787259,
  "baseTokenData": {
    "address": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
    "amount": "1",
    "toRecipient": "1",
    "toRepay": null,
    "toSupply": null
  },
  "quoteTokenData": {
    "address": "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
    "amount": "2",
    "minAmount": "1",
    "toTrader": "1",
    "toWithdraw": null,
    "toBorrow": null
  }
}

Using lending pools

Liquorice allows market makers to settle trades using borrowed funds, provided they have posted collateral equal to at least 25% of the quoted amount.

Consider the following example: a market maker receives an RFQ where a trader intends to exchange WETH for USDC. If the market maker does not have USDC in their inventory, they can borrow it from the lending pool—assuming they have supplied collateral (in any token) worth at least 25% of the quoted USDC amount.

For instance, if the quote is to exchange 0.3 WETH for 1,000 USDC, the market maker can post 250 USDT as collateral and borrow 1,000 USDC from the pool.

When the trade is settled, the 0.3 WETH will be added to the locked collateral alongside the market maker’s initially supplied 250 USDT. As a result, the market maker’s position in the pool will consist of 0.3 WETH and 250 USDT as locked collateral, with 1,000 USDC as outstanding debt.

To settle a trade using borrowed funds, the market maker must use the Extended Quote level and specify token amounts in the toSupply field of baseTokenData and the toBorrow field of quoteTokenData.

• baseTokenData.toSupply: the amount (e.g., 0.3 WETH) that the trader will supply and which will be added to the locked collateral on behalf of the market maker.

• quoteTokenData.toBorrow: the amount (e.g., 1,000 USDC) to be borrowed on behalf of the market maker and sent to the trader.

The system will automatically generate the transaction payload and forward it to the origin of the intent.

To withdraw the 0.3 WETH collateral, the market maker must first repay a sufficient portion of the 1,000 USDC debt.

6. Error handling

If the quote payload is not valid, WS API will send a message in the following format

{
  messageType: "error",
  message: {
    /// Type of the error — see table below
    type: string,
    /// Type-specific metadata; absent for `bad_payload`
    metadata?: object,
    /// Human-readable error message
    message: string,
  },
  timestamp: number
}

type	When it is sent	metadata
bad_payload	The message could not be deserialized at all	(absent)
quote_validation	A quote level failed validation (token/settlement mismatch, amount bounds, sum invariants, signature recovery mismatch, level count)	{ rfq_id }
quote_deadline	The quote arrived after the aggregator stopped waiting for this RFQ	{ rfq_id }
quote_simulation	The quote was well-formed but failed on-chain simulation	{ rfq_id, data } — data is the optional revert payload
missing_rfq	rfqId does not match any live RFQ (unknown, or already answered/expired)	{ rfq_id }
price_submission	A priceLevels message was rejected (bad levels, unknown solver, unsupported chain)	{ chain_id, base_token, quote_token }
quote_slippage	Quote price deviates from your own submitted price levels	{ rfq_id, actual_bps, max_bps }

Example

{
  "messageType": "error",
  "message": {
    "type": "quote_validation",
    "metadata": { "rfq_id": "c61c7b1d-86fa-402e-ba12-fb49c9c55cf8" },
    "message": "Signature recovered address does not match effective signer"
  },
  "timestamp": 1755075969000
}

7. Receiving notifications

{
  messageType: "notification";
  message: {
    type: "settlement" | "suspension";
    metadata: { ... };
  };
  timestamp: number;
}

Notification types

Settlement

Sent when RFQ is about to be settled on-chain

{
  "messageType": "notification",
  "message": {
    "type": "settlement",
    "metadata": {
      "rfqId": "c61c7b1d-86fa-402e-ba12-fb49c9c55cf8",
      "timestamp": 1755075969000
    }
  },
  "timestamp": 1755075969100
}

Suspension

Sent when the aggregator temporarily stops routing RFQs to you because your quote availability fell below the expected ratio. RFQs resume automatically after until

{
  "messageType": "notification",
  "message": {
    "type": "suspension",
    "metadata": {
      "until": 1755075969000,
      "reason": "quote_availability",
      "details": {
        "solverName": "solver-name",
        "chainId": 1,
        "actual": 0.25,
        "expected": 0.9
      }
    }
  },
  "timestamp": 1755075969100
}

8. Getting quote summary

Use the following endpoint to retrieve an extended information for the provided quote. Quote summary includes information such as originating solver RFQ and resulting solver quote with the competing quote levels from other market makers, and settlement result if the resulting solver quote was used to settle the trade on-chain.

URL: https://api.liquorice.tech/v1/maker/quote-summaries/{rfq-id}

Method: GET

Response

{
    "originatingSolverRfq": {
        "receivedAt": 1749207556472,
        "rfqId": "e6125d14-989e-4d67-acb5-64c883656203",
        "intentMetadata": {
            "source": "cow_protocol",
            "content": {
                "auctionId": 10696411
            }
        }
    },
    "makerRfq": {
        "sentAt": 1749207556483,
        "solver": "solver_name",
        "nonce": "5ee0634e178b21c9524e383a155ff26b0fd4b852c7de99c8c16886a229827dba",
        "chainId": 1,
        "expiry": 1749207586000,
        "baseToken": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        "baseTokenAmount": "100000000000",
        "quoteToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
        "quoteTokenAmount": null,
        "trader": "0xA6775ae22067D71FaE76E22Fa377Cfb38f223F0D",
        "effectiveTrader": null
    },
    "makerQuote": {
        "receivedAt": 1749207556534,
        "levels": [
            {
                "baseTokenAmount": "100000000000",
                "quoteTokenAmount": "100000000",
                "signer": "0xf7e93CC543d97af6632c9b8864417379dBa4bf15",
                "recipient": null,
                "expiry": 1749207586000,
                "minQuoteTokenAmount": null
            }
        ],
        "status": "settle",
        "transactionHash": "0x0c516419523f44ddc6b1877973d0c665734f4f7794c2749b4ec5e80821dc0358"
    },
    "resultingSolverQuote": {
        "sentAt": 1749207556542,
        "userLevels": [
            {
                "baseTokenAmount": "100000000000",
                "quoteTokenAmount": "100000000",
                "signer": "0xf7e93CC543d97af6632c9b8864417379dBa4bf15",
                "recipient": null,
                "expiry": 1749207586000,
                "minQuoteTokenAmount": null,
                "minBaseTokenAmount": null
            }
        ],
        "competingLevels": [
            {
                "baseTokenAmount": "100000000000",
                "quoteTokenAmount": "99999999",
                "expiry": 1749207586000,
                "minQuoteTokenAmount": null,
                "minBaseTokenAmount": null
            }
        ]
    },
    "settlementResult": {
        "winningSolutions": [
            {
                "transactionHash": "0xa5ec72c1fe8cfcfea410ce4a854beddb7d23492861d41435c6e892cba39db6bc",
                "orders": [
                    {
                        "baseToken": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
                        "quoteToken": "0x539bdE0d7Dbd336b79148AA742883198BBF60342",
                        "baseTokenAmount": "56866",
                        "quoteTokenAmount": "465593933993483323"
                    },
                    {
                        "baseToken": "0x539bdE0d7Dbd336b79148AA742883198BBF60342",
                        "quoteToken": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
                        "baseTokenAmount": "465593933993483323",
                        "quoteTokenAmount": "56866"
                    }
                ]
            },
            {
                "transactionHash": "0x0c516419523f44ddc6b1877973d0c665734f4f7794c2749b4ec5e80821dc0358",
                "orders": [
                    {
                        "baseToken": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
                        "quoteToken": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
                        "baseTokenAmount": "100000000000",
                        "quoteTokenAmount": "100000000"
                    }
                ]
            }
        ]
    }
}

• makerQuote.status can be one of live, settled, expired or missedDeadline

• field settlementResult shows data on on final settlement which can be used, for example, to compare price provided by you with the winning price. If this field is "null", it normally means that settlement did not occur

• field competing levels shows prices provided by other liquidity sources connected to Liquorice

9. Getting info on settled trades

When a trade executes on-chain, the Liquorice settlement contract emits a TraderOrder event containing information about transferred amounts. The event reflects actual token transfers, including cases of partial fills, and always shows the final amounts transferred on-chain.

event TradeOrder(
  string indexed rfqId,
  address trader,
  address effectiveTrader,
  address signer,           
  address baseToken,
  address quoteToken,
  uint256 baseTokenAmount,
  uint256 quoteTokenAmount,
  address recipient         
);

Note: rfqId is indexed and is a dynamic string, so the log topic is keccak256(rfqId), not the readable UUID. The unhashed value is not available from the log — match on the topic hash.