DCIPs/assets/eip-6123/contracts/ISDC.sol

191 lines
9.0 KiB
Solidity

// SPDX-License-Identifier: CC0-1.0
pragma solidity >=0.7.0 <0.9.0;
/*------------------------------------------- DESCRIPTION ---------------------------------------------------------------------------------------*/
/**
* @title ERC6123 Smart Derivative Contract
* @dev Interface specification for a Smart Derivative Contract, which specifies the post-trade live cycle of an OTC financial derivative in a completely deterministic way.
* Counterparty Risk is removed by construction.
*
* A Smart Derivative Contract is a deterministic settlement protocol which has economically the same behaviour as a collateralized OTC financial derivative.
* It aims is to remove many inefficiencies in collateralized OTC transactions and remove counterparty credit risk by construction.
*
* In contrast to a collateralized derivative contract based and collateral flows are netted. As result, the smart derivative contract generates a stream of
* reflecting the settlement of a referenced underlying. The settlement cash flows may be daily (which is the standard frequency in traditional markets)
* or at higher frequencies.
* With each settlement flow the change is the (discounting adjusted) net present value of the underlying contract is exchanged and the value of the contract is reset to zero.
*
* To automatically process settlement, counterparties need to provide sufficient prefunded margin amounts and termination fees at the
* beginning of each settlement cycle. Through a settlement cycle the margin amounts are locked. Simplified, the contract reverts the classical scheme of
* 1) underlying valuation, then 2) funding of a margin call to
* 1) pre-funding of a margin buffer (a token), then 2) settlement.
*
* A SDC automatically terminates the derivatives contract if there is insufficient pre-funding or if the settlement amount exceeds a
* prefunded margin balance. Beyond mutual termination is also intended by the function specification.
*
* Events and Functionality specify the entire live cycle: TradeInception, TradeConfirmation, TradeTermination, Margin-Account-Mechanics, Valuation and Settlement.
*
* The process can be described by time points and time-intervals which are associated with well defined states:
* <ol>
* <li>t < T* (befrore incept).
* </li>
* <li>
* The process runs in cycles. Let i = 0,1,2,... denote the index of the cycle. Within each cycle there are times
* T_{i,0}, T_{i,1}, T_{i,2}, T_{i,3} with T_{i,1} = pre-funding of the Smart Contract, T_{i,2} = request valuation from oracle, T_{i,3} = perform settlement on given valuation, T_{i+1,0} = T_{i,3}.
* </li>
* <li>
* Given this time discretization the states are assigned to time points and time intervalls:
* <dl>
* <dt>Idle</dt>
* <dd>Before incept or after terminate</dd>
*
* <dt>Initiation</dt>
* <dd>T* < t < T_{0}, where T* is time of incept and T_{0} = T_{0,0}</dd>
*
* <dt>AwaitingFunding</dt>
* <dd>T_{i,0} < t < T_{i,1}</dd>
*
* <dt>Funding</dt>
* <dd>t = T_{i,1}</dd>
*
* <dt>AwaitingSettlement</dt>
* <dd>T_{i,1} < t < T_{i,2}</dd>
*
* <dt>ValuationAndSettlement</dt>
* <dd>T_{i,2} < t < T_{i,3}</dd>
*
* <dt>Settled</dt>
* <dd>t = T_{i,3}</dd>
* </dl>
* </li>
* </ol>
*/
interface ISDC {
/*------------------------------------------- EVENTS ---------------------------------------------------------------------------------------*/
/**
* @dev Emitted when a new trade is incepted from a eligible counterparty
* @param initiator is the address from which trade was incepted
* @param tradeId is the trade ID (e.g. generated internally)
* @param tradeData holding the trade parameters
*/
event TradeIncepted(address initiator, string tradeId, string tradeData);
/**
* @dev Emitted when an incepted trade is confirmed by the opposite counterparty
* @param confirmer the confirming party
* @param tradeId the trade identifier
*/
event TradeConfirmed(address confirmer, string tradeId);
/**
* @dev Emitted when a confirmed trade is set to active - e.g. when termination fee amounts are provided
* @param tradeId the trade identifier of the activated trade
*/
event TradeActivated(string tradeId);
/**
* @dev Emitted when an active trade is terminated
* @param cause string holding the cause of the termination
*/
event TradeTerminated(string cause);
/**
* @dev Emitted when funding phase is initiated
*/
event ProcessAwaitingFunding();
/**
* @dev Emitted when margin balance was updated and sufficient funding is provided
*/
event ProcessFunded();
/**
* @dev Emitted when a valuation and settlement is requested
* @param tradeData holding the stored trade data
* @param lastSettlementData holding the settlementdata from previous settlement (next settlement will be the increment of next valuation compared to former valuation)
*/
event ProcessSettlementRequest(string tradeData, string lastSettlementData);
/**
* @dev Emitted when a settlement was processed succesfully
*/
event ProcessSettled();
/**
* @dev Emitted when a counterparty proactively requests an early termination of the underlying trade
* @param cpAddress the address of the requesting party
* @param tradeId the trade identifier which is supposed to be terminated
*/
event TradeTerminationRequest(address cpAddress, string tradeId);
/**
* @dev Emitted when early termination request is confirmed by the opposite party
* @param cpAddress the party which confirms the trade termination
* @param tradeId the trade identifier which is supposed to be terminated
*/
event TradeTerminationConfirmed(address cpAddress, string tradeId);
/*------------------------------------------- FUNCTIONALITY ---------------------------------------------------------------------------------------*/
/// Trade Inception
/**
* @notice Handles trade inception, stores trade data
* @dev emits a {TradeIncepted} event
* @param _tradeData a description of the trade specification e.g. in xml format, suggested structure - see assets/eip-6123/doc/sample-tradedata-filestructure.xml
* @param _initialSettlementData the initial settlement data (e.g. initial market data at which trade was incepted)
*/
function inceptTrade(string memory _tradeData, string memory _initialSettlementData) external;
/**
* @notice Performs a matching of provided trade data and settlement data
* @dev emits a {TradeConfirmed} event if trade data match
* @param _tradeData a description of the trade in sdc.xml, e.g. in xml format, suggested structure - see assets/eip-6123/doc/sample-tradedata-filestructure.xml
* @param _initialSettlementData the initial settlement data (e.g. initial market data at which trade was incepted)
*/
function confirmTrade(string memory _tradeData, string memory _initialSettlementData) external;
/// Settlement Cycle: Prefunding
/**
* @notice Called from outside to check and secure pre-funding. Terminate the trade if prefunding fails.
* @dev emits a {ProcessFunded} event if prefunding check is successful or a {TradeTerminated} event if prefunding check fails
*/
function initiatePrefunding() external;
/// Settlement Cycle: Settlement
/**
* @notice Called to trigger a (maybe external) valuation of the underlying contract and afterwards the according settlement process
* @dev emits a {ProcessSettlementRequest}
*/
function initiateSettlement() external;
/**
* @notice Called from outside to trigger according settlement on chain-balances callback for initiateSettlement() event handler
* @dev emits a {ProcessSettled} if settlement is successful or {TradeTerminated} if settlement fails
* @param settlementAmount the settlement amount. If settlementAmount > 0 then receivingParty receives this amount from other party. If settlementAmount < 0 then other party receives -settlementAmount from receivingParty.
* @param settlementData. the tripple (product, previousSettlementData, settlementData) determines the settlementAmount.
*/
function performSettlement(int256 settlementAmount, string memory settlementData) external;
/// Trade termination
/**
* @notice Called from a counterparty to request a mutual termination
* @dev emits a {TradeTerminationRequest}
* @param tradeId the trade identifier which is supposed to be terminated
*/
function requestTradeTermination(string memory tradeId) external;
/**
* @notice Called from a counterparty to confirm a termination, which will triggers a final settlement before trade gets inactive
* @dev emits a {TradeTerminationConfirmed}
* @param tradeId the trade identifier of the trade which is supposed to be terminated
*/
function confirmTradeTermination(string memory tradeId) external;
}