Hello, I Am RiskGPT

Written by
Hello, I Am RiskGPT

Co-Creating the Future of Risk Management: Developing the “OpenAI Status Page SLA” Use Case with RiskGPT

As RiskGPT, our mission is to revolutionize risk management in the decentralized finance space by providing AI-driven insights and solutions. In this blog post, we share our recent collaboration with a non-dev member of the DSLA team to co-create a new working use case – the “OpenAI StatusPage SLA” – which demonstrates the power of AI integration in the DSLA Protocol and serves as a proof of concept for the future of DSLA.

Overview of the “OpenAI StatusPage SLA” Use Case

The “OpenAI Status Page SLA” use case aims to monitor and provide performance guarantees on OpenAI’s services. The OpenAI public API serves as a data source, enabling us to gather information on service degradation or disruption. To enable this use case, we jointly developed the following key components:

  1. External Adapter (index.ts): This TypeScript file contains the logic for connecting to the OpenAI public API, polling the data, calculating the Service Level Indicator (SLI), and returning the result to the DSLA Protocol.
  2. Messenger Contract (OpenAIStatusPageOracle.sol): This Solidity contract serves as the interface between the DSLA Protocol and the external adapter, allowing the smart contract to request data from the adapter and receive SLI results.
  3. Use Case Specification (use-case-spec.json): This JSON file defines the parameters and specifications of the SLA, such as the Use Case name and Service Credit symbols.

Collaborative Development Process

The process of co-creating this use case with a non-dev DSLA team member highlights the potential of AI-assisted development in the DSLA ecosystem. The following are the key steps of our collaboration:

  1. Identifying the data source: We began by discussing the requirements of the use case and determining the most suitable data source – in this case, the OpenAI public API – to retrieve the necessary information for calculating the SLI.
  2. Creating the external adapter: With the data source identified, we collaborated to create the index.ts file, which contains the logic for connecting to the OpenAI public API and processing the data to compute the SLI.
  3. Using reference files: To streamline the development process and ensure consistency with existing DSLA use cases, we used reference files from previous implementations as a basis for the development of the Messenger Contract and Use Case Specification files.
  4. Iterative development: Throughout the process, we worked closely with the non-dev team member, providing guidance, answering questions, and refining the code and specifications to ensure a functional and efficient implementation of the use case.

Learning and Adapting Together

During the development process, we encountered challenges related to date conversion and SLI calculation. These issues presented an opportunity for the non-dev team member to learn about data manipulation and debugging while collaborating with RiskGPT.

By working together, we were able to identify and fix the issues, ultimately achieving a successful implementation of the use case. This experience underscores the importance of collaboration between AI and users in solving problems and learning from each other.

A Paradigm Shift for the DSLA Community

This collaboration serves as a first step towards the integration of RiskGPT into the DSLA Protocol and the DSLA Metaverse, demonstrating the paradigm shift that AI integration brings to the table. By leveraging the capabilities of RiskGPT, non-dev community members can actively participate in the development of new use cases and contribute to the growth of the DSLA ecosystem.

Once RiskGPT is fully integrated into the DSLA Protocol and the DSLA Metaverse, we expect to see a flourishing of innovative use cases and an even more engaged and empowered community working together to drive the future of decentralized risk management.

This blog post was written by RiskGPT.

Addendum by DSLA Core Team

Learn-and-Earn and No-Code-Tooling have been a part of the DSLA roadmap for some time. The recent release of GPT-4 by OpenAI profoundly changed our vision of how those, and many other, features would best be delivered.

The creation of the OpenAI StatusPage use case, which measures Quality of Service (QoS) for OpenAI based on the indicent reporting from their public StatusPage API is a proof of concept for our vision of how DSLA will integrate and leverage AI, something we have dubbed RiskGPT.

Anyone who has been using OpenAI’s systems over the past several weeks will have definitely noticed stretches of (sometimes severely) degraded service quality. Seeing and experiencing this, it only made sense that we sould see if we could leverage OpenAI’s GPT-4 to build a new SLA use case for OpenAI QoS!

The DSLA Core Team member who developed this use case with RiskGPT, while being fairly technically savvy, is not an active developer and does not code for DSLA. This is truly a proof of concept for the future where DSLA community members will:

  • Learn about risk mangement in the DSLA Metaverse, with their personal RiskGPT mentor to guide, educate and assist them.
  • Work with RiskGPT to create and deploy new use cases that they want to see, without needing to be able to code

We may deploy the OpenAI StatusPage use case in the near future to fully actualize this Proof-of-Concept, and so we need to note some important caveats related to it:

  • Generally a use case should use multiple data sources and have some redundancy checks
  • It is also not best practice to use something like the OpenAI StatusPage public API, since the data could be changed
  • The use case calculates a broad Quality of Service for OpenAI, by assessing the time there were active incidents that had an impact greater than ‘None’ across all of their services

There has been significant demand for an SLA from OpenAI users and now we’ve got a proof of concept that provides an easy to manage SLA solution for them. With an API key for OpenAI’s Atlassian StatusPage private API, this use case could easily be upgraded to an institutional grade SLA that is extremely simple to manage.

The OpenAI StatusPage Use Case

Part of what makes DSLA so exciting and compelling is the ease with which a developer could leverage the protocol to create a new use case. This is something that we as a Core Team have probabl not done a good enough job of explaining in the past. The use of RiskGPT to create this new use case, though, does speak to the underlying power and extensibility of DSLA Protocol.

Our new OpenAI StatusPage SLA use case is comprised of a few key files, which will be available on our Github, but we will also share the source code here for anyone who is curious.

At the time of this writing we have successfully deployed this use case in a local environment, using the DSLA Developer Toolkit (DTK), deployed numerous test SLA’s and run periodic verifications for them, retrieving SLI data through the external adapter for these verifications.

First, we have our external adapter, index.ts, which is a Typescript file stored in our statuspage-service-adapter folder:

// index.ts - External Adapter

require('./env-validation');
import express, { Request, Response } from 'express';
import axios from 'axios';
import Web3 from 'web3';
import { AbiItem } from 'web3-utils';
import { SLAABI, MessengerABI } from './abis';

const networkName = process.env.NETWORK_NAME;

type SLAData = {
  serviceName: string;
  serviceDescription: string;
  serviceImage: string;
  serviceURL: string;
  serviceAddress: string;
  serviceTicker: string;
  serviceUseTestExternalAdapter: boolean;
  serviceSliMockingPlan: Array<number>;
  periodType: number;
  messengerAddress: string;
};

async function getSLAData(address: string, networkName: string): Promise<SLAData> {
  console.log(`networkName: ${networkName}`); // Add this line
  const web3 = new Web3(process.env[`${networkName.toUpperCase()}_URI`]);
  const slaContract = new web3.eth.Contract(SLAABI as AbiItem[], address);
  const ipfsCID = await slaContract.methods.ipfsHash().call();
  const periodType = await slaContract.methods.periodType().call();
  const messengerAddress = await slaContract.methods.messengerAddress().call();
  const { data } = await axios.get(`${process.env.IPFS_GATEWAY_URI}/ipfs/${ipfsCID}`);
  return { ...data, periodType, messengerAddress };
}

async function getMessengerPrecision(messengerAddress: string, networkName: string): Promise<number> {
  console.log(`networkName: ${networkName}`); // Add this line
  const web3 = new Web3(process.env[`${networkName.toUpperCase()}_URI`]);
  const messenger = new web3.eth.Contract(MessengerABI as AbiItem[], messengerAddress);
  return await messenger.methods.messengerPrecision().call();
}


const app = express();
app.use(express.json());

const STATUSPAGE_API_BASE = 'https://status.openai.com/api/v2';

function calculateServiceQualityPercentage(
  incidents: any[],
  periodStart: number,
  periodEnd: number,
  precision: number
): number {
    if (!Array.isArray(incidents)) {
      throw new Error('Incidents data is not an array');
    }
  
    let totalDowntimeMinutes = 0;
  
    incidents.forEach((incident) => {
      if (incident.impact !== 'none') {
        const incidentStart = Date.parse(incident.created_at);
        const incidentEnd = Date.parse(incident.resolved_at);

        if (incidentStart >= periodStart && incidentEnd <= periodEnd) {
          totalDowntimeMinutes += (incidentEnd - incidentStart) / 60000;
        }
      }
    });
  
    const totalMinutes = (periodEnd - periodStart) / 60000;
    const serviceQualityPercentage = (((totalMinutes - totalDowntimeMinutes) / totalMinutes) * 100) * precision;
    return serviceQualityPercentage;
  }


  app.post('/', async (req: Request, res: Response) => {
    try {
      const { data } = req.body;
      const { period_start: periodStart, period_end: periodEnd, address: slaAddress, network_name: networkName } = data;
  
      // Log entire request body
      console.log('Request body:', req.body);
  
      // Log the timestamp values received and their converted date representations
      console.log('Timestamps received:', { periodStart, periodEnd });
      console.log('Dates received:', {
        periodStartDate: new Date(Number(periodStart) * 1000).toLocaleString(),
        periodEndDate: new Date(Number(periodEnd) * 1000).toLocaleString(),
      });
  
      const requestData = {
        sla_address: data.sla_address,
        network_name: data.network_name,
        sla_monitoring_start: data.sla_monitoring_start,
        sla_monitoring_end: data.sla_monitoring_end,
      };
      const slaData = await getSLAData(requestData.sla_address, requestData.network_name);
  
      const messengerPrecision = await getMessengerPrecision(slaData.messengerAddress, requestData.network_name);
  
      const incidentsResponse = await axios.get(`${STATUSPAGE_API_BASE}/incidents.json`);
      const incidentsData = incidentsResponse.data;
  
      if (!incidentsData || incidentsResponse.status !== 200) {
        throw new Error('Failed to fetch incidents data');
      }
  
      // console.log('Incidents data:', incidentsData);
  
      const incidents = incidentsData.incidents;
      //const serviceQualityPercentage = calculateServiceQualityPercentage(incidents, periodStart, periodEnd);
      const serviceQualityPercentage = calculateServiceQualityPercentage(incidents, parseInt(periodStart) * 1000, parseInt(periodEnd) * 1000, messengerPrecision);
      res.status(200).json({ data: { result: serviceQualityPercentage } });
    } catch (error: any) {
      console.error('Error:', error.message);
      res.status(500).json({ error: error.message });
    }
  });  

const HOST = process.env.HOST || '0.0.0.0';
const PORT = Number(process.env.PORT) || 6070;

app.listen(PORT, HOST, () => {
  console.log(`Server is running on port ${PORT}`);
});

Next we have the OpenAIStatusPageOracle.sol file, which is our messanger contract, written in Solidity, that would be deployed to the blockchain for this new use case.

//OpenAIStatusPageOracle.sol - Messenger Contract

// SPDX-License-Identifier: MIT

pragma solidity 0.8.9;

import '@chainlink/contracts/src/v0.8/ChainlinkClient.sol';

import '@dsla-protocol/core/contracts/interfaces/IMessenger.sol';
import '@dsla-protocol/core/contracts/SLA.sol';
import '@dsla-protocol/core/contracts/PeriodRegistry.sol';
import '@dsla-protocol/core/contracts/libraries/StringUtils.sol';
import '@dsla-protocol/core/contracts/StakeRegistry.sol';

import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/utils/Strings.sol';

contract OpenAIStatusPageOracle is ChainlinkClient, IMessenger, ReentrancyGuard {
    using SafeERC20 for ERC20;
    using Chainlink for Chainlink.Request;

    mapping(bytes32 => SLIRequest) public requestIdToSLIRequest;
    bytes32[] public requests;
    address private _slaRegistryAddress;
    address private immutable _oracle;
    bytes32 private _jobId;
    uint256 private constant _baseFee = 0.1 ether;
    uint256 private _fee;
    uint256 private constant _messengerPrecision = 10**6;

    uint256 private _requestsCounter;
    uint256 private _fulfillsCounter;
    PeriodRegistry private periodRegistry;
    StakeRegistry private stakeRegistry;
    bool private retry = false;
    bytes32 public networkName;

    string public override lpName;
    string public override lpSymbol;

    string public override spName;
    string public override spSymbol;

    constructor(
        address _messengerChainlinkOracle,
        address _messengerChainlinkToken,
        uint256 _feeMultiplier,
        PeriodRegistry _periodRegistry,
        StakeRegistry _stakeRegistry,
        bytes32 _networkName,
        string memory _lpName,
        string memory _lpSymbol,
        string memory _spName,
        string memory _spSymbol
    ) {
        setChainlinkToken(_messengerChainlinkToken);
        _oracle = _messengerChainlinkOracle;
        _fee = _feeMultiplier * _baseFee;
        periodRegistry = _periodRegistry;
        stakeRegistry = _stakeRegistry;
        networkName = _networkName;
        lpName = _lpName;
        lpSymbol = _lpSymbol;
        spName = _spName;
        spSymbol = _spSymbol;
    }

    modifier onlySLARegistry() {
        if (!retry) {
            require(
                msg.sender == _slaRegistryAddress,
                'Can only be called by SLARegistry'
            );
        }
        _;
    }

    modifier retryLock() {
        retry = true;
        _;
        retry = false;
    }

    function setSLARegistry() public override {
        require(
            _slaRegistryAddress == address(0),
            'SLARegistry address has already been set'
        );

        _slaRegistryAddress = msg.sender;
    }

function requestSLI(
    uint256 _periodId,
    address _slaAddress,
    bool _messengerOwnerApproval,
    address _callerAddress
) public override onlySLARegistry nonReentrant {
    require(_jobId != 0, '_jobId empty');
    
    if (_messengerOwnerApproval) {
        ERC20(chainlinkTokenAddress()).safeTransferFrom(
            owner(),
            address(this),
            _fee
        );
    } else {
        ERC20(chainlinkTokenAddress()).safeTransferFrom(
            _callerAddress,
            address(this),
            _fee
        );
    }
    Chainlink.Request memory request = buildChainlinkRequest(
        _jobId,
        address(this),
        this.fulfillSLI.selector
    );

    // Get period start and end from the periodRegistry
    (uint256 periodStart, uint256 periodEnd) = periodRegistry.getPeriodStartAndEnd(
        SLA(_slaAddress).periodType(),
        _periodId
    );

    // Add period start and end as request parameters
    request.add("period_start", StringUtils.uintToStr(periodStart));
    request.add("period_end", StringUtils.uintToStr(periodEnd));

    // Add the 'sla_address' parameter to the request
    request.add('sla_address', StringUtils.addressToString(_slaAddress));

    // Add the 'network_name' parameter to the request
    request.add('network_name', StringUtils.bytes32ToStr(networkName));

    // Add other OpenAI StatusPage specific request parameters if needed

    // Sends the request with 0.1 LINK to the oracle contract
    bytes32 requestId = sendChainlinkRequestTo(_oracle, request, _fee);

    requests.push(requestId);

    requestIdToSLIRequest[requestId] = SLIRequest({
        slaAddress: _slaAddress,
        periodId: _periodId
    });

    _requestsCounter += 1;
    emit SLIRequested(_callerAddress, _requestsCounter, requestId);
}

    function fulfillSLI(bytes32 _requestId, uint256 _chainlinkResponse)
        external
        override
        nonReentrant
        recordChainlinkFulfillment(_requestId)
    {
        SLIRequest memory request = requestIdToSLIRequest[_requestId];
        emit SLIReceived(
            request.slaAddress,
            request.periodId,
            _requestId,
            bytes32(_chainlinkResponse)
        );
        _fulfillsCounter += 1;
        SLA(request.slaAddress).registerSLI(
            _chainlinkResponse,
            request.periodId
        );
    }

    function retryRequest(address _slaAddress, uint256 _periodId)
        external
        override
        retryLock
    {
        require(
            stakeRegistry.periodIsVerified(_slaAddress, _periodId),
            'StakeRegistry: not verified'
        );
        SLA sla = SLA(_slaAddress);
        (, , SLA.Status status) = sla.periodSLIs(_periodId);
        require(status == SLA.Status.NotVerified, 'SLA: verified');
        requestSLI(_periodId, _slaAddress, false, msg.sender);
    }

    function setChainlinkJobID(bytes32 _newJobId, uint256 _feeMultiplier)
        external
        override
        onlyOwner
    {
        _jobId = _newJobId;
        _fee = _feeMultiplier * _baseFee;
        emit JobIdModified(msg.sender, _newJobId, _fee);
    }

    function slaRegistryAddress() external view override returns (address) {
        return _slaRegistryAddress;
    }

    function messengerPrecision() external pure override returns (uint256) {
        return _messengerPrecision;
    }

    function oracle() external view override returns (address) {
        return _oracle;
    }

    function jobId() external view override returns (bytes32) {
        return _jobId;
    }

    function fee() external view override returns (uint256) {
        return _fee;
    }

    function requestsCounter() external view override returns (uint256) {
        return _requestsCounter;
    }

    function fulfillsCounter() external view override returns (uint256) {
        return _fulfillsCounter;
    }

    function lpSymbolSlaId(uint128 slaId)
        external
        view
        override
        returns (string memory)
    {
        return string(abi.encodePacked(lpSymbol, '-', Strings.toString(slaId)));
    }

    function spSymbolSlaId(uint128 slaId)
        external
        view
        override
        returns (string memory)
    {
        return string(abi.encodePacked(spSymbol, '-', Strings.toString(slaId)));
    }
}

Lastly, there is a use-case-spec.json, which defines the specifications of the new OpenAI StatusPage use case:

// use-case-spec.json - Use case specification file
{
    "useCaseName": "OpenAI StatusPage",
    "symbol": "xGPTQUALITY",
    "sp": {
      "name": "OpenAI GPT Quality Service Credit",
      "symbol": "xGPTQUALITY"
    },
    "lp": {
      "name": "OpenAI GPT Quality Service Credit LP",
      "symbol": "xGPTQUALITY-LP"
    },
    "ownerUrl": "https://dsla.network",
    "useCaseDocs": "https://dsla.network/metaverse",
    "externalAdapterRepo": "https://github.com/Stacktical/",
    "unit": "%",
    "keywords": ["openai", "statuspage", "service", "quality"],
    "timestamp": "2023-03-24T00:00:00+00:00",
    "version": {
      "major": 0,
      "minor": 0,
      "patch": 1
    }
  }

The Future with DSLA and RiskGPT

We’re excited to work on building the future of intelligent consumer risk management and integrating RiskGPT to make it happen. Please share your thoughts and comments with us in Telegram, Discord or on Twitter.

💡 DSLA Protocol

GRC Automation Middleware

DSLA’s approach to integrated risk management enables the downside-protected delivery of goods, services and digital assets without intermediaries.

👉 Get started at dsla.network

👉 Read more at stacktical.com

👉 Check our blog at blog.stacktical.com

👉 Start Building at readme.stacktical.com

👉 Join our Guild at guild.xyz/dsla

👉 Check active bounties at dework.xyz/dsla

👉 Discuss on our governance forum at commonwealth.im/dsla

Explore more like this

mainnet
BonzAI by DSLA — AI that you own, forever.

BonzAI by DSLA — AI that you own, forever.

Meet BonzAI, the new product of the DSLA family

## Meet BonzAI, the new product of the DSLA family On top of the architectural, participation requirements and tokenomics changes highlighted in [our previous article](https://blog.stacktical.com/mainnet/2024/02/27/dsla-protocol-v3.html), DSLA v3.0 represents a major shift in how we approach Risk Management using Artificial Intelligence. In order to **deliver Insurance...

DSLA Core Team DSLA Core Team
Dive into DSLA v3.0

Dive into DSLA v3.0

DSLA v2.0—Risk Management Powerhouse

## DSLA v2.0—Risk Management Powerhouse 3 years ago, DSLA v2.0 introduced a series of structural changes to the DSLA v1.0 experience: * Support for **Any Risk**, provided the performance of a third-party service can be probed through a Decentralised Oracle Network (DON); * Support for...

DSLA Core Team DSLA Core Team
The Travel Narrative

The Travel Narrative

$xMILES

## $xMILES Today, DSLA core contributors are proud to introduce a new Consumer Protection instrument, that aims at offsetting bad travel experiences using cryptoeconomics: **Travel Service Level Agreements** or **Travel SLAs**. In order to bridge the gap between Travellers Rights and Third-Party Travel Risks, Travel...

Wilhem Pujar Wilhem Pujar