AAAResolverV1

Overview

AAAResolverV1 implements a complete on-chain dispute resolution workflow designed for agreement-bound records. Unlike ADRResolverV3, which requires an explicit arbitration clause to be registered and locked before disputes can be initiated, AAAResolverV1 derives its dispute prerequisite from the AgreementTokenizerV1 -- when all three agreement tokens (Party A, Party B, Provider) have been claimed, the agreement is considered bound and disputes become available.

The contract spans three resolver categories simultaneously:

• Behavioral -- Lifecycle hooks notify the resolver of record events (registration, transfer, tokenizer association). Named actions (check-conditions, check-compliance) allow callers to trigger automated evaluations.
• Gatekeeper -- Active disputes block ownership transfers (past INITIATED state) and tokenization (any active dispute), preventing record manipulation during proceedings.
• Automation -- Trigger conditions (payment expiry, attestation expiry, custom evaluators) can automatically initiate disputes when evaluated by keeper bots.

AAAResolverV1 also implements IContractV2 for integration with IntegraLens and off-chain services.

Relationship to ADRResolverV3

AAAResolverV1 shares the same dispute lifecycle, state machine, and many of the same functions as ADRResolverV3. The key differences are:

Source Files

Key Concepts

Pattern 1: Agreement Binding (Replaces Arbitration Clause)

AAAResolverV1 does not manage its own clause state. Instead, it queries the record's tokenizer (expected to be an AgreementTokenizerV1) to determine whether the agreement is bound. The check is performed by _isAgreementBound:

function _isAgreementBound(bytes32 integraHash) internal view returns (bool) {
    address tokenizer = IIntegraRecord(INTEGRA_RECORD).getTokenizer(integraHash);
    if (tokenizer == address(0)) return false;
    try IAgreementTokenizer(tokenizer).getRecordState(integraHash) returns (bytes memory data) {
        (, uint256 claimedBitmap,) = abi.decode(data, (uint256, uint256, bool));
        // Bits 1, 2, 3 must all be set (0x0E = 0b1110)
        return (claimedBitmap & 0x0E) == 0x0E;
    } catch {
        return false;
    }
}

The AgreementTokenizerV1 maintains a bitmap where:

When all three bits are set (bitmap 0x0E = 0b1110), the agreement is bound and disputes can be initiated. The check is performed via getRecordState on the tokenizer, decoded as (uint256, uint256, bool) -- the second element is the claimed bitmap.

If the tokenizer is not set, not an AgreementTokenizerV1, or the call reverts, _isAgreementBound returns false silently.

Pattern 2: Commercial Party Access Model

AAAResolverV1 introduces the concept of a commercial party -- a record party (owner, executor, or token holder) who is NOT an authorized provider. This distinction ensures that dispute resolution providers cannot participate in settlement, response, or counterclaim processes as if they were parties to the underlying agreement:

function _isCommercialParty(bytes32 integraHash, address caller) internal view returns (bool) {
    return _isRecordParty(integraHash, caller) && !_isAuthorized(PROVIDER_ROLE, integraHash, caller);
}

The commercial party check is used for:

Other functions use the broader _isRecordParty or role-specific checks, consistent with ADRResolverV3.

Pattern 3: Dispute Lifecycle State Machine

The dispute lifecycle is identical to ADRResolverV3, managed by the StateMachine library with 11 states organized into three groups:

Active states (dispute is in progress):

Terminal states (dispute is resolved):

Inactive:

State Transition Diagram

stateDiagram-v2
    [*] --> NONE
    NONE --> INITIATED : initiateDispute() / evaluateConditions()
    INITIATED --> FILED : bindCaseReference() [restricted]
    INITIATED --> WITHDRAWN : withdrawDispute()
    INITIATED --> SETTLED : confirmSettlement() [restricted]
    FILED --> PENDING : advanceState()
    FILED --> SETTLED : confirmSettlement() [restricted]
    PENDING --> HEARING : advanceState()
    PENDING --> SETTLED : confirmSettlement() [restricted]
    HEARING --> AWARDED : recordAward() [restricted, transient]
    HEARING --> SETTLED : confirmSettlement() [restricted]
    AWARDED --> COMPLIANCE : recordAward() [with deadline]
    AWARDED --> CLOSED : recordAward() [no deadline]
    COMPLIANCE --> CLOSED : confirmCompliance() [restricted]
    COMPLIANCE --> EXPIRED : checkCompliance() [restricted]
    COMPLIANCE --> SETTLED : confirmSettlement() [restricted]
    CLOSED --> [*]
    SETTLED --> [*]
    WITHDRAWN --> [*]
    EXPIRED --> [*]

Generic transitions (via advanceState, provider only):

• NONE to INITIATED, INITIATED to WITHDRAWN, FILED to PENDING, PENDING to HEARING

Restricted transitions (via domain-specific functions only):

• INITIATED to FILED (via bindCaseReference)
• HEARING to AWARDED (via recordAward)
• AWARDED to COMPLIANCE or CLOSED (via recordAward, atomic)
• COMPLIANCE to CLOSED (via confirmCompliance)
• COMPLIANCE to EXPIRED (via checkCompliance)
• Any active state to SETTLED (via confirmSettlement, when quorum met)

State classification uses bitmask constants from ADRTypes.sol:

uint16 constant ACTIVE_STATES_MASK = uint16(
    (1 << STATE_INITIATED) | (1 << STATE_FILED) | (1 << STATE_PENDING)
    | (1 << STATE_HEARING) | (1 << STATE_COMPLIANCE));

uint16 constant TERMINAL_STATES_MASK = uint16(
    (1 << STATE_CLOSED) | (1 << STATE_SETTLED) | (1 << STATE_WITHDRAWN) | (1 << STATE_EXPIRED));

Note that STATE_AWARDED (5) is intentionally absent from both masks -- it is transient and never persists between transactions.

Pattern 4: Trigger Types

When a dispute is initiated, the triggerType field records who or what caused the dispute:

TRIGGER_AUTOMATED cannot be passed to initiateDispute() directly -- it is reserved for the internal path through evaluateConditions().

Pattern 5: Condition Types

Trigger conditions determine when automated disputes should fire:

Contract Architecture

Inheritance

BaseResolver (ERC2771Context + AccessControl + ReentrancyGuardTransient + Pausable + ResolverEvents)
    + AuthorizedActors (abstract contract -- three-dimensional authorization)
    + ViewDelegation (abstract contract -- delegates IContractV2 view functions to companion contract)
    + IBehavioralResolver
    + IGatekeeperResolver
    + IAutomationResolver
    + AAAEvents (abstract contract)
    = AAAResolverV1

Constructor

constructor(
    address integraRecord,
    address trustedForwarder,
    address signal,
    address eas,
    address viewContract
) BaseResolver(integraRecord, trustedForwarder) ViewDelegation(viewContract)

The constructor initializes the full state transition table (both generic and restricted transitions), stores SIGNAL and EAS as immutable addresses, and binds the companion view contract via ViewDelegation.

Role Constants

Note: both AAA and ADR use the same role hash values ("ADR_PROVIDER" and "ADR_AGENT"), ensuring cross-resolver compatibility for authorized actors.

Immutable Integrations

Minimal Interfaces

AAAResolverV1 defines two minimal interfaces for external integrations:

interface IAgreementTokenizer {
    function getRecordState(bytes32 integraHash) external view returns (bytes memory);
}

interface IAAASignalPayments {
    function getRequestsByRecord(bytes32 integraHash) external view returns (bytes32[] memory);
    function isRequestExpired(bytes32 requestId) external view returns (bool);
}

Shared Data Types

All struct and constant definitions live in ADRTypes.sol and are shared between ADRResolverV3 and AAAResolverV1. Note: AAAResolverV1 imports ADRTypes.sol but does not use the ArbitrationClause struct.

Dispute

struct Dispute {
    bytes32 integraHash;
    bytes32 groundsHash;
    bytes32 caseReference;
    bytes32 awardHash;
    bytes32 settlementHash;
    address initiator;
    uint64  disputeId;
    uint64  initiatedAt;
    uint64  complianceDeadline;
    uint8   triggerType;
}

Response

struct Response {
    bytes32 responseHash;
    address respondent;
    uint64  filedAt;
    bool    contestsJurisdiction;
}

Counterclaim

struct Counterclaim {
    bytes32 groundsHash;
    address claimant;
    uint64  filedAt;
}

ComplianceRequirement

struct ComplianceRequirement {
    bytes32 descriptionHash;
    bytes32 evidenceHash;
    uint64  deadline;
    bool    satisfied;
}

TriggerCondition

struct TriggerCondition {
    uint8   conditionType;
    bytes32 targetReference;
    uint64  threshold;
    bool    active;
}

Limits

Storage Layout

// Dispute lifecycle
mapping(bytes32 => Dispute) public activeDisputes;
mapping(bytes32 => uint64) public disputeCounters;

// State machine
StateMachine.TransitionRules internal _transitionRules;
mapping(bytes32 => StateMachine.Machine) internal _disputeState;

// Evidence (HashAnchor)
mapping(bytes32 => mapping(uint64 => HashAnchor.AnchorStore)) internal _evidence;

// Settlement (MultiPartyConfirmation)
mapping(bytes32 => mapping(uint64 => MultiPartyConfirmation.Tracker)) internal _settlements;
mapping(bytes32 => mapping(uint64 => mapping(address => uint256))) internal _settlementNonces;
mapping(bytes32 => uint8) public entitySettlementThreshold;

// Deadlines (DeadlineTracker)
mapping(bytes32 => DeadlineTracker.Deadline) internal _responseDeadlines;
mapping(bytes32 => DeadlineTracker.Deadline) internal _complianceDeadlines;

// Response + Counterclaims
mapping(bytes32 => mapping(uint64 => Response)) public responses;
mapping(bytes32 => mapping(uint64 => Counterclaim[])) public counterclaims;

// Compliance requirements
mapping(bytes32 => mapping(uint64 => ComplianceRequirement[])) public complianceRequirements;

// Triggers
mapping(bytes32 => TriggerCondition[]) internal _triggerConditions;
mapping(address => bool) public approvedEvaluators;

// Settlement proposal counter
mapping(bytes32 => uint8) internal _settlementProposalCount;

// Case reference reverse lookup
mapping(bytes32 => bytes32) public caseToEntity;

All dispute-scoped storage is keyed by (integraHash, disputeId) to isolate data between sequential disputes on the same record. When a dispute reaches a terminal state, _archiveDispute clears the active dispute, state machine, deadlines, and settlement proposal counter -- evidence, responses, counterclaims, and compliance requirements persist in their dispute-scoped mappings.

Functions

IResolver Implementation

resolverCategories

function resolverCategories() external pure returns (uint256)

Returns CATEGORY_BEHAVIORAL | CATEGORY_GATEKEEPER | CATEGORY_AUTOMATION (bitmask 0x0E = 14).

resolverVersion

function resolverVersion() external pure returns (uint256)

Returns (1 << 32) | (0 << 16) | 0 encoding version 1.0.0.

supportsInterface

function supportsInterface(bytes4 interfaceId) public view returns (bool)

Returns true for IBehavioralResolver, IGatekeeperResolver, IAutomationResolver, IContractV2, and all interfaces supported by BaseResolver (including IResolver, IAccessControl, ERC165).

Dispute Lifecycle

initiateDispute

function initiateDispute(
    bytes32 integraHash,
    bytes32 groundsHash,
    uint8 triggerType
) external nonReentrant whenNotPaused

Initiates a new dispute against a record.

Requirements:

• triggerType must not be TRIGGER_AUTOMATED (reverts AutomatedTriggerNotAllowed)
• Caller must be a record party, authorized provider, or authorized agent (reverts NotRecordParty)
• Agreement must be bound via AgreementTokenizerV1 (reverts AgreementNotBound)
• No active dispute on the record (reverts DisputeAlreadyActive)
• groundsHash must be non-zero (reverts EmptyGroundsHash)

Effects:

• Increments disputeCounters[integraHash]
• Performs restricted transition NONE to INITIATED
• Stores the Dispute struct in activeDisputes
• Initializes evidence store with MAX_EVIDENCE_PER_DISPUTE capacity
• Emits DisputeInitiated

withdrawDispute

function withdrawDispute(bytes32 integraHash) external nonReentrant whenNotPaused

Withdraws a dispute. Only the original initiator can withdraw, and only from INITIATED state.

Requirements:

• Active dispute exists (reverts NoActiveDispute)
• Caller is the dispute initiator (reverts NotDisputeInitiator)
• Current state is INITIATED (generic transition enforces this)

Effects:

• Transitions INITIATED to WITHDRAWN
• Emits DisputeWithdrawn
• Archives the dispute (clears active state)

advanceState

function advanceState(bytes32 integraHash, uint8 newState) external nonReentrant whenNotPaused

Advances the dispute through generic (non-restricted) state transitions. Provider only.

Requirements:

• Caller is an authorized provider (reverts NotAuthorizedProvider)
• Active dispute exists (reverts NoActiveDispute)
• Transition must be a generic (non-restricted) transition

Valid generic transitions:

• INITIATED to WITHDRAWN
• FILED to PENDING
• PENDING to HEARING

Effects:

• Performs the state transition
• Emits DisputeStateAdvanced
• Archives if terminal state reached

Provider Bridge

authorizeProvider

function authorizeProvider(bytes32 integraHash, address provider) external nonReentrant whenNotPaused

Authorizes a dispute resolution provider for a record. Owner or executor only.

Requirements:

• Caller is owner or executor (reverts NotOwnerOrExecutor)
• No active dispute on the record (reverts ActiveDisputeExists)

revokeProvider

function revokeProvider(bytes32 integraHash, address provider) external nonReentrant whenNotPaused

Revokes a provider. Owner or executor only. If a dispute is active, revocation is only allowed while in INITIATED state.

Requirements:

• Caller is owner or executor (reverts NotOwnerOrExecutor)
• If active dispute exists and state is past INITIATED, reverts ActiveDisputeExists

bindCaseReference

function bindCaseReference(bytes32 integraHash, bytes32 caseReference) external nonReentrant whenNotPaused

Binds an external case reference to the dispute and atomically transitions INITIATED to FILED.

Requirements:

• Caller is an authorized provider (reverts NotAuthorizedProvider)
• caseReference must be non-zero (reverts InvalidCaseReference)
• caseReference must not already be bound (reverts CaseReferenceAlreadyBound)
• Active dispute exists (reverts NoActiveDispute)
• Current state is INITIATED (restricted transition enforces this)

Effects:

• Performs restricted transition INITIATED to FILED
• Stores caseReference in dispute and caseToEntity reverse lookup
• Sets response deadline to block.timestamp + DEFAULT_RESPONSE_DEADLINE (30 days)
• Emits CaseReferenceBound and DisputeStateAdvanced

Award and Compliance

recordAward

function recordAward(
    bytes32 integraHash,
    bytes32 awardHash,
    uint64 complianceDeadline
) external nonReentrant whenNotPaused

Records an award and atomically transitions through the transient AWARDED state.

Requirements:

• Caller is an authorized provider (reverts NotAuthorizedProvider)
• awardHash must be non-zero (reverts InvalidAwardHash)
• Active dispute exists (reverts NoActiveDispute)
• Current state is HEARING (restricted transition enforces this)
• If complianceDeadline > 0, it must be in the future (reverts ComplianceDeadlineInPast)

Effects (with compliance deadline):

• HEARING to AWARDED (restricted, transient)
• AWARDED to COMPLIANCE (restricted)
• Sets complianceDeadline on dispute and deadline tracker
• Emits AwardRecorded and DisputeStateAdvanced

Effects (without compliance deadline, complianceDeadline == 0):

• HEARING to AWARDED (restricted, transient)
• AWARDED to CLOSED (restricted)
• Emits AwardRecorded, DisputeStateAdvanced, DisputeClosed
• Archives the dispute

confirmCompliance

function confirmCompliance(bytes32 integraHash, bytes32 evidenceHash) external nonReentrant whenNotPaused

Confirms compliance and closes the dispute.

Requirements:

• Active dispute exists (reverts NoActiveDispute)
• Current state is COMPLIANCE (reverts NotInComplianceState)
• Caller is a record party, provider, or agent (reverts NotRecordParty)
• All compliance requirements must be satisfied (reverts ComplianceRequirementsNotMet)

Effects:

• Performs restricted transition COMPLIANCE to CLOSED
• Emits ComplianceConfirmed, DisputeClosed
• Archives the dispute

checkCompliance

function checkCompliance(bytes32 integraHash) external nonReentrant

Checks if the compliance deadline has passed and expires the dispute if so. Permissionless -- designed for keeper bots.

Requirements:

• Active dispute exists (reverts NoActiveDispute)
• Current state is COMPLIANCE (reverts NotInComplianceState)

Effects (if deadline passed):

• Performs restricted transition COMPLIANCE to EXPIRED
• Emits ComplianceExpired
• Archives the dispute

Effects (if deadline not passed):

• No-op (returns without reverting)

addComplianceRequirement

function addComplianceRequirement(
    bytes32 integraHash,
    bytes32 descriptionHash,
    uint64 deadline
) external nonReentrant whenNotPaused

Adds a compliance requirement to the active dispute. Provider only.

Requirements:

• Caller is an authorized provider (reverts NotAuthorizedProvider)
• Active dispute exists (reverts NoActiveDispute)
• Current state is COMPLIANCE (reverts NotInComplianceState)
• Requirement count under limit (reverts MaxComplianceRequirementsReached)
• If deadline > 0, it must be in the future (reverts ComplianceDeadlineInPast)

Effects:

• Pushes new ComplianceRequirement to the array
• Emits ComplianceRequirementAdded

satisfyRequirement

function satisfyRequirement(
    bytes32 integraHash,
    uint256 index,
    bytes32 evidenceHash
) external nonReentrant whenNotPaused

Satisfies a compliance requirement with supporting evidence.

Requirements:

• evidenceHash must be non-zero (reverts EmptyEvidenceHash) -- this is stricter than ADRResolverV3
• Active dispute exists (reverts NoActiveDispute)
• Current state is COMPLIANCE (reverts NotInComplianceState)
• Caller is a record party, provider, or agent (reverts NotRecordParty)
• index is within bounds (reverts RequirementIndexOutOfBounds)
• Requirement not already satisfied (reverts RequirementAlreadySatisfied)

Effects:

• Sets satisfied = true and stores evidenceHash on the requirement
• Emits ComplianceRequirementSatisfied

Evidence

submitEvidence

function submitEvidence(
    bytes32 integraHash,
    bytes32 evidenceHash,
    string calldata description
) external nonReentrant whenNotPaused

Submits evidence for an active dispute using the HashAnchor library.

Requirements:

• Active dispute exists (reverts NoActiveDispute)
• Caller is a record party, provider, or agent (reverts NotRecordParty)
• Evidence count under limit (enforced by HashAnchor.append)

Effects:

• Appends evidence hash to the HashAnchor.AnchorStore
• Emits EvidenceSubmitted

Settlement

confirmSettlement

function confirmSettlement(bytes32 integraHash, bytes32 settlementHash) external nonReentrant whenNotPaused

Confirms a settlement hash. When the required quorum is reached, the dispute transitions to SETTLED.

Requirements:

• settlementHash must be non-zero (reverts InvalidSettlementHash)
• Active dispute exists (reverts NoActiveDispute)
• Dispute is not in a terminal state (reverts NoActiveDispute)
• Caller must be a commercial party or agent (reverts NotCommercialParty) -- providers cannot settle
• Settlement proposal count under limit (reverts MaxSettlementProposalsReached)

Effects:

• Initializes MultiPartyConfirmation.Tracker on first call (threshold from entitySettlementThreshold or default 2)
• Calls tracker.confirm() with settlement cooldown
• Emits SettlementConfirmed
• If quorum met: stores settlementHash, transitions to SETTLED, emits DisputeSettled, archives

setSettlementThreshold

function setSettlementThreshold(bytes32 integraHash, uint8 threshold) external nonReentrant whenNotPaused

Sets the settlement confirmation threshold for a record. Owner or executor only.

Requirements:

• Caller is owner or executor (reverts NotOwnerOrExecutor)
• No active dispute (reverts ActiveDisputeExists)
• threshold >= 2 (reverts ThresholdTooLow)

Response and Counterclaims

fileResponse

function fileResponse(
    bytes32 integraHash,
    bytes32 responseHash,
    bool contestsJurisdiction
) external nonReentrant whenNotPaused

Files a response to an active dispute. One response per dispute.

Requirements:

• Active dispute exists (reverts NoActiveDispute)
• responseHash must be non-zero (reverts EmptyResponseHash)
• Current state must be INITIATED, FILED, or PENDING (reverts InvalidDisputeState if past PENDING)
• Caller is not the dispute initiator (reverts CannotRespondToOwnDispute)
• Caller must be a commercial party (reverts NotCommercialParty)
• No response already filed (reverts ResponseAlreadyFiled)
• Response deadline not passed (reverts ResponseDeadlinePassed)

Effects:

• If no deadline set, sets default response deadline (30 days) and emits ResponseDeadlineSet
• Stores the Response struct
• Emits ResponseFiled

fileCounterclaim

function fileCounterclaim(bytes32 integraHash, bytes32 groundsHash) external nonReentrant whenNotPaused

Files a counterclaim against an active dispute. One counterclaim per party per dispute.

Requirements:

• Active dispute exists (reverts NoActiveDispute)
• groundsHash must be non-zero (reverts EmptyGroundsHash)
• Current state must be INITIATED, FILED, or PENDING (reverts InvalidDisputeState if past PENDING)
• Caller is not the dispute initiator (reverts CannotRespondToOwnDispute)
• Caller must be a commercial party (reverts NotCommercialParty)
• Counterclaim count under limit (reverts MaxCounterclaimsReached)
• Caller has not already filed a counterclaim (reverts CounterclaimAlreadyFiled)

Effects:

• Pushes new Counterclaim to the array
• Emits CounterclaimFiled

setResponseDeadline

function setResponseDeadline(bytes32 integraHash, uint64 deadline) external nonReentrant whenNotPaused

Sets the response deadline for an active dispute. Owner or executor only.

Requirements:

• Caller is owner or executor
• Active dispute exists (reverts NoActiveDispute)
• Current state is INITIATED or FILED (reverts InvalidDisputeState if past FILED)

getResponse

function getResponse(bytes32 integraHash, uint64 disputeId) external view returns (Response memory)

Returns the response for a given dispute. Returns an empty struct if no response has been filed.

Agent Authorization

authorizeAgent

function authorizeAgent(
    bytes32 integraHash,
    address agent,
    address principal
) external nonReentrant whenNotPaused

Authorizes an agent for a record with principal validation. Owner or executor only.

Requirements:

• Caller is owner or executor (reverts NotOwnerOrExecutor)
• principal must be a record party (reverts NotRecordParty)

Effects:

• Calls _authorizeActor(AGENT_ROLE, integraHash, agent, principal, _msgSender())
• The principal is stored so agents can be traced back to the party they represent

revokeAgent

function revokeAgent(bytes32 integraHash, address agent) external nonReentrant whenNotPaused

Revokes an agent. Owner or executor only. Same active-dispute restriction as revokeProvider.

Trigger Condition Management

addTriggerCondition

function addTriggerCondition(bytes32 integraHash, TriggerCondition calldata condition)
    external nonReentrant whenNotPaused

Adds a trigger condition for automated dispute initiation. Owner or executor only.

Requirements:

• Caller is owner or executor
• condition.conditionType must be valid (0, 1, or 2; reverts InvalidConditionType)
• Condition count under limit (reverts MaxTriggersReached)

Effects:

• Pushes condition to the _triggerConditions array
• Emits TriggerConditionAdded

deactivateTrigger

function deactivateTrigger(bytes32 integraHash, uint256 index) external nonReentrant whenNotPaused

Deactivates a trigger condition. Owner or executor only.

Requirements:

• Caller is owner or executor
• index is within bounds (reverts ConditionIndexOutOfBounds)

Effects:

• Sets conditions[index].active = false
• Emits TriggerConditionDeactivated

replaceTrigger (AAA-only)

function replaceTrigger(bytes32 integraHash, uint256 index, TriggerCondition calldata condition)
    external nonReentrant whenNotPaused

Replaces an inactive trigger condition at a given index with a new condition. This function is unique to AAAResolverV1 -- it does not exist in ADRResolverV3.

Requirements:

• Caller is owner or executor
• condition.conditionType must be valid (reverts InvalidConditionType)
• index is within bounds (reverts ConditionIndexOutOfBounds)
• Existing condition at index must be inactive (reverts ConditionStillActive)

Effects:

• Overwrites conditions[index] with the new condition
• Emits TriggerConditionAdded (same event as add -- index identifies the slot)

Rationale: Since trigger conditions are stored in an array and can only be deactivated (not removed), the array can accumulate inactive entries over time. replaceTrigger allows reuse of these slots without requiring a full array rebuild.

setApprovedEvaluator

function setApprovedEvaluator(address evaluator, bool approved) external onlyRole(GOVERNOR_ROLE)

Approves or revokes an external condition evaluator contract. Governor only (no reentrancy guard or pause check).

IContractV2 Implementation (ViewDelegation)

AAAResolverV1 delegates its IContractV2 view functions (getRecordState and getAvailableActions) to a companion contract, AAAResolverView, via the ViewDelegation mixin. This pattern moves view logic out of the main contract to stay within the EVM's 24,576-byte contract size limit (EIP-170).

The delegation is transparent to callers -- IntegraLens and off-chain services call getRecordState and getAvailableActions on AAAResolverV1 exactly as before. The ViewDelegation mixin forwards these calls to the companion view contract, which reads state back from the resolver's public getters and encodes the response.

// ViewDelegation forwards calls:
function getRecordState(bytes32 integraHash) external view returns (bytes memory) {
    return VIEW_CONTRACT.getRecordState(address(this), integraHash);
}

The VIEW_CONTRACT is set as an immutable in the constructor and cannot change -- the resolver and its view contract are a matched pair.

getRecordState

Returns ABI-encoded complete state via the companion AAAResolverView contract:

abi.encode(
    // Dispute State Machine
    uint8   state,                    // Current dispute state (0-10)
    uint64  lastTransitionAt,         // Timestamp of last state transition
    bool    agreementBound,           // Whether agreement is bound (all 3 tokens claimed)

    // Active Dispute (complete Dispute struct)
    Dispute dispute,                  // integraHash, groundsHash, caseReference, awardHash,
                                      // settlementHash, initiator, disputeId, initiatedAt,
                                      // complianceDeadline, triggerType

    // History
    uint64  totalDisputeCount,        // Total disputes ever initiated for this record

    // Response
    Response response,                // responseHash, respondent, filedAt, contestsJurisdiction

    // Counterclaims
    Counterclaim[] counterclaims,     // Array of (groundsHash, claimant, filedAt)

    // Compliance
    ComplianceRequirement[] complianceRequirements,  // Array of (descriptionHash, evidenceHash, deadline, satisfied)

    // Deadlines
    uint64  responseDeadline,         // Response filing deadline
    uint64  complianceDeadlineTracker, // Compliance period deadline

    // Settlement Tracker
    bytes32 settlementContentHash,    // Current settlement proposal hash
    uint8   confirmationCount,        // Current confirmation count
    uint8   requiredConfirmations,    // Required for quorum
    uint64  lastHashChangeAt,         // Last time settlement hash changed
    uint8   proposalCount,            // Number of settlement proposals made

    // Evidence
    HashAnchor.Anchor[] evidence,     // Array of (contentHash, submitter, timestamp, description)

    // Trigger Conditions
    TriggerCondition[] triggerConditions  // Array of (conditionType, targetReference, threshold, active)
)

This is the complete state of the resolver for a given record. Nothing is filtered or omitted. The encoding is identical whether called via resolver.getRecordState(integraHash) or directly via resolverView.getRecordState(address(resolver), integraHash).

Note: the previous compact encoding (state, agreementBound, disputeId, initiator, awardHash) has been replaced by this comprehensive encoding. Decode using stateSchema() == "AAAResolverV1".

getAvailableActions

function getAvailableActions(bytes32 integraHash, address caller) external view returns (bytes4[] memory)

Returns an array of function selectors the caller can currently execute on the given record. Delegated to AAAResolverView, which reads role and state information from the resolver's public getters. The logic uses up to 12 action slots and applies the commercial party model:

stateSchema

function stateSchema() external pure returns (string memory)

Returns "AAAResolverV1". This function remains inline in the resolver (not delegated) -- it is pure and costs negligible bytecode. Off-chain services use this to determine which decoder to apply to getRecordState output.

Public Getters

AAAResolverV1 exposes public getters that the companion AAAResolverView contract reads to encode state. These are also available for direct use by off-chain services.

The view contract also reads auto-generated mapping getters (activeDisputes, disputeCounters, responses, counterclaims, complianceRequirements) and public immutables (INTEGRA_RECORD, PROVIDER_ROLE, AGENT_ROLE) directly.

AAAResolverView (Companion View Contract)

AAAResolverView is a stateless contract that implements IContractView. It is deployed independently and bound to AAAResolverV1 at construction time. It reads all state from the resolver's public getters and auto-generated mapping getters, encodes it into the comprehensive 17-position blob described above, and returns it.

// src/interfaces/IContractView.sol
interface IContractView {
    function getRecordState(address source, bytes32 integraHash)
        external view returns (bytes memory);
    function getAvailableActions(address source, bytes32 integraHash, address caller)
        external view returns (bytes4[] memory);
}

The source parameter is the resolver address -- the view contract calls back into source to read public state. This design means AAAResolverView has no storage, no constructor arguments, and no access control. It can be deployed once and shared by multiple AAAResolverV1 instances.

Deployment sequence:

1. Deploy AAAResolverView (no dependencies)
2. Deploy AAAResolverV1 with the view contract address as the 5th constructor argument
3. The VIEW_CONTRACT immutable creates an unbreakable pairing

IBehavioralResolver Implementation

onRegistered

function onRegistered(bytes32 integraHash, bytes32, address owner, bytes calldata) external onlyRecord

Lifecycle hook called when a record is first registered with this resolver. Emits RecordRegistered.

onTransferred

function onTransferred(bytes32 integraHash, address from, address to) external onlyRecord

Lifecycle hook called when record ownership is transferred. Emits RecordTransferred.

onTokenizerAssociated

function onTokenizerAssociated(bytes32 integraHash, address tokenizer) external onlyRecord

Lifecycle hook called when a tokenizer is associated with a record. Emits TokenizerAssociated.

executeAction

function executeAction(bytes32 integraHash, string calldata action, bytes calldata)
    external nonReentrant whenNotPaused returns (bool, bytes memory)

Executes a named action on a record. Intentionally permissionless -- designed for keeper bots and automation.

Supported actions:

Returns (false, "") for unrecognized actions.

availableActions

function availableActions(bytes32) external pure returns (string[] memory)

Returns ["check-conditions", "check-compliance"]. Unlike ADRResolverV3, which returns an empty array, AAAResolverV1 always advertises its keeper-compatible actions.

IGatekeeperResolver Implementation

canOwn

function canOwn(bytes32 integraHash, address) external view returns (bool, string memory)

Returns (false, "") if an active dispute exists beyond INITIATED state. Returns (true, "") otherwise. This allows ownership transfers while a dispute is in its initial state but blocks them once the dispute is formally filed or progressing.

canTokenize

function canTokenize(bytes32 integraHash, address) external view returns (bool, string memory)

Returns (false, "") if any active dispute exists (including INITIATED). Returns (true, "") otherwise. Tokenization is fully blocked during any active dispute.

isExpired

function isExpired(bytes32) external pure returns (bool, uint256)

Always returns (false, 0). AAAResolverV1 does not implement record-level expiry.

IAutomationResolver Implementation

evaluateConditions

function evaluateConditions(bytes32 integraHash)
    external nonReentrant returns (bool triggered, bytes32 conditionId, bytes memory data)

Evaluates all active trigger conditions and initiates a dispute if any condition is met.

Behavior (differs from ADRResolverV3):

• If a dispute is already active, returns (false, bytes32(0), "") -- no revert
• If agreement is not bound, returns (false, bytes32(0), "") -- no revert
• If no conditions configured, returns (false, bytes32(0), "") -- no revert
• If no conditions are met, returns (false, bytes32(0), "") -- no revert

This silent-return behavior is designed for keeper compatibility -- bots can call evaluateConditions on every record without worrying about reverts.

Effects (if a condition fires):

• Deactivates the triggered condition
• Emits TriggerConditionMet
• Initiates a dispute via _initiateDisputeInternal with TRIGGER_AUTOMATED and address(this) as initiator
• Returns (true, groundsHash, abi.encode(disputeId))

onConditionTriggered

function onConditionTriggered(bytes32, bytes32, bytes calldata) external onlyRecord

No-op callback. The onlyRecord modifier restricts calls to the IntegraRecord contract.

activeConditionCount

function activeConditionCount(bytes32 integraHash) external view returns (uint256)

Returns the number of active (non-deactivated) trigger conditions for a record.

Internal Condition Evaluation

The resolver supports three condition types, each with a dedicated internal evaluator:

Payment Expiry (CONDITION_PAYMENT_EXPIRY)

function _checkPaymentExpiry(bytes32 integraHash, uint64 threshold)
    internal view returns (bool met, bytes32 groundsHash)

Queries the Signal contract for payment requests associated with the record and counts how many have expired. If the expired count reaches threshold, returns (true, keccak256("PAYMENT_EXPIRY", threshold)). Returns (false, bytes32(0)) if SIGNAL is zero, the call fails, or the threshold is not met. Checks at most MAX_PAYMENT_REQUESTS_TO_CHECK (100) requests.

Attestation Expiry (CONDITION_ATTESTATION_EXPIRY)

function _checkAttestationExpiry(bytes32 attestationUID)
    internal view returns (bool met, bytes32 groundsHash)

Queries EAS for the attestation identified by targetReference (used as the attestation UID). Returns true if:

• The attestation has been revoked (revocationTime != 0) -- grounds: keccak256("ATTESTATION_REVOKED", uid)
• The attestation has expired (expirationTime != 0 && block.timestamp > expirationTime) -- grounds: keccak256("ATTESTATION_EXPIRED", uid)

Custom Condition (CONDITION_CUSTOM)

function _checkCustomCondition(bytes32 integraHash, bytes32 targetReference)
    internal view returns (bool met, bytes32 groundsHash)

Extracts an evaluator address from targetReference (cast from bytes32 to address), verifies it is in the approvedEvaluators mapping, and calls IConditionEvaluator(evaluator).evaluate{gas: EVALUATOR_GAS_LIMIT}(integraHash). The gas limit (50,000) prevents griefing by external contracts.

Error Catalog

All errors are defined in AAAErrors.sol as parameterless errors for bytecode optimization.

Event Catalog

All events are defined in AAAEvents.sol. Unlike ADRResolverV3, there are no clause-related events -- agreement binding is determined by the AgreementTokenizerV1.

Dispute Lifecycle

Award and Compliance

Settlement

Evidence

Provider Bridge

Response and Counterclaim

Triggers

Lifecycle Hooks

Access Control Summary

Cross-References

• Resolver Overview -- Architecture, categories, and building custom resolvers
• BaseResolver and Support Libraries -- BaseResolver, AuthorizedActors, StateMachine, MultiPartyConfirmation, HashAnchor, DeadlineTracker, and other libraries
• ADRResolverV3 -- The clause-based variant sharing the same dispute lifecycle