Integrate Chainalysis Oracle for Address Sanctions Screening

[rjan90]

Problem

For legal/regulatory compliance, we need to prevent sanctioned wallet addresses from accessing Filecoin Warm Storage Service operations. We need to integrate the Chainalysis Oracle for sanctions screening as documented at https://go.chainalysis.com/chainalysis-oracle-docs.html.

Proposed Solution

Integrate Chainalysis Oracle for wallet address sanctions screening in the FilecoinWarmStorageService contract.

Requirements

• Use Chainalysis Oracle: Implement sanctions screening using the Chainalysis Oracle contract
• Address Screening: Screen wallet addresses before allowing access to service operations

Design decisions and implementation details should be determined as part of this ticket.

[Chaitu-Tatipamula]

Sanctioned Address screening using Chainalysis Oracle in Filecoin Warm Storage Service

Overview

I would like to take this issue, and This implementation plan outlines the integration of Chainalysis Oracle sanctions screening directly into the Filecoin Warm Storage Service contract. The implementation will add sanctions screening functionality to prevent sanctioned wallet addresses from accessing service operations, ensuring regulatory compliance.

Current State Analysis

Chainalysis Oracle Availability

According to the Chainalysis Oracle documentation, the sanctions oracle is currently available on multiple EVM-compatible networks but not on Filecoin. However, for this design, we'll assume a direct integration approach as if the oracle were available on Filecoin.

Implementation Plan

Core Contract Modifications

1. State Variables

// Sanctions screening states
IChainalysisOracle public chainalysisOracle;
bool public sanctionsScreeningEnabled;

2. Constructor Updates

constructor(
    address _pdpVerifierAddress,
    address _paymentsContractAddress,
    address _usdfcTokenAddress,
    address _filCDNAddress,
    address _chainalysisOracleAddress  // New parameter
) {
    // Existing initialization...
    
    // Initialize Chainalysis Oracle
    chainalysisOracle = IChainalysisOracle(_chainalysisOracleAddress);
    // Enable screening addresses' 
    sanctionsScreeningEnabled = true;
}

3. Core Sanctions Screening Function

/// @notice Check if an address is sanctioned (reverts if sanctioned)
/// @param addressToCheck The address to check
function requireNotSanctioned(address addressToCheck) 
    public 
    view 
{
    if (!sanctionsScreeningEnabled) {
        return; // Skip screening if disabled
    }
    
    try chainalysisOracle.isSanctioned(addressToCheck) returns (bool isSanctioned) {
        if (isSanctioned) {
            revert Errors.AddressSanctioned(addressToCheck);
        }
    } catch {
        revert Errors.ChainalysisOracleUnavailable();
    }
}

4. Configuration Management Functions

/// @notice Update the Chainalysis Oracle address
/// @param newOracle The new oracle address
function updateChainalysisOracle(address newOracle) external onlyOwner {
    require(newOracle != address(0), Errors.ZeroAddress(Errors.AddressField.StorageProvider));
    
    address oldOracle = address(chainalysisOracle);
    chainalysisOracle = IChainalysisOracle(newOracle);
    
    emit ChainalysisOracleUpdated(oldOracle, newOracle);
}

/// @notice Enable or disable sanctions screening
/// @param enabled True to enable, false to disable
function setSanctionsScreeningEnabled(bool enabled) external onlyOwner {
    sanctionsScreeningEnabled = enabled;
    emit SanctionsScreeningEnabled(enabled);
}

/// @notice Get the current screening configuration
/// @return oracle The oracle address
/// @return enabled Whether screening is enabled
function getScreeningConfig() external view returns (address oracle, bool enabled) {
    return (address(chainalysisOracle), sanctionsScreeningEnabled);
}

Integration Points

Key Service Functions

The sanctions screening will be integrated at the following critical entry points:

1. Data Set Creation

function dataSetCreated(CreateData calldata createData, address creator) external {
    // Screen both payer and creator
    requireNotSanctioned(createData.payer);
    requireNotSanctioned(creator);
    
    // ... rest of existing function
}

2. Storage Provider Registration

function registerServiceProvider(string calldata serviceURL, bytes calldata peerId) external {
    // Screen the registering provider
    requireNotSanctioned(msg.sender);
    
    // ... rest of existing function
}

3. Storage Provider Approval

function approveServiceProvider(address provider) external onlyOwner {
    // Screen the provider before approval
    requireNotSanctioned(provider);
    
    // ... rest of existing function
}

4. Storage Provider Changes

function storageProviderChanged(uint256 dataSetId, address newStorageProvider) external {
    // Screen the new storage provider
    requireNotSanctioned(newStorageProvider);
    
    // ... rest of existing function
}

Required Interface

IChainalysisOracle Interface

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;

interface IChainalysisOracle {
    /// @notice Check if an address is sanctioned
    /// @param addr The address to check for sanctions
    /// @return True if the address is sanctioned, false otherwise
    function isSanctioned(address addr) external view returns (bool);
    
    /// @notice Check if an address is sanctioned with verbose logging
    /// @param addr The address to check for sanctions
    /// @return True if the address is sanctioned, false otherwise
    function isSanctionedVerbose(address addr) external returns (bool);
    
    /// @notice Get the oracle name
    /// @return The name of the oracle
    function name() external pure returns (string memory);
}

Error Handling

New Error Definitions

// Add to Errors.sol
error AddressSanctioned(address addr);
error ChainalysisOracleUnavailable();
error SanctionsScreeningDisabled();

Events

New Event Definitions

// Events for sanctions screening
event SanctionsScreeningEnabled(bool enabled);
event ChainalysisOracleUpdated(address indexed oldOracle, address indexed newOracle);

Security Considerations

Access Control

• Only contract owner can update oracle address
• Only contract owner can modify screening parameters

Error Handling

• Graceful handling of oracle failures
• Proper error messages for debugging
• Events for tracking screening results

Fallback Mechanisms

• Allow service to continue if sanctions screening disabled or fails
• Provide emergency disable functionality
• Monitor screening results and failures

Important Query: Oracle Availability

I noticed that Chainalysis Oracle for sanctions screening is currently available on multiple EVM-compatible networks (Ethereum, Polygon, BSC, etc.) but not on Filecoin. This presents a significant challenge for implementing sanctions screening on the Filecoin network.

Options to consider:

1. Wait for Filecoin Oracle: Should we wait for Chainalysis to deploy their oracle on Filecoin before implementing this feature?

2. Cross-Chain Solution: Should we implement a cross-chain bridge solution to query the Ethereum Chainalysis Oracle from Filecoin? (This would add complexity and cost)

3. Manual Management: Should we implement a manual sanctions list that can be updated by trusted operators, similar to how the Chainalysis Oracle works but managed locally?

4. Alternative Oracle: Are there other sanctions screening oracles available on Filecoin that we could use instead?

[aarshkshah1992]

Picking this up.