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

added new staking/delegating/timelock functions to staking wrapper

Browse Source
This commit is contained in:
Greg Hysen
2019-06-03 20:54:20 -07:00
parent 79f28f121b
commit 804256075e
4 changed files with 102 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -33,49 +33,49 @@ contract Staking is
///// STAKE /////
function deposit(address owner, uint256 amount)
function deposit(uint256 amount)
external
{
_deposit(msg.sender, amount);
}
function depositAndStake(address owner, uint256 amount)
function depositAndStake(uint256 amount)
external
{
_depositAndStake(msg.sender, amount);
}
function depositAndDelegate(address owner, bytes32 poolId, uint256 amount)
function depositAndDelegate(bytes32 poolId, uint256 amount)
external
{
_depositAndDelegate(owner, poolId, amount);
_depositAndDelegate(msg.sender, poolId, amount);
}
function activateStake(address owner, uint256 amount)
function activateStake(uint256 amount)
external
{
_activateStake(msg.sender, amount);
}
function activateAndDelegateStake(address owner, bytes32 poolId, uint256 amount)
function activateAndDelegateStake(bytes32 poolId, uint256 amount)
external
{
_activateAndDelegateStake(msg.sender, poolId, amount);
}
function deactivateAndTimelockStake(address owner, uint256 amount)
function deactivateAndTimelockStake(uint256 amount)
external
{
_deactivateAndTimelockStake(msg.sender, amount);
}
function deactivateAndTimelockDelegatedStake(address owner, bytes32 poolId, uint256 amount)
function deactivateAndTimelockDelegatedStake(bytes32 poolId, uint256 amount)
external
{
_deactivateAndTimelockDelegatedStake(msg.sender, poolId, amount);
}
function withdraw(address owner, uint256 amount)
function withdraw(uint256 amount)
external
{
_withdraw(msg.sender, amount);
@@ -132,7 +132,7 @@ contract Staking is
}
function getStakeDelegatedToPoolByOwner(address owner, bytes32 poolId)
internal
external
view
returns (uint256)
{

2
contracts/staking/contracts/src/core/MixinStakeBalances.sol
View File

@@ -70,7 +70,7 @@ contract MixinStakeBalances is
view
returns (uint256)
{
return _getDeactivatedStake(owner);
}
function _getTimelockedStake(address owner)

23
contracts/staking/test/core_test.ts
View File

@@ -68,51 +68,50 @@ describe('Staking Core', () => {
await blockchainLifecycle.revertAsync();
});
describe('end-to-end tests', () => {
it('staking/unstaking', async () => {
/*
it.skip('staking/unstaking', async () => {
///// 1/3 SETUP TEST PARAMETERS /////
const amountToStake = stakingWrapper.toBaseUnitAmount(10);
const amountToUnstake = stakingWrapper.toBaseUnitAmount(5);
const owner = stakers[0];
// check zrx token balances before minting stake
const zrxTokenBalanceOfVaultBeforeStaking = await stakingWrapper.getZrxTokenBalanceOfZrxVault();
expect(zrxTokenBalanceOfVaultBeforeStaking).to.be.bignumber.equal(new BigNumber(0));
const zrxTokenBalanceOfStakerBeforeStaking = await stakingWrapper.getZrxTokenBalance(stakers[0]);
const zrxTokenBalanceOfStakerBeforeStaking = await stakingWrapper.getZrxTokenBalance(owner);
expect(zrxTokenBalanceOfStakerBeforeStaking).to.be.bignumber.gte(amountToStake);
///// 2/3 STAKE ZRX /////
{
// mint stake
const stakeMinted = await stakingWrapper.stake(stakers[0], amountToStake);
const stakeMinted = await stakingWrapper.depositAndStakeAsync(owner, amountToStake);
expect(stakeMinted).to.be.bignumber.equal(amountToStake);
// check stake balance after minting
const stakeBalance = await stakingWrapper.getStakeBalance(stakers[0]);
const stakeBalance = await stakingWrapper.getTotalStakeAsync(owner);
expect(stakeBalance).to.be.bignumber.equal(amountToStake);
// check zrx vault balance
const vaultBalance = await stakingWrapper.getZrxVaultBalance(stakers[0]);
const vaultBalance = await stakingWrapper.getZrxVaultBalance(owner);
expect(vaultBalance).to.be.bignumber.equal(amountToStake);
// check zrx token balances
const zrxTokenBalanceOfVaultAfterStaking = await stakingWrapper.getZrxTokenBalanceOfZrxVault();
expect(zrxTokenBalanceOfVaultAfterStaking).to.be.bignumber.equal(amountToStake);
const zrxTokenBalanceOfStakerAfterStaking = await stakingWrapper.getZrxTokenBalance(stakers[0]);
const zrxTokenBalanceOfStakerAfterStaking = await stakingWrapper.getZrxTokenBalance(owner);
expect(zrxTokenBalanceOfStakerAfterStaking).to.be.bignumber.equal(zrxTokenBalanceOfStakerBeforeStaking.minus(amountToStake));
}
///// 3/3 UNSTAKE ZRX /////
{
// unstake
const stakeBurned = await stakingWrapper.unstake(stakers[0], amountToUnstake);
const stakeBurned = await stakingWrapper.deactivateAndTimelockStakeAsync(owner, amountToUnstake);
expect(stakeBurned).to.be.bignumber.equal(amountToUnstake);
// check stake balance after burning
const stakeBalance = await stakingWrapper.getStakeBalance(stakers[0]);
const stakeBalance = await stakingWrapper.getActivatedStakeAsync(owner);
expect(stakeBalance).to.be.bignumber.equal(amountToStake.minus(amountToUnstake));
// check zrx vault balance
const vaultBalance = await stakingWrapper.getZrxVaultBalance(stakers[0]);
const vaultBalance = await stakingWrapper.getZrxVaultBalance(owner);
expect(vaultBalance).to.be.bignumber.equal(amountToStake.minus(amountToUnstake));
// check zrx token balances
const zrxTokenBalanceOfVaultAfterStaking = await stakingWrapper.getZrxTokenBalanceOfZrxVault();
expect(zrxTokenBalanceOfVaultAfterStaking).to.be.bignumber.equal(amountToStake.minus(amountToUnstake));
const zrxTokenBalanceOfStakerAfterStaking = await stakingWrapper.getZrxTokenBalance(stakers[0]);
const zrxTokenBalanceOfStakerAfterStaking = await stakingWrapper.getZrxTokenBalance(owner);
expect(zrxTokenBalanceOfStakerAfterStaking).to.be.bignumber.equal(zrxTokenBalanceOfStakerBeforeStaking.minus(amountToStake).plus(amountToUnstake));
}
*/
});
it('nth root', async () => {

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

@@ -115,29 +115,89 @@ export class StakingWrapper {
const returnValue = await this._web3Wrapper.callAsync(txData);
return returnValue;
}
/*
public async stake(holder: string, amount: BigNumber): Promise<BigNumber> {
const calldata = this.getStakingContract().stake.getABIEncodedTransactionData(amount);
const txReceipt = await this._executeTransactionAsync(calldata, holder);
const stakeMintedLog = this._logDecoder.decodeLogOrThrow(txReceipt.logs[1]);
const stakeMinted = (stakeMintedLog as any).args.amount;
return stakeMinted;
///// STAKE /////
public async depositAsync(owner: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().deposit.getABIEncodedTransactionData(amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt;
}
public async unstake(holder: string, amount: BigNumber): Promise<BigNumber> {
const calldata = this.getStakingContract().unstake.getABIEncodedTransactionData(amount);
const txReceipt = await this._executeTransactionAsync(calldata, holder);
const stakeBurnedLog = this._logDecoder.decodeLogOrThrow(txReceipt.logs[1]);
const stakeBurned = (stakeBurnedLog as any).args.amount;
return stakeBurned;
public async depositAndStakeAsync(owner: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().depositAndStake.getABIEncodedTransactionData(amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt;
}
public async getStakeBalance(holder: string): Promise<BigNumber> {
const calldata = this.getStakingContract().getStakeBalance.getABIEncodedTransactionData(holder);
const balance = await this._callAsync(calldata, holder);
return balance;
public async depositAndDelegateAsync(owner: string, poolId: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().depositAndDelegate.getABIEncodedTransactionData(poolId, amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt;
}
*/
public async activateStakeAsync(owner: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().activateStake.getABIEncodedTransactionData(amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt;
}
public async activateAndDelegateStakeAsync(owner: string, poolId: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().activateAndDelegateStake.getABIEncodedTransactionData(poolId, amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt;
}
public async deactivateAndTimelockStakeAsync(owner: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().deactivateAndTimelockStake.getABIEncodedTransactionData(amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt;
}
public async deactivateAndTimelockDelegatedStakeAsync(owner: string, poolId: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().deactivateAndTimelockDelegatedStake.getABIEncodedTransactionData(poolId, amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt;
}
public async withdraw(owner: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().withdraw.getABIEncodedTransactionData(amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt;
}
///// STAKE BALANCES /////
public async getTotalStakeAsync(owner: string): Promise<string> {
const calldata = this.getStakingContract().getTotalStake.getABIEncodedTransactionData(owner);
const totalStake = await this._callAsync(calldata);
return totalStake;
}
public async getActivatedStakeAsync(owner: string): Promise<string> {
const calldata = this.getStakingContract().getActivatedStake.getABIEncodedTransactionData(owner);
const activatedStake = await this._callAsync(calldata);
return activatedStake;
}
public async getDeactivatedStakeAsync(owner: string): Promise<string> {
const calldata = this.getStakingContract().getDeactivatedStake.getABIEncodedTransactionData(owner);
const deactivatedStake = await this._callAsync(calldata);
return deactivatedStake;
}
public async getWithdrawableStakeAsync(owner: string): Promise<string> {
const calldata = this.getStakingContract().getWithdrawableStake.getABIEncodedTransactionData(owner);
const withdrawableStake = await this._callAsync(calldata);
return withdrawableStake;
}
public async getTimelockedStakeAsync(owner: string): Promise<string> {
const calldata = this.getStakingContract().getTimelockedStake.getABIEncodedTransactionData(owner);
const timelockedStake = await this._callAsync(calldata);
return timelockedStake;
}
public async getStakeDelegatedByOwnerAsync(owner: string): Promise<string> {
const calldata = this.getStakingContract().getTimelockedStake.getABIEncodedTransactionData(owner);
const stakeDelegatedByOwner = await this._callAsync(calldata);
return stakeDelegatedByOwner;
}
public async getStakeDelegatedToPoolByOwnerAsync(poolId: string, owner: string): Promise<string> {
const calldata = this.getStakingContract().getStakeDelegatedToPoolByOwner.getABIEncodedTransactionData(owner, poolId);
const stakeDelegatedToPoolByOwner = await this._callAsync(calldata);
return stakeDelegatedToPoolByOwner;
}
public async getStakeDelegatedToPoolAsync(poolId: string): Promise<string> {
const calldata = this.getStakingContract().getStakeDelegatedToPool.getABIEncodedTransactionData(poolId);
const stakeDelegatedToPool = await this._callAsync(calldata);
return stakeDelegatedToPool;
}
///// POOLS /////
public async getNextPoolIdAsync(): Promise<string> {
const calldata = this.getStakingContract().getNextPoolId.getABIEncodedTransactionData();
const nextPoolId = await this._callAsync(calldata);