forked from DecentralizedClimateFoundation/DCIPs
447 lines
20 KiB
Solidity
447 lines
20 KiB
Solidity
// SPDX-License-Identifier: CC0-1.0
|
|
pragma solidity >=0.8.0 <0.9.0;
|
|
|
|
import "./ISDC.sol";
|
|
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
|
|
import "@openzeppelin/contracts/utils/Strings.sol";
|
|
|
|
|
|
/**
|
|
* @title Reference Implementation of ERC6123 - Smart Derivative Contract
|
|
* @notice This reference implementation is based on a finite state machine with predefined trade and process states (see enums below)
|
|
* Some comments on the implementation:
|
|
* - trade and process states are used in modifiers to check which function is able to be called at which state
|
|
* - trade data are stored in the contract
|
|
* - trade data matching is done in incept and confirm routine (comparing the hash of the provided data)
|
|
* - ERC-20 token is used for three participants: counterparty1 and counterparty2 and sdc
|
|
* - when prefunding is done sdc contract will hold agreed amounts and perform settlement on those
|
|
* - sdc also keeps track on internal balances for each counterparty
|
|
* - during prefunding sdc will transfer required amounts to its own balance - therefore sufficient approval is needed
|
|
* - upon termination all remaining 'locked' amounts will be transferred back to the counterparties
|
|
*/
|
|
|
|
contract SDC is ISDC {
|
|
/*
|
|
* Trade States
|
|
*/
|
|
enum TradeState {
|
|
|
|
/*
|
|
* State before the trade is incepted.
|
|
*/
|
|
Inactive,
|
|
|
|
/*
|
|
* Incepted: Trade data submitted by one party. Market data for initial valuation is set.
|
|
*/
|
|
Incepted,
|
|
|
|
/*
|
|
* Confirmed: Trade data accepted by other party.
|
|
*/
|
|
Confirmed,
|
|
|
|
/*
|
|
* Active (Confirmend + Prefunded Termination Fees). Will cycle through process states.
|
|
*/
|
|
Active,
|
|
|
|
/*
|
|
* Terminated.
|
|
*/
|
|
Terminated
|
|
}
|
|
|
|
/*
|
|
* Process States. t < T* (vor incept). 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}.
|
|
* Given this time discretization the states are assigned to time points and time intervalls:
|
|
* Idle: Before incept or after terminate
|
|
* Initiation: T* < t < T_{0}, where T* is time of incept and T_{0} = T_{0,0}
|
|
* AwaitingFunding: T_{i,0} < t < T_{i,1}
|
|
* Funding: t = T_{i,1}
|
|
* AwaitingSettlement: T_{i,1} < t < T_{i,2}
|
|
* ValuationAndSettlement: T_{i,2} < t < T_{i,3}
|
|
* Settled: t = T_{i,3}
|
|
*/
|
|
enum ProcessState {
|
|
/**
|
|
* @dev The process has not yet started or is terminated
|
|
*/
|
|
Idle,
|
|
/*
|
|
* @dev The process is initiated (incepted, but not yet completed confimation). Next: AwaitingFunding
|
|
*/
|
|
Initiation,
|
|
/*
|
|
* @dev Awaiiting preparation for funding the smart contract. Next: Funding
|
|
*/
|
|
AwaitingFunding,
|
|
/*
|
|
* @dev Prefunding the smart contract. Next: AwaitingSettlement
|
|
*/
|
|
Funding,
|
|
/*
|
|
* @dev The smart contract is completely funded and awaits settlement. Next: ValuationAndSettlement
|
|
*/
|
|
Funded,
|
|
/*
|
|
* @dev The settlement process is initiated. Next: Settled or InTermination
|
|
*/
|
|
ValuationAndSettlement,
|
|
/*
|
|
* @dev Termination started.
|
|
*/
|
|
InTermination
|
|
}
|
|
|
|
struct MarginRequirement {
|
|
int256 buffer;
|
|
int256 terminationFee;
|
|
}
|
|
|
|
/*
|
|
* Modifiers serve as guards whether at a specific process state a specific function can be called
|
|
*/
|
|
|
|
modifier onlyCounterparty() {
|
|
require(msg.sender == party1 || msg.sender == party2, "You are not a counterparty."); _;
|
|
}
|
|
modifier onlyWhenTradeInactive() {
|
|
require(tradeState == TradeState.Inactive, "Trade state is not 'Inactive'."); _;
|
|
}
|
|
modifier onlyWhenTradeIncepted() {
|
|
require(tradeState == TradeState.Incepted, "Trade state is not 'Incepted'."); _;
|
|
}
|
|
modifier onlyWhenProcessAwaitingFunding() {
|
|
require(processState == ProcessState.AwaitingFunding, "Process state is not 'AwaitingFunding'."); _;
|
|
}
|
|
modifier onlyWhenProcessFundedAndTradeActive() {
|
|
require(processState == ProcessState.Funded && tradeState == TradeState.Active, "Process state is not 'Funded' or Trade is not 'Active'."); _;
|
|
}
|
|
modifier onlyWhenProcessValuationAndSettlement() {
|
|
require(processState == ProcessState.ValuationAndSettlement, "Process state is not 'ValuationAndSettlement'."); _;
|
|
}
|
|
TradeState private tradeState;
|
|
ProcessState private processState;
|
|
|
|
address public party1;
|
|
address public party2;
|
|
address private immutable receivingPartyAddress; // Determine the receiver: Positive values are consider to be received by receivingPartyAddress. Negative values are received by the other counterparty.
|
|
|
|
/*
|
|
* liquidityToken holds:
|
|
* - funding account of party1
|
|
* - funding account of party2
|
|
* - account for SDC (sum - this is split among parties by sdcBalances)
|
|
*/
|
|
IERC20 private liquidityToken;
|
|
|
|
string private tradeID;
|
|
string private tradeData;
|
|
string private lastSettlementData;
|
|
|
|
mapping(address => MarginRequirement) private marginRequirements; // Storage of M and P per counterparty address
|
|
mapping(uint256 => address) private pendingRequests; // Stores open request hashes for several requests: initiation, update and termination
|
|
|
|
mapping(address => int256) private sdcBalances; // internal book-keeping: needed to track what part of the gross token balance is held for each party
|
|
|
|
|
|
bool private mutuallyTerminated = false;
|
|
|
|
constructor(
|
|
address counterparty1,
|
|
address counterparty2,
|
|
address receivingParty,
|
|
address tokenAddress,
|
|
uint256 initialMarginRequirement,
|
|
uint256 initalTerminationFee
|
|
) {
|
|
party1 = counterparty1;
|
|
party2 = counterparty2;
|
|
receivingPartyAddress = receivingParty;
|
|
liquidityToken = IERC20(tokenAddress);
|
|
tradeState = TradeState.Inactive;
|
|
processState = ProcessState.Idle;
|
|
marginRequirements[party1] = MarginRequirement(int256(initialMarginRequirement), int256(initalTerminationFee));
|
|
marginRequirements[party2] = MarginRequirement(int256(initialMarginRequirement), int256(initalTerminationFee));
|
|
sdcBalances[party1] = 0;
|
|
sdcBalances[party2] = 0;
|
|
}
|
|
|
|
/*
|
|
* generates a hash from tradeData and generates a map entry in openRequests
|
|
* emits a TradeIncepted
|
|
* can be called only when TradeState = Incepted
|
|
*/
|
|
function inceptTrade(string memory _tradeData, string memory _initialSettlementData) external override onlyCounterparty onlyWhenTradeInactive
|
|
{
|
|
processState = ProcessState.Initiation;
|
|
tradeState = TradeState.Incepted; // Set TradeState to Incepted
|
|
|
|
uint256 hash = uint256(keccak256(abi.encode(_tradeData, _initialSettlementData)));
|
|
pendingRequests[hash] = msg.sender;
|
|
tradeID = Strings.toString(hash);
|
|
tradeData = _tradeData; // Set trade data to enable querying already in inception state
|
|
lastSettlementData = _initialSettlementData; // Store settlement data to make them available for confirming party
|
|
|
|
emit TradeIncepted(msg.sender, tradeID, _tradeData);
|
|
}
|
|
|
|
/*
|
|
* generates a hash from tradeData and checks whether an open request can be found by the opposite party
|
|
* if so, data are stored and open request is deleted
|
|
* emits a TradeConfirmed
|
|
* can be called only when TradeState = Incepted
|
|
*/
|
|
function confirmTrade(string memory _tradeData, string memory _initialSettlementData) external override onlyCounterparty onlyWhenTradeIncepted
|
|
{
|
|
address pendingRequestParty = msg.sender == party1 ? party2 : party1;
|
|
uint256 tradeIDConf = uint256(keccak256(abi.encode(_tradeData, _initialSettlementData)));
|
|
require(pendingRequests[tradeIDConf] == pendingRequestParty, "Confirmation fails due to inconsistent trade data or wrong party address");
|
|
delete pendingRequests[tradeIDConf]; // Delete Pending Request
|
|
|
|
tradeState = TradeState.Confirmed;
|
|
emit TradeConfirmed(msg.sender, tradeID);
|
|
|
|
// Pre-Conditions
|
|
if(_lockTerminationFees()) {
|
|
tradeState = TradeState.Active;
|
|
emit TradeActivated(tradeID);
|
|
|
|
processState = ProcessState.AwaitingFunding;
|
|
emit ProcessAwaitingFunding();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check sufficient balances and lock Termination Fees otherwise trade does not get activated
|
|
*/
|
|
function _lockTerminationFees() internal returns(bool) {
|
|
bool isAvailableParty1 = (liquidityToken.balanceOf(party1) >= uint(marginRequirements[party1].terminationFee)) && (liquidityToken.allowance(party1,address(this)) >= uint(marginRequirements[party1].terminationFee));
|
|
bool isAvailableParty2 = (liquidityToken.balanceOf(party2) >= uint(marginRequirements[party2].terminationFee)) && (liquidityToken.allowance(party2,address(this)) >= uint(marginRequirements[party2].terminationFee));
|
|
if (isAvailableParty1 && isAvailableParty2){
|
|
liquidityToken.transferFrom(party1, address(this), uint(marginRequirements[party1].terminationFee)); // transfer termination fee party1 to sdc
|
|
liquidityToken.transferFrom(party2, address(this), uint(marginRequirements[party2].terminationFee)); // transfer termination fee party2 to sdc
|
|
adjustSDCBalances(marginRequirements[party1].terminationFee, marginRequirements[party2].terminationFee); // Update internal balances
|
|
return true;
|
|
}
|
|
else{
|
|
tradeState == TradeState.Inactive;
|
|
processState = ProcessState.Idle;
|
|
emit TradeTerminated("Termination Fee could not be locked.");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Failsafe: Free up accounts upon termination
|
|
*/
|
|
function _processTermination() internal {
|
|
liquidityToken.transfer(party1, uint256(sdcBalances[party1]));
|
|
liquidityToken.transfer(party2, uint256(sdcBalances[party2]));
|
|
|
|
processState = ProcessState.Idle;
|
|
tradeState = TradeState.Inactive;
|
|
}
|
|
|
|
/*
|
|
* Settlement Cycle
|
|
*/
|
|
|
|
/*
|
|
* Send an Lock Request Event only when Process State = Funding
|
|
* Puts Process state to Margin Account Check
|
|
* can be called only when ProcessState = AwaitingFunding
|
|
*/
|
|
function initiatePrefunding() external override onlyWhenProcessAwaitingFunding {
|
|
processState = ProcessState.Funding;
|
|
|
|
uint256 balanceParty1 = liquidityToken.balanceOf(party1);
|
|
uint256 balanceParty2 = liquidityToken.balanceOf(party2);
|
|
|
|
/* Calculate gap amount for each party, i.e. residual between buffer and termination fee and actual balance */
|
|
// max(M+P - sdcBalance,0)
|
|
uint gapAmountParty1 = marginRequirements[party1].buffer + marginRequirements[party1].terminationFee - sdcBalances[party1] > 0 ? uint(marginRequirements[party1].buffer + marginRequirements[party1].terminationFee - sdcBalances[party1]) : 0;
|
|
uint gapAmountParty2 = marginRequirements[party2].buffer + marginRequirements[party2].terminationFee - sdcBalances[party2] > 0 ? uint(marginRequirements[party2].buffer + marginRequirements[party2].terminationFee - sdcBalances[party2]) : 0;
|
|
|
|
/* Good case: Balances are sufficient and token has enough approval */
|
|
if ( (balanceParty1 >= gapAmountParty1 && liquidityToken.allowance(party1,address(this)) >= gapAmountParty1) &&
|
|
(balanceParty2 >= gapAmountParty2 && liquidityToken.allowance(party2,address(this)) >= gapAmountParty2) ) {
|
|
liquidityToken.transferFrom(party1, address(this), gapAmountParty1); // Transfer of GapAmount to sdc contract
|
|
liquidityToken.transferFrom(party2, address(this), gapAmountParty2); // Transfer of GapAmount to sdc contract
|
|
processState = ProcessState.Funded;
|
|
adjustSDCBalances(int(gapAmountParty1),int(gapAmountParty2)); // Update internal balances
|
|
emit ProcessFunded();
|
|
}
|
|
/* Party 1 - Bad case: Balances are insufficient or token has not enough approval */
|
|
else if ( (balanceParty1 < gapAmountParty1 || liquidityToken.allowance(party1,address(this)) < gapAmountParty1) &&
|
|
(balanceParty2 >= gapAmountParty2 && liquidityToken.allowance(party2,address(this)) >= gapAmountParty2) ) {
|
|
tradeState = TradeState.Terminated;
|
|
processState = ProcessState.InTermination;
|
|
|
|
adjustSDCBalances(-marginRequirements[party1].terminationFee,marginRequirements[party1].terminationFee); // Update internal balances
|
|
|
|
_processTermination(); // Release all buffers
|
|
emit TradeTerminated("Termination caused by party1 due to insufficient prefunding");
|
|
}
|
|
/* Party 2 - Bad case: Balances are insufficient or token has not enough approval */
|
|
else if ( (balanceParty1 >= gapAmountParty1 && liquidityToken.allowance(party1,address(this)) >= gapAmountParty1) &&
|
|
(balanceParty2 < gapAmountParty2 || liquidityToken.allowance(party2,address(this)) < gapAmountParty2) ) {
|
|
tradeState = TradeState.Terminated;
|
|
processState = ProcessState.InTermination;
|
|
|
|
adjustSDCBalances(marginRequirements[party2].terminationFee,-marginRequirements[party2].terminationFee); // Update internal balances
|
|
|
|
_processTermination(); // Release all buffers
|
|
emit TradeTerminated("Termination caused by party2 due to insufficient prefunding");
|
|
}
|
|
/* Both parties fail: Cross Transfer of Termination Fee */
|
|
else {
|
|
tradeState = TradeState.Terminated;
|
|
processState = ProcessState.InTermination;
|
|
// if ( (balanceParty1 < gapAmountParty1 || liquidityToken.allowance(party1,address(this)) < gapAmountParty1) && (balanceParty2 < gapAmountParty2 || liquidityToken.allowance(party2,address(this)) < gapAmountParty2) ) { tradeState = TradeState.Terminated;
|
|
adjustSDCBalances(marginRequirements[party2].terminationFee-marginRequirements[party1].terminationFee,marginRequirements[party1].terminationFee-marginRequirements[party2].terminationFee); // Update internal balances: Cross Booking of termination fee
|
|
|
|
_processTermination(); // Release all buffers
|
|
emit TradeTerminated("Termination caused by both parties due to insufficient prefunding");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Settlement can be initiated when margin accounts are locked, a valuation request event is emitted containing tradeData and valuationViewParty
|
|
* Changes Process State to Valuation&Settlement
|
|
* can be called only when ProcessState = Funded and TradeState = Active
|
|
*/
|
|
function initiateSettlement() external override onlyCounterparty onlyWhenProcessFundedAndTradeActive
|
|
{
|
|
processState = ProcessState.ValuationAndSettlement;
|
|
emit ProcessSettlementRequest(tradeData, lastSettlementData);
|
|
}
|
|
|
|
/*
|
|
* Performs a settelement only when processState is ValuationAndSettlement
|
|
* Puts process state to "inTransfer"
|
|
* Checks Settlement amount according to valuationViewParty: If SettlementAmount is > 0, valuationViewParty receives
|
|
* can be called only when ProcessState = ValuationAndSettlement
|
|
*/
|
|
function performSettlement(int256 settlementAmount, string memory settlementData) onlyWhenProcessValuationAndSettlement external override
|
|
{
|
|
lastSettlementData = settlementData;
|
|
address receivingParty = settlementAmount > 0 ? receivingPartyAddress : other(receivingPartyAddress);
|
|
address payingParty = other(receivingParty);
|
|
|
|
bool noTermination = abs(settlementAmount) <= marginRequirements[payingParty].buffer;
|
|
int256 transferAmount = (noTermination == true) ? abs(settlementAmount) : marginRequirements[payingParty].buffer + marginRequirements[payingParty].terminationFee; // Override with Buffer and Termination Fee: Max Transfer
|
|
|
|
if(receivingParty == party1) // Adjust internal Balances, only debit is booked on sdc balance as receiving party obtains transfer amount directly from sdc
|
|
adjustSDCBalances(0, -transferAmount);
|
|
else
|
|
adjustSDCBalances(-transferAmount, 0);
|
|
|
|
liquidityToken.transfer(receivingParty, uint256(transferAmount)); // SDC contract performs transfer to receiving party
|
|
|
|
if (noTermination) { // Regular Settlement
|
|
emit ProcessSettled();
|
|
processState = ProcessState.AwaitingFunding; // Set ProcessState to 'AwaitingFunding'
|
|
} else { // Termination Event, buffer not sufficient, transfer margin buffer and termination fee and process termination
|
|
tradeState = TradeState.Terminated;
|
|
processState = ProcessState.InTermination;
|
|
_processTermination(); // Transfer all locked amounts
|
|
emit TradeTerminated("Termination due to margin buffer exceedance");
|
|
}
|
|
|
|
if (mutuallyTerminated) { // Both counterparties agreed on a premature termination
|
|
processState = ProcessState.InTermination;
|
|
_processTermination();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* End of Cycle
|
|
*/
|
|
|
|
/*
|
|
* Can be called by a party for mutual termination
|
|
* Hash is generated an entry is put into pendingRequests
|
|
* TerminationRequest is emitted
|
|
* can be called only when ProcessState = Funded and TradeState = Active
|
|
*/
|
|
function requestTradeTermination(string memory _tradeID) external override onlyCounterparty onlyWhenProcessFundedAndTradeActive
|
|
{
|
|
require(keccak256(abi.encodePacked(tradeID)) == keccak256(abi.encodePacked(_tradeID)), "Trade ID mismatch");
|
|
uint256 hash = uint256(keccak256(abi.encode(_tradeID, "terminate")));
|
|
pendingRequests[hash] = msg.sender;
|
|
emit TradeTerminationRequest(msg.sender, _tradeID);
|
|
}
|
|
|
|
/*
|
|
|
|
* Same pattern as for initiation
|
|
* confirming party generates same hash, looks into pendingRequests, if entry is found with correct address, tradeState is put to terminated
|
|
* can be called only when ProcessState = Funded and TradeState = Active
|
|
*/
|
|
function confirmTradeTermination(string memory tradeId) external override onlyCounterparty onlyWhenProcessFundedAndTradeActive
|
|
{
|
|
address pendingRequestParty = msg.sender == party1 ? party2 : party1;
|
|
uint256 hashConfirm = uint256(keccak256(abi.encode(tradeId, "terminate")));
|
|
require(pendingRequests[hashConfirm] == pendingRequestParty, "Confirmation of termination failed due to wrong party or missing request");
|
|
delete pendingRequests[hashConfirm];
|
|
mutuallyTerminated = true;
|
|
emit TradeTerminationConfirmed(msg.sender, tradeID);
|
|
}
|
|
|
|
function adjustSDCBalances(int256 adjustmentAmountParty1, int256 adjustmentAmountParty2) internal {
|
|
if (adjustmentAmountParty1 < 0)
|
|
require(sdcBalances[party1] >= adjustmentAmountParty1, "SDC Balance Adjustment fails for Party1");
|
|
if (adjustmentAmountParty2 < 0)
|
|
require(sdcBalances[party2] >= adjustmentAmountParty2, "SDC Balance Adjustment fails for Party2");
|
|
sdcBalances[party1] = sdcBalances[party1] + adjustmentAmountParty1;
|
|
sdcBalances[party2] = sdcBalances[party2] + adjustmentAmountParty2;
|
|
}
|
|
|
|
/*
|
|
* Utilities
|
|
*/
|
|
|
|
/**
|
|
* Absolute value of an integer
|
|
*/
|
|
function abs(int x) private pure returns (int) {
|
|
return x >= 0 ? x : -x;
|
|
}
|
|
|
|
/**
|
|
* Other party
|
|
*/
|
|
function other(address party) private view returns (address) {
|
|
return (party == party1 ? party2 : party1);
|
|
}
|
|
|
|
function getTokenAddress() public view returns(address) {
|
|
return address(liquidityToken);
|
|
}
|
|
|
|
function getTradeID() public view returns (string memory) {
|
|
return tradeID;
|
|
}
|
|
|
|
function getTradeData() public view returns (string memory) {
|
|
return tradeData;
|
|
}
|
|
|
|
|
|
function getTradeState() public view returns (TradeState) {
|
|
return tradeState;
|
|
}
|
|
|
|
function getProcessState() public view returns (ProcessState) {
|
|
return processState;
|
|
}
|
|
|
|
function getOwnSdcBalance() public view returns (int256) {
|
|
return sdcBalances[msg.sender];
|
|
}
|
|
|
|
/**END OF FUNCTIONS WHICH ARE ONLY USED FOR TESTING PURPOSES */
|
|
} |