Celeste Manifest

The Celeste manifest is not directly integrated with Celeste. In combination with the Disputable base contract however it represents a good standard on how to implement access control for evidence submission. The manifest implements a simple representative system: users can set addresses which are allowed to submit evidence on their behalf in any compatible disputes where they are the challenger / defendant. This is similar to how a lawyer will argue on your behalf in a court of law. The idea behind this is that in the future one may engage actual lawyer like professionals who will argue your case in a Celeste dispute.

By default no one can arbitrarily set anyone else as their representative. The potential representative must first enable clients by using the allowRepresentation method on the manifest.

If you use the Disputable base class you'll by default be using the manifest and will not have to worry about integrating with it. Regardless the manifest itself is documented here to help with integrations, whether it be on the frontend side or via custom smart contract integrations.

ArbitratorManifest API

Constructor

constructor

constructor(address)

Parameters:

• address _disputeManager: the address of the disputeManager instance.

Properties and Getters

disputeManager

disputeManager() -> (address)

Return values:

• address disputeManager_: The address of the Dispute Manager that the Manifest uses to verify which address is the subject of a certain dispute

isRepOf

isRepOf(address, address) -> (bool)

Parameters:

• address _client: account which is to be represented

• address _representative: potential account that may represent the client

Return values:

• bool isRep: whether the given _representative can current represent the given _client. By default false.

canRepresent

canRepresent(address, address) -> (bool)

Parameters:

• address _representative: potential account that may have recused itself in respect to the given client

• address _client: account which may be blocked from being represented by the given _representative

Return values:

• bool allowed: whether the given _representative has allowed the given _client to be its representative.

defendantOf

defendantOf(uint256) -> (address)

Parameters:

• uint256 _disputeId

Return values:

• address defendant: the defendant of the given dispute. Zero address if the dispute does not exist or the dispute subject has not set a defendant in the manifest.

challengerOf

challengerOf(uint256) -> (address)

Parameters:

• uint256 _disputeId

Return values:

• address challenger: the challenger of the given dispute. Zero address if the dispute does not exist or the dispute subject has not set a challenger in the manifest.

canSubmitEvidenceFor

canSubmitEvidenceFor(address, uint256) -> (bool, address)

Parameters:

• address _submitter: address which wants to submit evidence

• uint256 _depositId: the deposit for which the submitter wants to submit evidence

Return values:

• bool canSubmit: whether the _submitter address is allowed to submit evidence for the given dispute.

• address submittingFor: address for which the evidence is being submitted.

General function

Returns true for canSubmit if:

• the _submitter is the defendant or challenger for the given dispute

• OR the _submitter is a representative of ONLY one of the two

submittingFor is always either the address of the defendant or challenger regardless if _submitter is the actual party or the representative

canSubmitEvidenceFor() returning true for a certain _submitter is not a guarantee that that address will be able to submit evidence through the subject of the dispute as it's up to the implementation of the subject contract whether it enforces this logic.

If a subject contract uses the Disputable base contract and does not substantially override the logic of the inherited submitEvidenceFor method it will automatically enforce this access restriction by querying the manifest.

Methods

setPartiesOf

setPartiesOf(uint256, address, address) -> ()

Parameters:

• uint256 _disputeId: dispute for which to set defendant and challenger

• address _defendant: address to be registered as defendant of dispute

• address _challenger: address to be registered as challenger of the dispute

Emitted events:

• PartiesSet(uint256 indexed disputeId, address indexed defendant, address indexed challenger): emitted with method parameters if the method successfully runs

General function

Registers _defendant and _challenger for the dispute. Reverts if the caller is not the subject of the dispute, this prevents arbitrary addresses from overriding the defendant and challenger.

setRepStatus

setRepStatus(address, bool) -> ()

Parameters:

• uint256 _rep: address for which the representative status is to be changed

• bool _isActive: whether the caller wants to set the representative as active or not

Emitted events:

• RepStateSet(address indexed client, address indexed rep, bool isActive): emitted with method parameters and the msg.sender as client if the method successfully runs

General function

Sets the representative status of the _rep for the msg.sender. Reverts if trying to set to active (true) but canRepresent for the client representative pair is false.

allowRepresentation

allowRepresentation(address, bool) -> ()

Parameters:

• uint256 _client: address of client for which the caller will set the allow representation status

• bool _allow: whether the caller wants to allow representation of _client

Emitted events:

• AllowRepresentation(address indexed rep, address indexed client, bool allowed): emitted with method parameters and the msg.sender as rep

• RepStateSet(address indexed client, address indexed rep, bool isActive): emitted with method parameters and the msg.sender as rep if representation allowance is being set to false

General function

Sets the representation allowance of the caller for a certain potential or existing client. If set to false may reset existing representation to inactive.