crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added functions for reward balances to staking API

Browse Source
This commit is contained in:
Greg Hysen
2019-06-17 21:24:32 -07:00
parent cafa3c827c
commit 0ba8690120
5 changed files with 157 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
contracts/staking/contracts/src/Staking.sol
View File

@@ -318,23 +318,37 @@ contract Staking is
///// REWARDS /////
function computeOperatorRewardBalance(address operator, bytes32 poolId)
function getRewardBalance(bytes32 poolId)
external
view
returns (uint256)
{
return _getRewardBalance(poolId);
}
function computeDelegatorRewardBalance(address owner, bytes32 poolId)
function getRewardBalanceOfOperator(bytes32 poolId)
external
view
returns (uint256)
{
return _getRewardBalanceOfOperator(poolId);
}
///// SHADOW BALANCES /////
function getRewardBalanceOfPool(bytes32 poolId)
external
view
returns (uint256)
{
return _getRewardBalanceOfPool(poolId);
}
function computeRewardBalance(bytes32 poolId, address owner)
external
view
returns (uint256)
{
return _computeRewardBalance(poolId, owner);
}
function getShadowBalanceByPoolId(bytes32 poolId)
external
@@ -352,6 +366,34 @@ contract Staking is
return _getShadowBalanceInPoolByOwner(owner, poolId);
}
function withdrawOperatorReward(bytes32 poolId, uint256 amount)
external
onlyPoolOperator(poolId)
{
_withdrawOperatorReward(poolId, amount);
}
function withdrawReward(bytes32 poolId, uint256 amount)
external
{
_withdrawReward(poolId, msg.sender, amount);
}
function withdrawTotalOperatorReward(bytes32 poolId)
external
onlyPoolOperator(poolId)
returns (uint256)
{
return _withdrawTotalOperatorReward(poolId);
}
function withdrawTotalReward(bytes32 poolId)
external
returns (uint256)
{
return _withdrawTotalReward(poolId, msg.sender);
}
///// FEES /////
modifier onlyExchange() {
require(

98
contracts/staking/contracts/src/core/MixinRewards.sol
View File

@@ -19,37 +19,62 @@
pragma solidity ^0.5.5;
import "../immutable/MixinStorage.sol";
import "../libs/LibRewards.sol";
import "@0x/contracts-utils/contracts/src/SafeMath.sol";
import "../immutable/MixinConstants.sol";
import "../interfaces/IStakingEvents.sol";
import "./MixinStakeBalances.sol";
contract MixinRewards is
SafeMath,
LibRewards,
IStakingEvents,
MixinConstants,
MixinStorage
MixinStorage,
MixinStakeBalances
{
// Pinciple - design any Mixin such that internal members are callable without messing up internal state
// any function that could mess up internal state should be private.
// @TODO -- add a MixinZrxVault and a MixinRewardVault that interact with the vaults.
function _computeOperatorReward(address operator, bytes32 poolId)
function _getRewardBalance(bytes32 poolId)
internal
view
returns (uint256)
{
return rewardVault.balanceOf(poolId);
}
function _computeDelegatorReward(address owner, bytes32 poolId)
function _getRewardBalanceOfOperator(bytes32 poolId)
internal
view
returns (uint256)
{
return rewardVault.balanceOfOperator(poolId);
}
function _getRewardBalanceOfPool(bytes32 poolId)
internal
view
returns (uint256)
{
return rewardVault.balanceOfPool(poolId);
}
function _computeRewardBalance(bytes32 poolId, address owner)
internal
view
returns (uint256)
{
uint256 poolBalance = rewardVault.balanceOfPool(poolId);
return _computePayoutDenominatedInRealAsset(
delegatedStakeToPoolByOwner[owner][poolId],
delegatedStakeByPoolId[poolId],
shadowRewardsInPoolByOwner[owner][poolId],
shadowRewardsByPoolId[poolId],
poolBalance
);
}
function _getShadowBalanceByPoolId(bytes32 poolId)
@@ -68,43 +93,52 @@ contract MixinRewards is
return shadowRewardsInPoolByOwner[owner][poolId];
}
/*
function _withdrawReward(address owner, bytes32 poolId, uint256 amount)
function _withdrawOperatorReward(bytes32 poolId, uint256 amount)
internal
{
rewardVault.withdrawFromOperator(poolId, amount);
poolById[poolId].operatorAddress.transfer(amount);
}
function _withdrawRewardForOperator(address owner, bytes32 poolId, uint256 amount)
private
{
}
*/
function _withdrawRewardForDelegator(address owner, bytes32 poolId, uint256 amount)
function _withdrawReward(bytes32 poolId, address payable owner, uint256 amount)
internal
{
//rebateVault.withdrawFrom(owner, poolId, amount);
uint256 ownerBalance = _computeRewardBalance(poolId, owner);
require(
amount <= ownerBalance,
"INVALID_AMOUNT"
);
shadowRewardsInPoolByOwner[owner][poolId] = _safeAdd(shadowRewardsInPoolByOwner[owner][poolId], amount);
shadowRewardsByPoolId[poolId] = _safeAdd(shadowRewardsByPoolId[poolId], amount);
rewardVault.withdrawFromPool(poolId, amount);
owner.transfer(amount);
}
/*
function _withdrawTotalReward(address owner, bytes32 poolId)
function _withdrawTotalOperatorReward(bytes32 poolId)
internal
returns (uint256 amount)
returns (uint256)
{
uint256 amount = rewardVault.balanceOfOperator(poolId);
rewardVault.withdrawFromOperator(poolId, amount);
poolById[poolId].operatorAddress.transfer(amount);
return amount;
}
function _withdrawTotalRewardForOperator(address owner, bytes32 poolId)
private
function _withdrawTotalReward(bytes32 poolId, address payable owner)
internal
returns (uint256)
{
}
uint256 amount = _computeRewardBalance(poolId, owner);
function _withdrawTotalRewardForDelegator(address owner, bytes32 poolId, uint256 amount)
private
{
}*/
}
shadowRewardsInPoolByOwner[owner][poolId] = _safeAdd(shadowRewardsInPoolByOwner[owner][poolId], amount);
shadowRewardsByPoolId[poolId] = _safeAdd(shadowRewardsByPoolId[poolId], amount);
rewardVault.withdrawFromPool(poolId, amount);
owner.transfer(amount);
return amount;
}
}

10
contracts/staking/contracts/src/core/MixinStake.sol
View File

@@ -228,19 +228,11 @@ contract MixinStake is
shadowRewardsByPoolId[poolId],
poolBalance
);
emit K(
amount,
_delegatedStakeByPoolId,
payoutInShadowAsset,
shadowRewardsByPoolId[poolId],
poolBalance,
payoutInRealAsset
);
} else {
// partial payout
(payoutInRealAsset, payoutInShadowAsset) = _computePartialPayout(
amount,
_delegatedStakeByOwner,
_delegatedStakeToPoolByOwner,
_delegatedStakeByPoolId,
shadowRewardsInPoolByOwner[owner][poolId],
shadowRewardsByPoolId[poolId],

2
contracts/staking/contracts/src/interfaces/IStructs.sol
View File

@@ -28,7 +28,7 @@ interface IStructs {
}
struct Pool {
address operatorAddress;
address payable operatorAddress;
uint8 operatorShare;
}

76
contracts/staking/test/utils/staking_wrapper.ts
View File

@@ -388,61 +388,69 @@ export class StakingWrapper {
const txReceipt = await this._executeTransactionAsync(calldata, this._ownerAddres);
return txReceipt;
}
/*
///// REWARDS /////
public async computeOperatorRewardAsync(): Promise<BigNumber> {
const calldata = this.getStakingContract().computeOperatorReward.getABIEncodedTransactionData();
public async getRewardBalanceAsync(poolId: string): Promise<BigNumber> {
const calldata = this.getStakingContract().getRewardBalance.getABIEncodedTransactionData(poolId);
const returnData = await this._callAsync(calldata);
const value = this.getStakingContract().computeOperatorReward.getABIDecodedReturnData(returnData);
const value = this.getStakingContract().getRewardBalance.getABIDecodedReturnData(returnData);
return value;
}
public async computeDelegatorRewardAsync(): Promise<BigNumber> {
const calldata = this.getStakingContract().computeDelegatorReward.getABIEncodedTransactionData();
public async getRewardBalanceOfOperatorAsync(poolId: string): Promise<BigNumber> {
const calldata = this.getStakingContract().getRewardBalanceOfOperator.getABIEncodedTransactionData(poolId);
const returnData = await this._callAsync(calldata);
const value = this.getStakingContract().computeDelegatorReward.getABIDecodedReturnData(returnData);
const value = this.getStakingContract().getRewardBalanceOfOperator.getABIDecodedReturnData(returnData);
return value;
}
///// SHADOW BALANCES /////
public async getShadowBalanceByPoolIdAsync(): Promise<BigNumber> {
const calldata = this.getStakingContract().getShadowBalanceByPoolId.getABIEncodedTransactionData();
public async getRewardBalanceOfPoolAsync(poolId: string): Promise<BigNumber> {
const calldata = this.getStakingContract().getRewardBalanceOfPool.getABIEncodedTransactionData(poolId);
const returnData = await this._callAsync(calldata);
const value = this.getStakingContract().getRewardBalanceOfPool.getABIDecodedReturnData(returnData);
return value;
}
public async computeRewardBalanceAsync(poolId: string, owner: string): Promise<BigNumber> {
const calldata = this.getStakingContract().computeRewardBalance.getABIEncodedTransactionData(poolId, owner);
const returnData = await this._callAsync(calldata);
const value = this.getStakingContract().computeRewardBalance.getABIDecodedReturnData(returnData);
return value;
}
public async getShadowBalanceByPoolIdAsync(poolId: string): Promise<BigNumber> {
const calldata = this.getStakingContract().getShadowBalanceByPoolId.getABIEncodedTransactionData(poolId);
const returnData = await this._callAsync(calldata);
const value = this.getStakingContract().getShadowBalanceByPoolId.getABIDecodedReturnData(returnData);
return value;
}
public async getShadowBalanceInPoolByOwnerAsync(): Promise<BigNumber> {
const calldata = this.getStakingContract().getShadowBalanceInPoolByOwner.getABIEncodedTransactionData();
public async getShadowBalanceInPoolByOwnerAsync(owner: string, poolId: string): Promise<BigNumber> {
const calldata = this.getStakingContract().getShadowBalanceInPoolByOwner.getABIEncodedTransactionData(owner, poolId);
const returnData = await this._callAsync(calldata);
const value = this.getStakingContract().getShadowBalanceInPoolByOwner.getABIDecodedReturnData(returnData);
return value;
}
*/
///// BUY-INS & PAYOUTS /////
public async withdrawOperatorRewardAsync(poolId: string, amount: BigNumber, operatorAddress: string): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().withdrawOperatorReward.getABIEncodedTransactionData(poolId, amount);
const txReceipt = await this._executeTransactionAsync(calldata, operatorAddress);
return txReceipt;
}
public async withdrawRewardAsync(poolId: string, amount: BigNumber, owner: string): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().withdrawReward.getABIEncodedTransactionData(poolId, amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt;
}
public async withdrawTotalOperatorRewardAsync(poolId: string, operatorAddress: string): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().withdrawTotalOperatorReward.getABIEncodedTransactionData(poolId);
const txReceipt = await this._executeTransactionAsync(calldata, operatorAddress);
return txReceipt;
}
public async withdrawTotalRewardAsync(poolId: string, owner: string): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().withdrawTotalReward.getABIEncodedTransactionData(poolId);
const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt;
}
///// REWARD VAULT /////
public async rewardVaultDepositForAsync(poolId: string, amount: BigNumber, stakingContractAddress: string): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getRewardVaultContract().depositFor.getABIEncodedTransactionData(poolId);
const txReceipt = await this._executeTransactionAsync(calldata, stakingContractAddress, amount);
return txReceipt;
}
/*
public async rewardVaultWithdrawFor(poolId: string, amount: BigNumber, stakingContractAddress: string): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getRewardVaultContract().withdrawFor.getABIEncodedTransactionData(poolId, amount);
const txReceipt = await this._executeTransactionAsync(calldata, stakingContractAddress);
return txReceipt;
}
*/
/*
public async rewardVaultWithdrawAllForAsync(poolId: string): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getRewardVaultContract().withdrawAllFrom.getABIEncodedTransactionData(poolId);
const txReceipt = await this._executeTransactionAsync(calldata);
return txReceipt;
}
*/
public async rewardVaultEnterCatastrophicFailureModeAsync(zeroExMultisigAddress: string): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getRewardVaultContract().enterCatostrophicFailure.getABIEncodedTransactionData();
const txReceipt = await this._executeTransactionAsync(calldata, zeroExMultisigAddress);