IEscrow

The IEscrow interface defines the data structures and function signatures used by the Escrow contract. It helps external contracts and interfaces interact with the escrow in a standardized manner.

interface IEscrow {
    
    /* ============ Structs ============ */

    struct Range {
        uint256 min;  // Minimum value
        uint256 max;  // Maximum value
    }

    struct Deposit {
        address depositor;                          
        IERC20 token;                               
        uint256 amount;                             
        Range intentAmountRange;                    
        bool acceptingIntents;                      
        uint256 remainingDeposits;                  
        uint256 outstandingIntentAmount;            
        bytes32[] intentHashes;                     
    }

    struct Currency {
        bytes32 code;                // keccak256 hash of the currency code
        uint256 conversionRate;      // Conversion rate of deposit token to fiat currency
    }

    struct DepositVerifierData {
        address intentGatingService; // Optional gating service for verifying off-chain eligibility
        string payeeDetails;         // Payee details (hash or raw) that the verifier can parse
        bytes data;                  // Additional data needed for payment verification
    }

    struct Intent {
        address owner;               
        address to;                  
        uint256 depositId;           
        uint256 amount;             
        uint256 timestamp;           
        address paymentVerifier;     
        bytes32 fiatCurrency;        
        uint256 conversionRate;      
    }

    struct VerifierDataView {
        address verifier;
        DepositVerifierData verificationData;
        Currency[] currencies;
    }

    struct DepositView {
        uint256 depositId;
        Deposit deposit;
        uint256 availableLiquidity;  
        VerifierDataView[] verifiers;
    }

    struct IntentView {
        bytes32 intentHash;
        Intent intent;
        DepositView deposit;
    }

    function getDepositFromIds(uint256[] memory _depositIds) external view returns (DepositView[] memory depositArray);
}

Structs

• Range Defines a minimum and maximum value. Used for intentAmountRange.

• Deposit Describes all state and configuration data for a given deposit:

  • address depositor – Who created the deposit.

  • IERC20 token – Which token (ERC-20) is deposited.

  • uint256 amount – How many tokens are locked in escrow.

  • Range intentAmountRange – The minimum and maximum each intent can claim.

  • bool acceptingIntents – Whether new intents can be created for this deposit.

  • uint256 remainingDeposits – The current unclaimed amount.

  • uint256 outstandingIntentAmount – Total amount locked by open/active intents.

  • bytes32[] intentHashes – An array of active intent identifiers.

• Currency

  • bytes32 code – The currency code hashed via keccak256 (e.g. "USD" -> keccak256("USD")).

  • uint256 conversionRate – Conversion between deposit token and this currency.

• DepositVerifierData

  • address intentGatingService – Optional gating service that signs off on user eligibility for an intent.

  • string payeeDetails – The string that identifies the payee or payee details.

  • bytes data – Additional proof or attestation data required for the payment verifier.

• Intent

  • address owner – The address that initiated the intent (the potential off-chain payer).

  • address to – Address that will receive on-chain funds if the intent is fulfilled.

  • uint256 depositId – Reference to which deposit this intent targets.

  • uint256 amount – Amount of the deposit’s token to be claimed.

  • uint256 timestamp – Block timestamp when the intent was created.

  • address paymentVerifier – Which verifier is used to check off-chain payment.

  • bytes32 fiatCurrency – The keccak256 hash of the off-chain currency code (e.g., USD).

  • uint256 conversionRate – The rate used for off-chain-to-on-chain value conversion.

• VerifierDataView

  • Binds a verifier address to its DepositVerifierData and an array of Currency structures.

• DepositView

  • uint256 depositId

  • Deposit deposit – The core deposit data.

  • uint256 availableLiquidity – The effective unclaimed deposit (accounting for prunable/expired intents).

  • VerifierDataView[] verifiers – An array of verifiers and their supported currencies.

• IntentView

  • bytes32 intentHash – Unique identifier for the intent.

  • Intent intent – The Intent struct.

  • DepositView deposit – Information about the deposit that the intent is targeting.