BoundlessMarket

Inherits: IBoundlessMarket, Initializable, EIP712Upgradeable, Ownable2StepUpgradeable, UUPSUpgradeable

State Variables

VERSION

The version of the contract, with respect to upgrades.

uint64 public constant VERSION = 1;

requestLocks

mapping(RequestId => RequestLock) public requestLocks;

accounts

mapping(address => Account) internal accounts;

VERIFIER

Note: oz-upgrades-unsafe-allow: state-variable-immutable

IRiscZeroVerifier public immutable VERIFIER;

ASSESSOR_ID

Note: oz-upgrades-unsafe-allow: state-variable-immutable

bytes32 public immutable ASSESSOR_ID;

imageUrl

string private imageUrl;

STAKE_TOKEN_CONTRACT

Note: oz-upgrades-unsafe-allow: state-variable-immutable

address public immutable STAKE_TOKEN_CONTRACT;

FULFILL_MAX_GAS_FOR_VERIFY

In order to fulfill a request, the prover must provide a proof that can be verified with at most the amount of gas specified by this constant. This requirement exists to ensure the client can then post the given proof in a new transaction as part of the application.

uint256 public constant FULFILL_MAX_GAS_FOR_VERIFY = 50000;

SLASHING_BURN_FRACTION_NUMERATOR

When a prover is slashed for failing to fulfill a request, a portion of the stake is burned, and a portion is sent to the client. This fraction controls that ratio.

uint256 public constant SLASHING_BURN_FRACTION_NUMERATOR = 1;

SLASHING_BURN_FRACTION_DENOMINATOR

uint256 public constant SLASHING_BURN_FRACTION_DENOMINATOR = 1;

MARKET_FEE_NUMERATOR

When an order is fulfilled, the market takes a fee based on the price of the order. This fraction is multiplied by the price to decide the fee.

The fee is configured as a constant to avoid accessing storage and thus paying for the gas of an SLOAD. This means the fee can only be changed by an implementation upgrade. Note that it is currently set to zero.

uint256 public constant MARKET_FEE_NUMERATOR = 0;

MARKET_FEE_DENOMINATOR

uint256 public constant MARKET_FEE_DENOMINATOR = 1;

marketBalance

Balance owned by the market contract itself. This balance is collected from fees, when the fee rate is set to a non-zero value.

uint256 internal marketBalance;

Functions

constructor

Note: oz-upgrades-unsafe-allow: constructor

constructor(IRiscZeroVerifier verifier, bytes32 assessorId, address stakeTokenContract);

initialize

function initialize(address initialOwner, string calldata _imageUrl) external initializer;

setImageUrl

function setImageUrl(string calldata _imageUrl) external onlyOwner;

_authorizeUpgrade

function _authorizeUpgrade(address newImplementation) internal override onlyOwner;

submitRequest

function submitRequest(ProofRequest calldata request, bytes calldata clientSignature) external payable;

lockRequest

Lock the request to the prover, giving them exclusive rights to be paid to fulfill this request, and also making them subject to slashing penalties if they fail to deliver. At this point, the price for fulfillment is also set, based on the reverse Dutch auction parameters and the block at which this transaction is processed.

This method should be called from the address of the prover.

function lockRequest(ProofRequest calldata request, bytes calldata clientSignature) external;

lockRequestWithSignature

Lock the request to the prover, giving them exclusive rights to be paid to fulfill this request, and also making them subject to slashing penalties if they fail to deliver. At this point, the price for fulfillment is also set, based on the reverse Dutch auction parameters and the block at which this transaction is processed.

This method uses the provided signature to authenticate the prover.

function lockRequestWithSignature(
    ProofRequest calldata request,
    bytes calldata clientSignature,
    bytes calldata proverSignature
) external;

_lockRequest

Locks the request to the prover. Deducts funds from the client for payment and funding from the prover for locking stake.

function _lockRequest(
    ProofRequest calldata request,
    bytes32 requestDigest,
    address client,
    uint32 idx,
    address prover,
    uint64 deadline
) internal;

priceRequest

Validates the request and records the price to transient storage such that it can be fulfilled within the same transaction without taking a lock on it.

function priceRequest(ProofRequest calldata request, bytes calldata clientSignature) public;

verifyDelivery

Verify the application and assessor receipts, ensuring that the provided fulfillment satisfies the request.

function verifyDelivery(Fulfillment calldata fill, bytes calldata assessorSeal, address prover) public view;

verifyBatchDelivery

Verify the application and assessor receipts for the batch, ensuring that the provided fulfillments satisfy the requests.

function verifyBatchDelivery(Fulfillment[] calldata fills, bytes calldata assessorSeal, address prover) public view;

fulfill

Fulfill a request by delivering the proof for the application. If the order is locked, only the prover that locked the order may receive payment. If another prover delivers a proof for an order that is locked, this method will revert unless paymentRequired is set to false on the Fulfillment struct.

function fulfill(Fulfillment calldata fill, bytes calldata assessorSeal, address prover) external;

fulfillBatch

Fulfills a batch of requests. See IBoundlessMarket.fulfill for more information.

function fulfillBatch(Fulfillment[] calldata fills, bytes calldata assessorSeal, address prover) public;

priceAndFulfillBatch

A combined call to IBoundlessMarket.priceRequest and IBoundlessMarket.fulfillBatch. The caller should provide the signed request and signature for each unlocked request they want to fulfill. Payment for unlocked requests will go to the provided prover address.

function priceAndFulfillBatch(
    ProofRequest[] calldata requests,
    bytes[] calldata clientSignatures,
    Fulfillment[] calldata fills,
    bytes calldata assessorSeal,
    address prover
) external;

_fulfillVerified

Complete the fulfillment logic after having verified the app and assessor receipts.

function _fulfillVerified(RequestId id, bytes32 requestDigest, address assessorProver, bool requirePayment) internal;

_fulfillVerifiedLocked

function _fulfillVerifiedLocked(
    RequestId id,
    address client,
    uint32 idx,
    bytes32 requestDigest,
    bool fulfilled,
    address assessorProver
) internal returns (bytes memory paymentError);

_fulfillVerifiedUnlocked

function _fulfillVerifiedUnlocked(
    RequestId id,
    address client,
    uint32 idx,
    bytes32 requestDigest,
    bool fulfilled,
    address assessorProver
) internal returns (bytes memory paymentError);

submitRoot

Submit a new root to a set-verifier.

Consider using submitRootAndFulfillBatch to submit the root and fulfill in one transaction.

function submitRoot(address setVerifierAddress, bytes32 root, bytes calldata seal) external;

submitRootAndFulfillBatch

Combined function to submit a new root to a set-verifier and call fulfillBatch.

Useful to reduce the transaction count for fulfillments.

function submitRootAndFulfillBatch(
    address setVerifier,
    bytes32 root,
    bytes calldata seal,
    Fulfillment[] calldata fills,
    bytes calldata assessorSeal,
    address prover
) external;

slash

When a prover fails to fulfill a request by the deadline, this method can be used to burn the associated prover stake.

function slash(RequestId requestId) external;

imageInfo

Returns the assessor imageId and its url.

function imageInfo() external view returns (bytes32, string memory);

deposit

Deposit Ether into the market to pay for proof.

Value deposited is msg.value and it is credited to the account of msg.sender.

function deposit() public payable;

withdraw

Withdraw Ether from the market.

Value is debited from msg.sender.

function withdraw(uint256 value) public;

balanceOf

Check the deposited balance, in Ether, of the given account.

function balanceOf(address addr) public view returns (uint256);

depositStake

Deposit stake into the market to pay for lockin stake.

Before calling this method, the account owner must approve the contract as an allowed spender.

function depositStake(uint256 value) external;

depositStakeWithPermit

Permit and deposit stake into the market to pay for lockin stake.

This method requires a valid EIP-712 signature from the account owner.

function depositStakeWithPermit(uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;

_depositStake

function _depositStake(address from, uint256 value) internal;

withdrawStake

Withdraw stake from the market.

function withdrawStake(uint256 value) public;

balanceOfStake

Check the deposited balance, in HP, of the given account.

function balanceOfStake(address addr) public view returns (uint256);

accountIsFrozen

Returns the frozen state of an account.

An account gets frozen after a slash occurred. A frozen account cannot lock-in requests. To unlock the account, its owner must call unfreezeAccount.

function accountIsFrozen(address addr) external view returns (bool);

unfreezeAccount

Clear the frozen state of an account, transferring the frozen stake back to the prover's available balance.

function unfreezeAccount() public;

requestIsFulfilled

Check if the given request has been fulfilled (i.e. a proof was delivered).

function requestIsFulfilled(RequestId id) external view returns (bool);

requestIsLocked

Check if the given request has been locked (i.e. accepted) by a prover.

When a request is locked, only the prover it is locked to can be paid to fulfill the job.

function requestIsLocked(RequestId id) external view returns (bool);

requestIsSlashed

Check if the given request resulted in the prover being slashed (i.e. request was locked in but proof was not delivered)

Note it is possible for a request to result in a slash, but still be fulfilled if for example another prover decided to fulfill the request altruistically. This function should not be used to determine if a request was fulfilled.

function requestIsSlashed(RequestId id) external view returns (bool);

requestDeadline

Return when the given request expires.

function requestDeadline(RequestId id) external view returns (uint64);

eip712DomainSeparator

EIP 712 domain separator getter.

function eip712DomainSeparator() external view returns (bytes32);

revertWith

Internal utility function to revert with a pre-encoded error.

function revertWith(bytes memory err) internal pure;