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

ran prettier

Browse Source
This commit is contained in:
Greg Hysen 2019-06-26 14:01:24 -07:00
parent b756e723ea
commit a02f96c913
20 changed files with 657 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
contracts/staking/test/actors/delegator_actor.ts
View File

@ -5,7 +5,7 @@ import {
provider, provider,
txDefaults, txDefaults,
web3Wrapper, web3Wrapper,
} from '@0x/contracts-test-utils' } from '@0x/contracts-test-utils';
import { RevertReason } from '@0x/types'; import { RevertReason } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
import * as chai from 'chai'; import * as chai from 'chai';
@ -19,21 +19,21 @@ import { StakerActor } from './staker_actor';
const expect = chai.expect; const expect = chai.expect;
export class DelegatorActor extends StakerActor { export class DelegatorActor extends StakerActor {
constructor(owner: string, stakingWrapper: StakingWrapper) { constructor(owner: string, stakingWrapper: StakingWrapper) {
super(owner, stakingWrapper); super(owner, stakingWrapper);
} }
public async depositAndDelegateAsync(poolId: string, amount: BigNumber, revertReason?: RevertReason): Promise<void> { public async depositAndDelegateAsync(
poolId: string,
amount: BigNumber,
revertReason?: RevertReason,
): Promise<void> {
// query init balances // query init balances
const initZrxBalanceOfVault = await this._stakingWrapper.getZrxTokenBalanceOfZrxVault(); const initZrxBalanceOfVault = await this._stakingWrapper.getZrxTokenBalanceOfZrxVault();
const initDelegatorBalances = await this.getBalancesAsync([poolId]); const initDelegatorBalances = await this.getBalancesAsync([poolId]);
// deposit stake // deposit stake
const txReceiptPromise = this._stakingWrapper.depositAndDelegateAsync(this._owner, poolId, amount); const txReceiptPromise = this._stakingWrapper.depositAndDelegateAsync(this._owner, poolId, amount);
if (revertReason !== undefined) { if (revertReason !== undefined) {
await expectTransactionFailedAsync( await expectTransactionFailedAsync(txReceiptPromise, revertReason);
txReceiptPromise,
revertReason
);
return; return;
} }
const txReceipt = await txReceiptPromise; const txReceipt = await txReceiptPromise;
@ -45,23 +45,26 @@ export class DelegatorActor extends StakerActor {
expectedDelegatorBalances.stakeBalanceInVault = initDelegatorBalances.stakeBalanceInVault.plus(amount); expectedDelegatorBalances.stakeBalanceInVault = initDelegatorBalances.stakeBalanceInVault.plus(amount);
expectedDelegatorBalances.activatedStakeBalance = initDelegatorBalances.activatedStakeBalance.plus(amount); expectedDelegatorBalances.activatedStakeBalance = initDelegatorBalances.activatedStakeBalance.plus(amount);
expectedDelegatorBalances.delegatedStakeBalance = initDelegatorBalances.delegatedStakeBalance.plus(amount); expectedDelegatorBalances.delegatedStakeBalance = initDelegatorBalances.delegatedStakeBalance.plus(amount);
expectedDelegatorBalances.stakeDelegatedToPoolByOwner[0] = initDelegatorBalances.stakeDelegatedToPoolByOwner[0].plus(amount); expectedDelegatorBalances.stakeDelegatedToPoolByOwner[0] = initDelegatorBalances.stakeDelegatedToPoolByOwner[0].plus(
amount,
);
expectedDelegatorBalances.stakeDelegatedToPool[0] = initDelegatorBalances.stakeDelegatedToPool[0].plus(amount); expectedDelegatorBalances.stakeDelegatedToPool[0] = initDelegatorBalances.stakeDelegatedToPool[0].plus(amount);
await this.assertBalancesAsync(expectedDelegatorBalances, [poolId]); await this.assertBalancesAsync(expectedDelegatorBalances, [poolId]);
// check zrx balance of vault // check zrx balance of vault
const finalZrxBalanceOfVault = await this._stakingWrapper.getZrxTokenBalanceOfZrxVault(); const finalZrxBalanceOfVault = await this._stakingWrapper.getZrxTokenBalanceOfZrxVault();
expect(finalZrxBalanceOfVault).to.be.bignumber.equal(initZrxBalanceOfVault.plus(amount)); expect(finalZrxBalanceOfVault).to.be.bignumber.equal(initZrxBalanceOfVault.plus(amount));
} }
public async activateAndDelegateStakeAsync(poolId: string, amount: BigNumber, revertReason?: RevertReason): Promise<void> { public async activateAndDelegateStakeAsync(
poolId: string,
amount: BigNumber,
revertReason?: RevertReason,
): Promise<void> {
// query init balances // query init balances
const initDelegatorBalances = await this.getBalancesAsync([poolId]); const initDelegatorBalances = await this.getBalancesAsync([poolId]);
// activate and delegate // activate and delegate
const txReceiptPromise = this._stakingWrapper.activateAndDelegateStakeAsync(this._owner, poolId, amount); const txReceiptPromise = this._stakingWrapper.activateAndDelegateStakeAsync(this._owner, poolId, amount);
if (revertReason !== undefined) { if (revertReason !== undefined) {
await expectTransactionFailedAsync( await expectTransactionFailedAsync(txReceiptPromise, revertReason);
txReceiptPromise,
revertReason
);
return; return;
} }
const txReceipt = await txReceiptPromise; const txReceipt = await txReceiptPromise;
@ -70,24 +73,37 @@ export class DelegatorActor extends StakerActor {
// check balances // check balances
let expectedDelegatorBalances = initDelegatorBalances; let expectedDelegatorBalances = initDelegatorBalances;
expectedDelegatorBalances.activatedStakeBalance = initDelegatorBalances.activatedStakeBalance.plus(amount); expectedDelegatorBalances.activatedStakeBalance = initDelegatorBalances.activatedStakeBalance.plus(amount);
expectedDelegatorBalances.withdrawableStakeBalance = expectedDelegatorBalances.withdrawableStakeBalance.minus(amount); expectedDelegatorBalances.withdrawableStakeBalance = expectedDelegatorBalances.withdrawableStakeBalance.minus(
expectedDelegatorBalances.activatableStakeBalance = expectedDelegatorBalances.activatableStakeBalance.minus(amount); amount,
expectedDelegatorBalances.deactivatedStakeBalance = expectedDelegatorBalances.deactivatedStakeBalance.minus(amount); );
expectedDelegatorBalances.activatableStakeBalance = expectedDelegatorBalances.activatableStakeBalance.minus(
amount,
);
expectedDelegatorBalances.deactivatedStakeBalance = expectedDelegatorBalances.deactivatedStakeBalance.minus(
amount,
);
expectedDelegatorBalances.delegatedStakeBalance = initDelegatorBalances.delegatedStakeBalance.plus(amount); expectedDelegatorBalances.delegatedStakeBalance = initDelegatorBalances.delegatedStakeBalance.plus(amount);
expectedDelegatorBalances.stakeDelegatedToPoolByOwner[0] = initDelegatorBalances.stakeDelegatedToPoolByOwner[0].plus(amount); expectedDelegatorBalances.stakeDelegatedToPoolByOwner[0] = initDelegatorBalances.stakeDelegatedToPoolByOwner[0].plus(
amount,
);
expectedDelegatorBalances.stakeDelegatedToPool[0] = initDelegatorBalances.stakeDelegatedToPool[0].plus(amount); expectedDelegatorBalances.stakeDelegatedToPool[0] = initDelegatorBalances.stakeDelegatedToPool[0].plus(amount);
await this.assertBalancesAsync(expectedDelegatorBalances, [poolId]); await this.assertBalancesAsync(expectedDelegatorBalances, [poolId]);
} }
public async deactivateAndTimelockDelegatedStakeAsync(poolId: string, amount: BigNumber, revertReason?: RevertReason): Promise<void> { public async deactivateAndTimelockDelegatedStakeAsync(
poolId: string,
amount: BigNumber,
revertReason?: RevertReason,
): Promise<void> {
// query init balances // query init balances
const initDelegatorBalances = await this.getBalancesAsync([poolId]); const initDelegatorBalances = await this.getBalancesAsync([poolId]);
// deactivate and timelock // deactivate and timelock
const txReceiptPromise = this._stakingWrapper.deactivateAndTimelockDelegatedStakeAsync(this._owner, poolId, amount); const txReceiptPromise = this._stakingWrapper.deactivateAndTimelockDelegatedStakeAsync(
if (revertReason !== undefined) { this._owner,
await expectTransactionFailedAsync( poolId,
txReceiptPromise, amount,
revertReason
); );
if (revertReason !== undefined) {
await expectTransactionFailedAsync(txReceiptPromise, revertReason);
return; return;
} }
const txReceipt = await txReceiptPromise; const txReceipt = await txReceiptPromise;
@ -95,10 +111,16 @@ export class DelegatorActor extends StakerActor {
// check balances // check balances
let expectedDelegatorBalances = initDelegatorBalances; let expectedDelegatorBalances = initDelegatorBalances;
expectedDelegatorBalances.activatedStakeBalance = initDelegatorBalances.activatedStakeBalance.minus(amount); expectedDelegatorBalances.activatedStakeBalance = initDelegatorBalances.activatedStakeBalance.minus(amount);
expectedDelegatorBalances.timelockedStakeBalance = expectedDelegatorBalances.timelockedStakeBalance.plus(amount); expectedDelegatorBalances.timelockedStakeBalance = expectedDelegatorBalances.timelockedStakeBalance.plus(
expectedDelegatorBalances.deactivatedStakeBalance = expectedDelegatorBalances.deactivatedStakeBalance.plus(amount); amount,
);
expectedDelegatorBalances.deactivatedStakeBalance = expectedDelegatorBalances.deactivatedStakeBalance.plus(
amount,
);
expectedDelegatorBalances.delegatedStakeBalance = initDelegatorBalances.delegatedStakeBalance.minus(amount); expectedDelegatorBalances.delegatedStakeBalance = initDelegatorBalances.delegatedStakeBalance.minus(amount);
expectedDelegatorBalances.stakeDelegatedToPoolByOwner[0] = initDelegatorBalances.stakeDelegatedToPoolByOwner[0].minus(amount); expectedDelegatorBalances.stakeDelegatedToPoolByOwner[0] = initDelegatorBalances.stakeDelegatedToPoolByOwner[0].minus(
amount,
);
expectedDelegatorBalances.stakeDelegatedToPool[0] = initDelegatorBalances.stakeDelegatedToPool[0].minus(amount); expectedDelegatorBalances.stakeDelegatedToPool[0] = initDelegatorBalances.stakeDelegatedToPool[0].minus(amount);
await this.assertBalancesAsync(expectedDelegatorBalances, [poolId]); await this.assertBalancesAsync(expectedDelegatorBalances, [poolId]);
} }
@ -112,7 +134,10 @@ export class DelegatorActor extends StakerActor {
}; };
const poolIds = maybePoolIds !== undefined ? maybePoolIds : []; const poolIds = maybePoolIds !== undefined ? maybePoolIds : [];
for (const poolId of poolIds) { for (const poolId of poolIds) {
const stakeDelegatedToPoolByOwner = await this._stakingWrapper.getStakeDelegatedToPoolByOwnerAsync(poolId, this._owner); const stakeDelegatedToPoolByOwner = await this._stakingWrapper.getStakeDelegatedToPoolByOwnerAsync(
poolId,
this._owner,
);
delegatorBalances.stakeDelegatedToPoolByOwner.push(stakeDelegatedToPoolByOwner); delegatorBalances.stakeDelegatedToPoolByOwner.push(stakeDelegatedToPoolByOwner);
const stakeDelegatedToPool = await this._stakingWrapper.getStakeDelegatedToPoolAsync(poolId); const stakeDelegatedToPool = await this._stakingWrapper.getStakeDelegatedToPoolAsync(poolId);
delegatorBalances.stakeDelegatedToPool.push(stakeDelegatedToPool); delegatorBalances.stakeDelegatedToPool.push(stakeDelegatedToPool);
@ -122,11 +147,19 @@ export class DelegatorActor extends StakerActor {
public async assertBalancesAsync(expectedBalances: DelegatorBalances, maybePoolIds?: string[]): Promise<void> { public async assertBalancesAsync(expectedBalances: DelegatorBalances, maybePoolIds?: string[]): Promise<void> {
await super.assertBalancesAsync(expectedBalances); await super.assertBalancesAsync(expectedBalances);
const balances = await this.getBalancesAsync(maybePoolIds); const balances = await this.getBalancesAsync(maybePoolIds);
expect(balances.delegatedStakeBalance, 'delegated stake balance').to.be.bignumber.equal(expectedBalances.delegatedStakeBalance); expect(balances.delegatedStakeBalance, 'delegated stake balance').to.be.bignumber.equal(
expectedBalances.delegatedStakeBalance,
);
const poolIds = maybePoolIds !== undefined ? maybePoolIds : []; const poolIds = maybePoolIds !== undefined ? maybePoolIds : [];
for (let i = 0; i < poolIds.length; i++) { for (let i = 0; i < poolIds.length; i++) {
expect(balances.stakeDelegatedToPoolByOwner[i], `stake delegated to pool ${poolIds[i]} by owner`).to.be.bignumber.equal(expectedBalances.stakeDelegatedToPoolByOwner[i]); expect(
expect(balances.stakeDelegatedToPool[i], `total stake delegated to pool ${poolIds[i]}`).to.be.bignumber.equal(expectedBalances.stakeDelegatedToPool[i]); balances.stakeDelegatedToPoolByOwner[i],
`stake delegated to pool ${poolIds[i]} by owner`,
).to.be.bignumber.equal(expectedBalances.stakeDelegatedToPoolByOwner[i]);
expect(
balances.stakeDelegatedToPool[i],
`total stake delegated to pool ${poolIds[i]}`,
).to.be.bignumber.equal(expectedBalances.stakeDelegatedToPool[i]);
} }
} }
} }

12
contracts/staking/test/actors/maker_actor.ts
View File

@ -5,7 +5,7 @@ import {
provider, provider,
txDefaults, txDefaults,
web3Wrapper, web3Wrapper,
} from '@0x/contracts-test-utils' } from '@0x/contracts-test-utils';
import { RevertReason } from '@0x/types'; import { RevertReason } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
import * as chai from 'chai'; import * as chai from 'chai';
@ -25,7 +25,13 @@ export class MakerActor extends BaseActor {
private readonly _signatureVerifierIfExists?: string; private readonly _signatureVerifierIfExists?: string;
private readonly _chainIdIfExists?: number; private readonly _chainIdIfExists?: number;
constructor(owner: string, stakingWrapper: StakingWrapper, ownerPrivateKey?: Buffer, signatureVerifier?: string, chainId?: number) { constructor(
owner: string,
stakingWrapper: StakingWrapper,
ownerPrivateKey?: Buffer,
signatureVerifier?: string,
chainId?: number,
) {
super(owner, stakingWrapper); super(owner, stakingWrapper);
this._ownerPrivateKeyIfExists = ownerPrivateKey; this._ownerPrivateKeyIfExists = ownerPrivateKey;
this._signatureVerifierIfExists = signatureVerifier; this._signatureVerifierIfExists = signatureVerifier;
@ -42,7 +48,7 @@ export class MakerActor extends BaseActor {
this._ownerPrivateKeyIfExists, this._ownerPrivateKeyIfExists,
this._signatureVerifierIfExists, this._signatureVerifierIfExists,
this._chainIdIfExists, this._chainIdIfExists,
signatureType signatureType,
); );
return approval; return approval;
} }

40
contracts/staking/test/actors/pool_operator_actor.ts
View File

@ -5,7 +5,7 @@ import {
provider, provider,
txDefaults, txDefaults,
web3Wrapper, web3Wrapper,
} from '@0x/contracts-test-utils' } from '@0x/contracts-test-utils';
import { RevertReason } from '@0x/types'; import { RevertReason } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
import * as chai from 'chai'; import * as chai from 'chai';
@ -20,7 +20,6 @@ import { constants as stakingConstants } from '../utils/constants';
const expect = chai.expect; const expect = chai.expect;
export class PoolOperatorActor extends BaseActor { export class PoolOperatorActor extends BaseActor {
constructor(owner: string, stakingWrapper: StakingWrapper) { constructor(owner: string, stakingWrapper: StakingWrapper) {
super(owner, stakingWrapper); super(owner, stakingWrapper);
} }
@ -31,25 +30,29 @@ export class PoolOperatorActor extends BaseActor {
// create pool // create pool
const poolIdPromise = this._stakingWrapper.createPoolAsync(this._owner, operatorShare); const poolIdPromise = this._stakingWrapper.createPoolAsync(this._owner, operatorShare);
if (revertReason !== undefined) { if (revertReason !== undefined) {
await expectTransactionFailedAsync( await expectTransactionFailedAsync(poolIdPromise, revertReason);
poolIdPromise, return '';
revertReason
);
return "";
} }
const poolId = await poolIdPromise; const poolId = await poolIdPromise;
// validate pool id // validate pool id
expect(poolId, 'pool id').to.be.bignumber.equal(nextPoolId); expect(poolId, 'pool id').to.be.bignumber.equal(nextPoolId);
return poolId; return poolId;
} }
public async addMakerToPoolAsync(poolId: string, makerAddress: string, makerSignature: string, revertReason?: RevertReason): Promise<void> { public async addMakerToPoolAsync(
poolId: string,
makerAddress: string,
makerSignature: string,
revertReason?: RevertReason,
): Promise<void> {
// add maker // add maker
const txReceiptPromise = this._stakingWrapper.addMakerToPoolAsync(poolId, makerAddress, makerSignature, this._owner); const txReceiptPromise = this._stakingWrapper.addMakerToPoolAsync(
if (revertReason !== undefined) { poolId,
await expectTransactionFailedAsync( makerAddress,
txReceiptPromise, makerSignature,
revertReason this._owner,
); );
if (revertReason !== undefined) {
await expectTransactionFailedAsync(txReceiptPromise, revertReason);
return; return;
} }
const txReceipt = await txReceiptPromise; const txReceipt = await txReceiptPromise;
@ -60,14 +63,15 @@ export class PoolOperatorActor extends BaseActor {
const makerAddressesForPool = await this._stakingWrapper.getMakerAddressesForPool(poolId); const makerAddressesForPool = await this._stakingWrapper.getMakerAddressesForPool(poolId);
expect(makerAddressesForPool, 'maker addresses for pool').to.include(makerAddress); expect(makerAddressesForPool, 'maker addresses for pool').to.include(makerAddress);
} }
public async removeMakerFromPoolAsync(poolId: string, makerAddress: string, revertReason?: RevertReason): Promise<void> { public async removeMakerFromPoolAsync(
poolId: string,
makerAddress: string,
revertReason?: RevertReason,
): Promise<void> {
// remove maker // remove maker
const txReceiptPromise = this._stakingWrapper.removeMakerFromPoolAsync(poolId, makerAddress, this._owner); const txReceiptPromise = this._stakingWrapper.removeMakerFromPoolAsync(poolId, makerAddress, this._owner);
if (revertReason !== undefined) { if (revertReason !== undefined) {
await expectTransactionFailedAsync( await expectTransactionFailedAsync(txReceiptPromise, revertReason);
txReceiptPromise,
revertReason
);
return; return;
} }
const txReceipt = await txReceiptPromise; const txReceipt = await txReceiptPromise;

53
contracts/staking/test/actors/staker_actor.ts
View File

@ -5,7 +5,7 @@ import {
provider, provider,
txDefaults, txDefaults,
web3Wrapper, web3Wrapper,
} from '@0x/contracts-test-utils' } from '@0x/contracts-test-utils';
import { RevertReason } from '@0x/types'; import { RevertReason } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
import * as chai from 'chai'; import * as chai from 'chai';
@ -18,7 +18,6 @@ import { BaseActor } from './base_actor';
const expect = chai.expect; const expect = chai.expect;
export class StakerActor extends BaseActor { export class StakerActor extends BaseActor {
constructor(owner: string, stakingWrapper: StakingWrapper) { constructor(owner: string, stakingWrapper: StakingWrapper) {
super(owner, stakingWrapper); super(owner, stakingWrapper);
} }
@ -33,10 +32,7 @@ export class StakerActor extends BaseActor {
// deposit stake // deposit stake
const txReceiptPromise = this._stakingWrapper.depositAndStakeAsync(this._owner, amount); const txReceiptPromise = this._stakingWrapper.depositAndStakeAsync(this._owner, amount);
if (revertReason !== undefined) { if (revertReason !== undefined) {
await expectTransactionFailedAsync( await expectTransactionFailedAsync(txReceiptPromise, revertReason);
txReceiptPromise,
revertReason
);
return; return;
} }
const txReceipt = await txReceiptPromise; const txReceipt = await txReceiptPromise;
@ -58,10 +54,7 @@ export class StakerActor extends BaseActor {
// activate stake // activate stake
const txReceiptPromise = this._stakingWrapper.activateStakeAsync(this._owner, amount); const txReceiptPromise = this._stakingWrapper.activateStakeAsync(this._owner, amount);
if (revertReason !== undefined) { if (revertReason !== undefined) {
await expectTransactionFailedAsync( await expectTransactionFailedAsync(txReceiptPromise, revertReason);
txReceiptPromise,
revertReason
);
return; return;
} }
const txReceipt = await txReceiptPromise; const txReceipt = await txReceiptPromise;
@ -80,10 +73,7 @@ export class StakerActor extends BaseActor {
// deactivate and timelock stake // deactivate and timelock stake
const txReceiptPromise = this._stakingWrapper.deactivateAndTimelockStakeAsync(this._owner, amount); const txReceiptPromise = this._stakingWrapper.deactivateAndTimelockStakeAsync(this._owner, amount);
if (revertReason !== undefined) { if (revertReason !== undefined) {
await expectTransactionFailedAsync( await expectTransactionFailedAsync(txReceiptPromise, revertReason);
txReceiptPromise,
revertReason
);
return; return;
} }
const txReceipt = await txReceiptPromise; const txReceipt = await txReceiptPromise;
@ -102,10 +92,7 @@ export class StakerActor extends BaseActor {
// withdraw stake // withdraw stake
const txReceiptPromise = this._stakingWrapper.withdrawAsync(this._owner, amount); const txReceiptPromise = this._stakingWrapper.withdrawAsync(this._owner, amount);
if (revertReason !== undefined) { if (revertReason !== undefined) {
await expectTransactionFailedAsync( await expectTransactionFailedAsync(txReceiptPromise, revertReason);
txReceiptPromise,
revertReason
);
return; return;
} }
const txReceipt = await txReceiptPromise; const txReceipt = await txReceiptPromise;
@ -133,19 +120,31 @@ export class StakerActor extends BaseActor {
activatedStakeBalance: await this._stakingWrapper.getActivatedStakeAsync(this._owner), activatedStakeBalance: await this._stakingWrapper.getActivatedStakeAsync(this._owner),
timelockedStakeBalance: await this._stakingWrapper.getTimelockedStakeAsync(this._owner), timelockedStakeBalance: await this._stakingWrapper.getTimelockedStakeAsync(this._owner),
deactivatedStakeBalance: await this._stakingWrapper.getDeactivatedStakeAsync(this._owner), deactivatedStakeBalance: await this._stakingWrapper.getDeactivatedStakeAsync(this._owner),
} };
return stakerBalances; return stakerBalances;
} }
public async assertBalancesAsync(expectedBalances: StakerBalances): Promise<void> { public async assertBalancesAsync(expectedBalances: StakerBalances): Promise<void> {
const balances = await this.getBalancesAsync(); const balances = await this.getBalancesAsync();
expect(balances.zrxBalance, 'zrx balance').to.be.bignumber.equal(expectedBalances.zrxBalance); expect(balances.zrxBalance, 'zrx balance').to.be.bignumber.equal(expectedBalances.zrxBalance);
expect(balances.stakeBalance, 'stake balance').to.be.bignumber.equal(expectedBalances.stakeBalance); expect(balances.stakeBalance, 'stake balance').to.be.bignumber.equal(expectedBalances.stakeBalance);
expect(balances.stakeBalanceInVault, 'stake balance, recorded in vault').to.be.bignumber.equal(expectedBalances.stakeBalanceInVault); expect(balances.stakeBalanceInVault, 'stake balance, recorded in vault').to.be.bignumber.equal(
expect(balances.withdrawableStakeBalance, 'withdrawable stake balance').to.be.bignumber.equal(expectedBalances.withdrawableStakeBalance); expectedBalances.stakeBalanceInVault,
expect(balances.activatableStakeBalance, 'activatable stake balance').to.be.bignumber.equal(expectedBalances.activatableStakeBalance); );
expect(balances.activatedStakeBalance, 'activated stake balance').to.be.bignumber.equal(expectedBalances.activatedStakeBalance); expect(balances.withdrawableStakeBalance, 'withdrawable stake balance').to.be.bignumber.equal(
expect(balances.timelockedStakeBalance, 'timelocked stake balance').to.be.bignumber.equal(expectedBalances.timelockedStakeBalance); expectedBalances.withdrawableStakeBalance,
expect(balances.deactivatedStakeBalance, 'deactivated stake balance').to.be.bignumber.equal(expectedBalances.deactivatedStakeBalance); );
expect(balances.activatableStakeBalance, 'activatable stake balance').to.be.bignumber.equal(
expectedBalances.activatableStakeBalance,
);
expect(balances.activatedStakeBalance, 'activated stake balance').to.be.bignumber.equal(
expectedBalances.activatedStakeBalance,
);
expect(balances.timelockedStakeBalance, 'timelocked stake balance').to.be.bignumber.equal(
expectedBalances.timelockedStakeBalance,
);
expect(balances.deactivatedStakeBalance, 'deactivated stake balance').to.be.bignumber.equal(
expectedBalances.deactivatedStakeBalance,
);
} }
public async forceTimelockSyncAsync(): Promise<void> { public async forceTimelockSyncAsync(): Promise<void> {
const initBalances = await this.getBalancesAsync(); const initBalances = await this.getBalancesAsync();
@ -162,7 +161,9 @@ export class StakerActor extends BaseActor {
let expectedBalances = initBalances; let expectedBalances = initBalances;
const currentTimelockPeriod = await this._stakingWrapper.getCurrentTimelockPeriodAsync(); const currentTimelockPeriod = await this._stakingWrapper.getCurrentTimelockPeriodAsync();
if (currentTimelockPeriod.minus(timelockStart).isGreaterThan(1)) { if (currentTimelockPeriod.minus(timelockStart).isGreaterThan(1)) {
expectedBalances.activatableStakeBalance = initBalances.activatableStakeBalance.plus(initBalances.timelockedStakeBalance); expectedBalances.activatableStakeBalance = initBalances.activatableStakeBalance.plus(
initBalances.timelockedStakeBalance,
);
expectedBalances.withdrawableStakeBalance = expectedBalances.activatableStakeBalance; expectedBalances.withdrawableStakeBalance = expectedBalances.activatableStakeBalance;
expectedBalances.timelockedStakeBalance = new BigNumber(0); expectedBalances.timelockedStakeBalance = new BigNumber(0);
} }

8
contracts/staking/test/epoch_test.ts
View File

@ -72,8 +72,12 @@ describe('Epochs', () => {
describe('Epochs & Timelocks', () => { describe('Epochs & Timelocks', () => {
it('basic epochs & timelock periods', async () => { it('basic epochs & timelock periods', async () => {
///// 0/3 Validate Assumptions ///// ///// 0/3 Validate Assumptions /////
expect(await stakingWrapper.getEpochPeriodInSecondsAsync()).to.be.bignumber.equal(stakingConstants.EPOCH_PERIOD_IN_SECONDS); expect(await stakingWrapper.getEpochPeriodInSecondsAsync()).to.be.bignumber.equal(
expect(await stakingWrapper.getTimelockPeriodInEpochsAsync()).to.be.bignumber.equal(stakingConstants.TIMELOCK_PERIOD_IN_EPOCHS); stakingConstants.EPOCH_PERIOD_IN_SECONDS,
);
expect(await stakingWrapper.getTimelockPeriodInEpochsAsync()).to.be.bignumber.equal(
stakingConstants.TIMELOCK_PERIOD_IN_EPOCHS,
);
///// 1/3 Validate Initial Epoch & Timelock Period ///// ///// 1/3 Validate Initial Epoch & Timelock Period /////
{ {

7
contracts/staking/test/exchange_test.ts
View File

@ -21,7 +21,6 @@ import { StakingWrapper } from './utils/staking_wrapper';
import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy'; import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy';
import { StakingContract } from '../src'; import { StakingContract } from '../src';
import { StakerActor } from './actors/staker_actor'; import { StakerActor } from './actors/staker_actor';
import { DelegatorActor } from './actors/delegator_actor'; import { DelegatorActor } from './actors/delegator_actor';
@ -77,7 +76,7 @@ describe('Exchange Integrations', () => {
describe('Exchange Tracking in Staking Contract', () => { describe('Exchange Tracking in Staking Contract', () => {
it('basic exchange tracking', async () => { it('basic exchange tracking', async () => {
// 1 try querying an invalid addresses // 1 try querying an invalid addresses
const invalidAddress = "0x0000000000000000000000000000000000000001"; const invalidAddress = '0x0000000000000000000000000000000000000001';
const isInvalidAddressValid = await stakingWrapper.isValidExchangeAddressAsync(invalidAddress); const isInvalidAddressValid = await stakingWrapper.isValidExchangeAddressAsync(invalidAddress);
expect(isInvalidAddressValid).to.be.false(); expect(isInvalidAddressValid).to.be.false();
// 2 add valid address // 2 add valid address
@ -87,7 +86,7 @@ describe('Exchange Integrations', () => {
// 3 try adding valid address again // 3 try adding valid address again
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
stakingWrapper.addExchangeAddressAsync(exchange), stakingWrapper.addExchangeAddressAsync(exchange),
RevertReason.ExchangeAddressAlreadyRegistered RevertReason.ExchangeAddressAlreadyRegistered,
); );
// 4 remove valid address // 4 remove valid address
await stakingWrapper.removeExchangeAddressAsync(exchange); await stakingWrapper.removeExchangeAddressAsync(exchange);
@ -96,7 +95,7 @@ describe('Exchange Integrations', () => {
// 5 try removing valid address again // 5 try removing valid address again
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
stakingWrapper.removeExchangeAddressAsync(exchange), stakingWrapper.removeExchangeAddressAsync(exchange),
RevertReason.ExchangeAddressNotRegistered RevertReason.ExchangeAddressNotRegistered,
); );
}); });
}); });

22
contracts/staking/test/math_test.ts
View File

@ -16,7 +16,6 @@ import { StakingWrapper } from './utils/staking_wrapper';
import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy'; import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy';
chaiSetup.configure(); chaiSetup.configure();
const expect = chai.expect; const expect = chai.expect;
const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper); const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
@ -126,9 +125,12 @@ describe('Math Libraries', () => {
ownerStake, ownerStake,
totalStake, totalStake,
alphaNumerator, alphaNumerator,
alphaDenominator alphaDenominator,
);
const ownerRewardFloatingPoint = stakingWrapper.trimFloat(
stakingWrapper.toFloatingPoint(ownerReward, 18),
4,
); );
const ownerRewardFloatingPoint = stakingWrapper.trimFloat(stakingWrapper.toFloatingPoint(ownerReward, 18), 4);
// validation // validation
expect(ownerRewardFloatingPoint).to.be.bignumber.equal(expectedOwnerReward); expect(ownerRewardFloatingPoint).to.be.bignumber.equal(expectedOwnerReward);
}); });
@ -151,9 +153,12 @@ describe('Math Libraries', () => {
totalFees, totalFees,
ownerStake, ownerStake,
totalStake, totalStake,
alphaDenominator alphaDenominator,
);
const ownerRewardFloatingPoint = stakingWrapper.trimFloat(
stakingWrapper.toFloatingPoint(ownerReward, 18),
14,
); );
const ownerRewardFloatingPoint = stakingWrapper.trimFloat(stakingWrapper.toFloatingPoint(ownerReward, 18), 14);
// validation // validation
expect(ownerRewardFloatingPoint).to.be.bignumber.equal(expectedOwnerReward); expect(ownerRewardFloatingPoint).to.be.bignumber.equal(expectedOwnerReward);
}); });
@ -175,9 +180,12 @@ describe('Math Libraries', () => {
totalFees, totalFees,
ownerStake, ownerStake,
totalStake, totalStake,
inverseAlphaDenominator inverseAlphaDenominator,
);
const ownerRewardFloatingPoint = stakingWrapper.trimFloat(
stakingWrapper.toFloatingPoint(ownerReward, 18),
12,
); );
const ownerRewardFloatingPoint = stakingWrapper.trimFloat(stakingWrapper.toFloatingPoint(ownerReward, 18), 12);
// validation // validation
expect(ownerRewardFloatingPoint).to.be.bignumber.equal(expectedOwnerReward); expect(ownerRewardFloatingPoint).to.be.bignumber.equal(expectedOwnerReward);
}); });

47
contracts/staking/test/pools_test.ts
View File

@ -22,7 +22,6 @@ import { StakingWrapper } from './utils/staking_wrapper';
import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy'; import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy';
import { StakingContract } from '../src'; import { StakingContract } from '../src';
import { StakerActor } from './actors/staker_actor'; import { StakerActor } from './actors/staker_actor';
import { DelegatorActor } from './actors/delegator_actor'; import { DelegatorActor } from './actors/delegator_actor';
import { PoolOperatorActor } from './actors/pool_operator_actor'; import { PoolOperatorActor } from './actors/pool_operator_actor';
@ -84,7 +83,7 @@ describe('Staking Pool Management', () => {
const poolId = await poolOperator.createPoolAsync(operatorShare); const poolId = await poolOperator.createPoolAsync(operatorShare);
expect(poolId).to.be.equal(stakingConstants.INITIAL_POOL_ID); expect(poolId).to.be.equal(stakingConstants.INITIAL_POOL_ID);
// check that the next pool id was incremented // check that the next pool id was incremented
const expectedNextPoolId = "0x0000000000000000000000000000000200000000000000000000000000000000"; const expectedNextPoolId = '0x0000000000000000000000000000000200000000000000000000000000000000';
const nextPoolId = await stakingWrapper.getNextPoolIdAsync(); const nextPoolId = await stakingWrapper.getNextPoolIdAsync();
expect(nextPoolId).to.be.equal(expectedNextPoolId); expect(nextPoolId).to.be.equal(expectedNextPoolId);
}); });
@ -147,7 +146,12 @@ describe('Staking Pool Management', () => {
const makerApproval = maker.signApprovalForStakingPool(poolId); const makerApproval = maker.signApprovalForStakingPool(poolId);
await poolOperator.addMakerToPoolAsync(poolId, makerAddress, makerApproval.signature); await poolOperator.addMakerToPoolAsync(poolId, makerAddress, makerApproval.signature);
// add same maker to pool again // add same maker to pool again
await poolOperator.addMakerToPoolAsync(poolId, makerAddress, makerApproval.signature, RevertReason.MakerAddressAlreadyRegistered); await poolOperator.addMakerToPoolAsync(
poolId,
makerAddress,
makerApproval.signature,
RevertReason.MakerAddressAlreadyRegistered,
);
}); });
it('Should fail to remove a maker that does not exist', async () => { it('Should fail to remove a maker that does not exist', async () => {
// test parameters // test parameters
@ -168,14 +172,21 @@ describe('Staking Pool Management', () => {
const operatorShare = 39; const operatorShare = 39;
const poolOperator = new PoolOperatorActor(operatorAddress, stakingWrapper); const poolOperator = new PoolOperatorActor(operatorAddress, stakingWrapper);
const makerAddress = users[1]; const makerAddress = users[1];
const badMakerPrivateKey = ethUtil.toBuffer('0x0000000000000000000000000000000000000000000000000000000000000001'); const badMakerPrivateKey = ethUtil.toBuffer(
'0x0000000000000000000000000000000000000000000000000000000000000001',
);
const maker = new MakerActor(makerAddress, stakingWrapper, badMakerPrivateKey); const maker = new MakerActor(makerAddress, stakingWrapper, badMakerPrivateKey);
// create pool // create pool
const poolId = await poolOperator.createPoolAsync(operatorShare); const poolId = await poolOperator.createPoolAsync(operatorShare);
expect(poolId).to.be.equal(stakingConstants.INITIAL_POOL_ID); expect(poolId).to.be.equal(stakingConstants.INITIAL_POOL_ID);
// add maker to pool // add maker to pool
const makerApproval = maker.signApprovalForStakingPool(poolId); const makerApproval = maker.signApprovalForStakingPool(poolId);
await poolOperator.addMakerToPoolAsync(poolId, makerAddress, makerApproval.signature, RevertReason.InvalidMakerSignature); await poolOperator.addMakerToPoolAsync(
poolId,
makerAddress,
makerApproval.signature,
RevertReason.InvalidMakerSignature,
);
}); });
it('Should fail to add a maker who signed with the wrong staking contract address', async () => { it('Should fail to add a maker who signed with the wrong staking contract address', async () => {
// test parameters // test parameters
@ -191,7 +202,12 @@ describe('Staking Pool Management', () => {
expect(poolId).to.be.equal(stakingConstants.INITIAL_POOL_ID); expect(poolId).to.be.equal(stakingConstants.INITIAL_POOL_ID);
// add maker to pool // add maker to pool
const makerApproval = maker.signApprovalForStakingPool(poolId); const makerApproval = maker.signApprovalForStakingPool(poolId);
await poolOperator.addMakerToPoolAsync(poolId, makerAddress, makerApproval.signature, RevertReason.InvalidMakerSignature); await poolOperator.addMakerToPoolAsync(
poolId,
makerAddress,
makerApproval.signature,
RevertReason.InvalidMakerSignature,
);
}); });
it('Should fail to add a maker who signed with the wrong chain id', async () => { it('Should fail to add a maker who signed with the wrong chain id', async () => {
// test parameters // test parameters
@ -202,13 +218,24 @@ describe('Staking Pool Management', () => {
const forceMakerKeyLookup = undefined; const forceMakerKeyLookup = undefined;
const forceStakingContractLookup = undefined; const forceStakingContractLookup = undefined;
const badChainId = 209348; const badChainId = 209348;
const maker = new MakerActor(makerAddress, stakingWrapper, forceMakerKeyLookup, forceStakingContractLookup, badChainId); const maker = new MakerActor(
makerAddress,
stakingWrapper,
forceMakerKeyLookup,
forceStakingContractLookup,
badChainId,
);
// create pool // create pool
const poolId = await poolOperator.createPoolAsync(operatorShare); const poolId = await poolOperator.createPoolAsync(operatorShare);
expect(poolId).to.be.equal(stakingConstants.INITIAL_POOL_ID); expect(poolId).to.be.equal(stakingConstants.INITIAL_POOL_ID);
// add maker to pool // add maker to pool
const makerApproval = maker.signApprovalForStakingPool(poolId); const makerApproval = maker.signApprovalForStakingPool(poolId);
await poolOperator.addMakerToPoolAsync(poolId, makerAddress, makerApproval.signature, RevertReason.InvalidMakerSignature); await poolOperator.addMakerToPoolAsync(
poolId,
makerAddress,
makerApproval.signature,
RevertReason.InvalidMakerSignature,
);
}); });
it('Should fail to add a maker when called by someone other than the pool operator', async () => { it('Should fail to add a maker when called by someone other than the pool operator', async () => {
// test parameters // test parameters
@ -225,7 +252,7 @@ describe('Staking Pool Management', () => {
const makerApproval = maker.signApprovalForStakingPool(poolId); const makerApproval = maker.signApprovalForStakingPool(poolId);
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
stakingWrapper.addMakerToPoolAsync(poolId, makerAddress, makerApproval.signature, notOperatorAddress), stakingWrapper.addMakerToPoolAsync(poolId, makerAddress, makerApproval.signature, notOperatorAddress),
RevertReason.OnlyCallableByPoolOperator RevertReason.OnlyCallableByPoolOperator,
); );
}); });
it('Should fail to remove a maker when called by someone other than the pool operator', async () => { it('Should fail to remove a maker when called by someone other than the pool operator', async () => {
@ -245,7 +272,7 @@ describe('Staking Pool Management', () => {
// try to remove the maker address from an address other than the operator // try to remove the maker address from an address other than the operator
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
stakingWrapper.removeMakerFromPoolAsync(poolId, makerAddress, notOperatorAddress), stakingWrapper.removeMakerFromPoolAsync(poolId, makerAddress, notOperatorAddress),
RevertReason.OnlyCallableByPoolOperator RevertReason.OnlyCallableByPoolOperator,
); );
}); });
}); });

27
contracts/staking/test/simulations_test.ts
View File

@ -21,7 +21,6 @@ import { StakingWrapper } from './utils/staking_wrapper';
import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy'; import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy';
import { StakingContract } from '../src'; import { StakingContract } from '../src';
import { StakerActor } from './actors/staker_actor'; import { StakerActor } from './actors/staker_actor';
import { DelegatorActor } from './actors/delegator_actor'; import { DelegatorActor } from './actors/delegator_actor';
@ -47,7 +46,6 @@ describe('End-To-End Simulations', () => {
let makers: string[]; let makers: string[];
let delegators: string[]; let delegators: string[];
// wrappers // wrappers
let stakingWrapper: StakingWrapper; let stakingWrapper: StakingWrapper;
let erc20Wrapper: ERC20Wrapper; let erc20Wrapper: ERC20Wrapper;
@ -69,7 +67,6 @@ describe('End-To-End Simulations', () => {
makers = accounts.slice(4, 10); makers = accounts.slice(4, 10);
users = [...users, ...users]; // maybe this'll work? Not sure lol. users = [...users, ...users]; // maybe this'll work? Not sure lol.
// deploy erc20 proxy // deploy erc20 proxy
erc20Wrapper = new ERC20Wrapper(provider, accounts, owner); erc20Wrapper = new ERC20Wrapper(provider, accounts, owner);
erc20ProxyContract = await erc20Wrapper.deployProxyAsync(); erc20ProxyContract = await erc20Wrapper.deployProxyAsync();
@ -109,7 +106,7 @@ describe('End-To-End Simulations', () => {
// pool 3 // pool 3
stakingWrapper.toBaseUnitAmount(23.577), stakingWrapper.toBaseUnitAmount(23.577),
stakingWrapper.toBaseUnitAmount(4.54522236), stakingWrapper.toBaseUnitAmount(4.54522236),
stakingWrapper.toBaseUnitAmount(0) stakingWrapper.toBaseUnitAmount(0),
], ],
numberOfDelegators: 0, numberOfDelegators: 0,
numberOfDelegatorsPerPool: [0, 0, 0], numberOfDelegatorsPerPool: [0, 0, 0],
@ -131,14 +128,9 @@ describe('End-To-End Simulations', () => {
new BigNumber('16.28130'), // 16.28130500394935316563988584956596823402223838026190634525 new BigNumber('16.28130'), // 16.28130500394935316563988584956596823402223838026190634525
new BigNumber('20.31028'), // 20.31028447343014834523983759032242063760612769662934308289 new BigNumber('20.31028'), // 20.31028447343014834523983759032242063760612769662934308289
], ],
expectedMembersPayoutByPool: [ expectedMembersPayoutByPool: [new BigNumber('0'), new BigNumber('0'), new BigNumber('0')],
new BigNumber('0'),
new BigNumber('0'),
new BigNumber('0'),
],
expectedPayoutByDelegator: [], expectedPayoutByDelegator: [],
exchangeAddress: exchange, exchangeAddress: exchange,
}; };
const simulator = new Simulation(stakingWrapper, simulationParams); const simulator = new Simulation(stakingWrapper, simulationParams);
await simulator.runAsync(); await simulator.runAsync();
@ -178,7 +170,7 @@ describe('End-To-End Simulations', () => {
// pool 3 // pool 3
stakingWrapper.toBaseUnitAmount(23.577), stakingWrapper.toBaseUnitAmount(23.577),
stakingWrapper.toBaseUnitAmount(4.54522236), stakingWrapper.toBaseUnitAmount(4.54522236),
stakingWrapper.toBaseUnitAmount(0) stakingWrapper.toBaseUnitAmount(0),
], ],
numberOfDelegators: 3, numberOfDelegators: 3,
numberOfDelegatorsPerPool: [0, 0, 3], numberOfDelegatorsPerPool: [0, 0, 3],
@ -202,7 +194,7 @@ describe('End-To-End Simulations', () => {
expectedPayoutByPoolOperator: [ expectedPayoutByPoolOperator: [
new BigNumber('1.12828'), // 0.39 * 2.89303 new BigNumber('1.12828'), // 0.39 * 2.89303
new BigNumber('5.84228'), // 0.59 * 9.90218 new BigNumber('5.84228'), // 0.59 * 9.90218
new BigNumber('12.11079') // 0.43 * 28.16463 new BigNumber('12.11079'), // 0.43 * 28.16463
], ],
expectedMembersPayoutByPool: [ expectedMembersPayoutByPool: [
new BigNumber('1.76475'), // (1 - 0.39) * 2.89303 new BigNumber('1.76475'), // (1 - 0.39) * 2.89303
@ -260,7 +252,7 @@ describe('End-To-End Simulations', () => {
// pool 3 // pool 3
stakingWrapper.toBaseUnitAmount(23.577), stakingWrapper.toBaseUnitAmount(23.577),
stakingWrapper.toBaseUnitAmount(4.54522236), stakingWrapper.toBaseUnitAmount(4.54522236),
stakingWrapper.toBaseUnitAmount(0) stakingWrapper.toBaseUnitAmount(0),
], ],
numberOfDelegators: 3, numberOfDelegators: 3,
numberOfDelegatorsPerPool: [0, 0, 3], numberOfDelegatorsPerPool: [0, 0, 3],
@ -284,7 +276,7 @@ describe('End-To-End Simulations', () => {
expectedPayoutByPoolOperator: [ expectedPayoutByPoolOperator: [
new BigNumber('1.85514'), // 0.39 * 4.75677 new BigNumber('1.85514'), // 0.39 * 4.75677
new BigNumber('9.60597'), // 0.59 * 16.28130 new BigNumber('9.60597'), // 0.59 * 16.28130
new BigNumber('8.73342') // 0.43 * 20.31028 new BigNumber('8.73342'), // 0.43 * 20.31028
], ],
expectedMembersPayoutByPool: [ expectedMembersPayoutByPool: [
new BigNumber('2.90163'), // (1 - 0.39) * 4.75677 new BigNumber('2.90163'), // (1 - 0.39) * 4.75677
@ -339,7 +331,7 @@ describe('End-To-End Simulations', () => {
// pool 3 // pool 3
stakingWrapper.toBaseUnitAmount(23.577), stakingWrapper.toBaseUnitAmount(23.577),
stakingWrapper.toBaseUnitAmount(4.54522236), stakingWrapper.toBaseUnitAmount(4.54522236),
stakingWrapper.toBaseUnitAmount(0) stakingWrapper.toBaseUnitAmount(0),
], ],
numberOfDelegators: 3, numberOfDelegators: 3,
numberOfDelegatorsPerPool: [0, 0, 3], numberOfDelegatorsPerPool: [0, 0, 3],
@ -363,7 +355,7 @@ describe('End-To-End Simulations', () => {
expectedPayoutByPoolOperator: [ expectedPayoutByPoolOperator: [
new BigNumber('1.85514'), // 0.39 * 4.75677 new BigNumber('1.85514'), // 0.39 * 4.75677
new BigNumber('9.60597'), // 0.59 * 16.28130 new BigNumber('9.60597'), // 0.59 * 16.28130
new BigNumber('8.73342') // 0.43 * 20.31028 new BigNumber('8.73342'), // 0.43 * 20.31028
], ],
expectedMembersPayoutByPool: [ expectedMembersPayoutByPool: [
new BigNumber('2.90163'), // (1 - 0.39) * 4.75677 new BigNumber('2.90163'), // (1 - 0.39) * 4.75677
@ -376,7 +368,6 @@ describe('End-To-End Simulations', () => {
new BigNumber(0), new BigNumber(0),
], ],
exchangeAddress: exchange, exchangeAddress: exchange,
}; };
const simulator = new Simulation(stakingWrapper, simulationParams); const simulator = new Simulation(stakingWrapper, simulationParams);
await simulator.runAsync(); await simulator.runAsync();
@ -387,7 +378,7 @@ describe('End-To-End Simulations', () => {
const protocolFee = new BigNumber(1); const protocolFee = new BigNumber(1);
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
stakingWrapper.payProtocolFeeAsync(makerAddress, protocolFee, owner), stakingWrapper.payProtocolFeeAsync(makerAddress, protocolFee, owner),
RevertReason.OnlyCallableByExchange RevertReason.OnlyCallableByExchange,
); );
}); });
}); });

1
contracts/staking/test/stake_test.ts
View File

@ -21,7 +21,6 @@ import { StakingWrapper } from './utils/staking_wrapper';
import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy'; import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy';
import { StakingContract } from '../src'; import { StakingContract } from '../src';
import { StakerActor } from './actors/staker_actor'; import { StakerActor } from './actors/staker_actor';
import { DelegatorActor } from './actors/delegator_actor'; import { DelegatorActor } from './actors/delegator_actor';

2
contracts/staking/test/utils/ApprovalFactory.ts
View File

@ -26,7 +26,7 @@ export class ApprovalFactory {
poolId, poolId,
makerAddress, makerAddress,
this._verifyingContractAddress, this._verifyingContractAddress,
this._chainId this._chainId,
); );
const signatureBuff = signingUtils.signMessage(approvalHashBuff, this._privateKey, signatureType); const signatureBuff = signingUtils.signMessage(approvalHashBuff, this._privateKey, signatureType);
const signedApproval = { const signedApproval = {

59
contracts/staking/test/utils/Simulation.ts
View File

@ -1,6 +1,4 @@
import { import { chaiSetup } from '@0x/contracts-test-utils';
chaiSetup,
} from '@0x/contracts-test-utils';
import * as _ from 'lodash'; import * as _ from 'lodash';
import * as chai from 'chai'; import * as chai from 'chai';
@ -12,7 +10,6 @@ import { StakingWrapper } from './staking_wrapper';
import { Queue } from './queue'; import { Queue } from './queue';
import { DelegatorActor } from '../actors/delegator_actor'; import { DelegatorActor } from '../actors/delegator_actor';
chaiSetup.configure(); chaiSetup.configure();
const expect = chai.expect; const expect = chai.expect;
@ -74,9 +71,15 @@ export class Simulation {
await delegator.deactivateAndTimelockDelegatedStakeAsync(poolId, amountOfStakeDelegated); await delegator.deactivateAndTimelockDelegatedStakeAsync(poolId, amountOfStakeDelegated);
const finalEthBalance = await this._stakingWrapper.getEthBalanceAsync(delegatorAddress); const finalEthBalance = await this._stakingWrapper.getEthBalanceAsync(delegatorAddress);
const reward = finalEthBalance.minus(initEthBalance); const reward = finalEthBalance.minus(initEthBalance);
const rewardTrimmed = this._stakingWrapper.trimFloat(this._stakingWrapper.toFloatingPoint(reward, 18), 5); const rewardTrimmed = this._stakingWrapper.trimFloat(
this._stakingWrapper.toFloatingPoint(reward, 18),
5,
);
const expectedReward = p.expectedPayoutByDelegator[delegatorIdx]; const expectedReward = p.expectedPayoutByDelegator[delegatorIdx];
expect(rewardTrimmed, `reward withdrawn from pool ${poolId} for delegator ${delegatorAddress}`).to.be.bignumber.equal(expectedReward); expect(
rewardTrimmed,
`reward withdrawn from pool ${poolId} for delegator ${delegatorAddress}`,
).to.be.bignumber.equal(expectedReward);
delegatorIdx += 1; delegatorIdx += 1;
} }
poolIdx += 1; poolIdx += 1;
@ -95,9 +98,15 @@ export class Simulation {
await this._stakingWrapper.withdrawTotalRewardAsync(poolId, delegatorAddress); await this._stakingWrapper.withdrawTotalRewardAsync(poolId, delegatorAddress);
const finalEthBalance = await this._stakingWrapper.getEthBalanceAsync(delegatorAddress); const finalEthBalance = await this._stakingWrapper.getEthBalanceAsync(delegatorAddress);
const reward = finalEthBalance.minus(initEthBalance); const reward = finalEthBalance.minus(initEthBalance);
const rewardTrimmed = this._stakingWrapper.trimFloat(this._stakingWrapper.toFloatingPoint(reward, 18), 5); const rewardTrimmed = this._stakingWrapper.trimFloat(
this._stakingWrapper.toFloatingPoint(reward, 18),
5,
);
const expectedReward = p.expectedPayoutByDelegator[delegatorIdx]; const expectedReward = p.expectedPayoutByDelegator[delegatorIdx];
expect(rewardTrimmed, `reward withdrawn from pool ${poolId} for delegator ${delegatorAddress}`).to.be.bignumber.equal(expectedReward); expect(
rewardTrimmed,
`reward withdrawn from pool ${poolId} for delegator ${delegatorAddress}`,
).to.be.bignumber.equal(expectedReward);
delegatorIdx += 1; delegatorIdx += 1;
} }
poolIdx += 1; poolIdx += 1;
@ -198,19 +207,37 @@ export class Simulation {
// check pool balance in vault // check pool balance in vault
const poolId = this._poolIds[i]; const poolId = this._poolIds[i];
const rewardVaultBalance = await this._stakingWrapper.rewardVaultBalanceOfAsync(poolId); const rewardVaultBalance = await this._stakingWrapper.rewardVaultBalanceOfAsync(poolId);
const rewardVaultBalanceTrimmed = this._stakingWrapper.trimFloat(this._stakingWrapper.toFloatingPoint(rewardVaultBalance, 18), 5); const rewardVaultBalanceTrimmed = this._stakingWrapper.trimFloat(
this._stakingWrapper.toFloatingPoint(rewardVaultBalance, 18),
5,
);
const expectedRewardBalance = p.expectedPayoutByPool[i]; const expectedRewardBalance = p.expectedPayoutByPool[i];
expect(rewardVaultBalanceTrimmed, `expected balance in vault for pool with id ${poolId}`).to.be.bignumber.equal(expectedRewardBalance); expect(
rewardVaultBalanceTrimmed,
`expected balance in vault for pool with id ${poolId}`,
).to.be.bignumber.equal(expectedRewardBalance);
// check operator's balance // check operator's balance
const poolOperatorVaultBalance = await this._stakingWrapper.getRewardBalanceOfOperatorAsync(poolId); const poolOperatorVaultBalance = await this._stakingWrapper.getRewardBalanceOfOperatorAsync(poolId);
const poolOperatorVaultBalanceTrimmed = this._stakingWrapper.trimFloat(this._stakingWrapper.toFloatingPoint(poolOperatorVaultBalance, 18), 5); const poolOperatorVaultBalanceTrimmed = this._stakingWrapper.trimFloat(
this._stakingWrapper.toFloatingPoint(poolOperatorVaultBalance, 18),
5,
);
const expectedPoolOperatorVaultBalance = p.expectedPayoutByPoolOperator[i]; const expectedPoolOperatorVaultBalance = p.expectedPayoutByPoolOperator[i];
expect(poolOperatorVaultBalanceTrimmed, `operator balance in vault for pool with id ${poolId}`).to.be.bignumber.equal(expectedPoolOperatorVaultBalance); expect(
poolOperatorVaultBalanceTrimmed,
`operator balance in vault for pool with id ${poolId}`,
).to.be.bignumber.equal(expectedPoolOperatorVaultBalance);
// check balance of pool members // check balance of pool members
const membersVaultBalance = await this._stakingWrapper.getRewardBalanceOfPoolAsync(poolId); const membersVaultBalance = await this._stakingWrapper.getRewardBalanceOfPoolAsync(poolId);
const membersVaultBalanceTrimmed = this._stakingWrapper.trimFloat(this._stakingWrapper.toFloatingPoint(membersVaultBalance, 18), 5); const membersVaultBalanceTrimmed = this._stakingWrapper.trimFloat(
this._stakingWrapper.toFloatingPoint(membersVaultBalance, 18),
5,
);
const expectedMembersVaultBalance = p.expectedMembersPayoutByPool[i]; const expectedMembersVaultBalance = p.expectedMembersPayoutByPool[i];
expect(membersVaultBalanceTrimmed, `members balance in vault for pool with id ${poolId}`).to.be.bignumber.equal(expectedMembersVaultBalance); expect(
membersVaultBalanceTrimmed,
`members balance in vault for pool with id ${poolId}`,
).to.be.bignumber.equal(expectedMembersVaultBalance);
// @TODO compute balance of each member // @TODO compute balance of each member
} }
} }
@ -229,7 +256,9 @@ export class Simulation {
const reward = finalEthBalance.minus(initEthBalance); const reward = finalEthBalance.minus(initEthBalance);
const rewardTrimmed = this._stakingWrapper.trimFloat(this._stakingWrapper.toFloatingPoint(reward, 18), 5); const rewardTrimmed = this._stakingWrapper.trimFloat(this._stakingWrapper.toFloatingPoint(reward, 18), 5);
const expectedReward = p.expectedPayoutByPoolOperator[i]; const expectedReward = p.expectedPayoutByPoolOperator[i];
expect(rewardTrimmed, `reward withdrawn from pool ${poolId} for operator`).to.be.bignumber.equal(expectedReward); expect(rewardTrimmed, `reward withdrawn from pool ${poolId} for operator`).to.be.bignumber.equal(
expectedReward,
);
} }
} }
} }

12
contracts/staking/test/utils/constants.ts
View File

@ -1,12 +1,12 @@
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
export const constants = { export const constants = {
MAX_UINT_64: (new BigNumber(2)).pow(256).minus(1), MAX_UINT_64: new BigNumber(2).pow(256).minus(1),
TOKEN_MULTIPLIER: (new BigNumber(10)).pow(18), TOKEN_MULTIPLIER: new BigNumber(10).pow(18),
INITIAL_POOL_ID: "0x0000000000000000000000000000000100000000000000000000000000000000", INITIAL_POOL_ID: '0x0000000000000000000000000000000100000000000000000000000000000000',
NIL_POOL_ID: "0x0000000000000000000000000000000000000000000000000000000000000000", NIL_POOL_ID: '0x0000000000000000000000000000000000000000000000000000000000000000',
NIL_ADDRESS: "0x0000000000000000000000000000000000000000", NIL_ADDRESS: '0x0000000000000000000000000000000000000000',
INITIAL_EPOCH: (new BigNumber(0)), INITIAL_EPOCH: new BigNumber(0),
INITIAL_TIMELOCK_PERIOD: new BigNumber(0), INITIAL_TIMELOCK_PERIOD: new BigNumber(0),
EPOCH_PERIOD_IN_SECONDS: new BigNumber(1000), // @TODO SET FOR DEPLOYMENT*/ EPOCH_PERIOD_IN_SECONDS: new BigNumber(1000), // @TODO SET FOR DEPLOYMENT*/
TIMELOCK_PERIOD_IN_EPOCHS: new BigNumber(3), // @TODO SET FOR DEPLOYMENT TIMELOCK_PERIOD_IN_EPOCHS: new BigNumber(3), // @TODO SET FOR DEPLOYMENT

6
contracts/staking/test/utils/hash_utils.ts
View File

@ -7,13 +7,13 @@ export const hashUtils = {
poolId: string, poolId: string,
makerAddress: string, makerAddress: string,
verifyingContractAddress: string, verifyingContractAddress: string,
chainId: number chainId: number,
): Buffer { ): Buffer {
const typedData = eip712Utils.createStakingPoolApprovalTypedData( const typedData = eip712Utils.createStakingPoolApprovalTypedData(
poolId, poolId,
makerAddress, makerAddress,
verifyingContractAddress, verifyingContractAddress,
chainId chainId,
); );
const hashBuffer = signTypedDataUtils.generateTypedDataHash(typedData); const hashBuffer = signTypedDataUtils.generateTypedDataHash(typedData);
return hashBuffer; return hashBuffer;
@ -22,7 +22,7 @@ export const hashUtils = {
poolId: string, poolId: string,
makerAddress: string, makerAddress: string,
verifyingContractAddress: string, verifyingContractAddress: string,
chainId: number chainId: number,
): string { ): string {
const hashHex = `0x${hashUtils const hashHex = `0x${hashUtils
.getStakingPoolApprovalHashBuffer(poolId, makerAddress, verifyingContractAddress, chainId) .getStakingPoolApprovalHashBuffer(poolId, makerAddress, verifyingContractAddress, chainId)

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

@ -9,7 +9,14 @@ import { artifacts as erc20Artifacts, DummyERC20TokenContract } from '@0x/contra
import { ERC20ProxyContract } from '@0x/contracts-asset-proxy'; import { ERC20ProxyContract } from '@0x/contracts-asset-proxy';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { artifacts, StakingContract, StakingProxyContract, ZrxVaultContract, RewardVaultContract, LibFeeMathTestContract } from '../../src'; import {
artifacts,
StakingContract,
StakingProxyContract,
ZrxVaultContract,
RewardVaultContract,
LibFeeMathTestContract,
} from '../../src';
import { ApprovalFactory } from './ApprovalFactory'; import { ApprovalFactory } from './ApprovalFactory';
import { SignedStakingPoolApproval } from './types'; import { SignedStakingPoolApproval } from './types';
import { constants } from './constants'; import { constants } from './constants';
@ -30,7 +37,13 @@ export class StakingWrapper {
private _rewardVaultContractIfExists?: RewardVaultContract; private _rewardVaultContractIfExists?: RewardVaultContract;
private _LibFeeMathTestContractIfExists?: LibFeeMathTestContract; private _LibFeeMathTestContractIfExists?: LibFeeMathTestContract;
constructor(provider: Provider, ownerAddres: string, erc20ProxyContract: ERC20ProxyContract, zrxTokenContract: DummyERC20TokenContract, accounts: string[]) { constructor(
provider: Provider,
ownerAddres: string,
erc20ProxyContract: ERC20ProxyContract,
zrxTokenContract: DummyERC20TokenContract,
accounts: string[],
) {
this._web3Wrapper = new Web3Wrapper(provider); this._web3Wrapper = new Web3Wrapper(provider);
this._provider = provider; this._provider = provider;
const decoderArtifacts = _.merge(artifacts, erc20Artifacts); const decoderArtifacts = _.merge(artifacts, erc20Artifacts);
@ -69,7 +82,7 @@ export class StakingWrapper {
txDefaults, txDefaults,
this._erc20ProxyContract.address, this._erc20ProxyContract.address,
this._zrxTokenContract.address, this._zrxTokenContract.address,
zrxAssetData zrxAssetData,
); );
// deploy reward vault // deploy reward vault
this._rewardVaultContractIfExists = await RewardVaultContract.deployFrom0xArtifactAsync( this._rewardVaultContractIfExists = await RewardVaultContract.deployFrom0xArtifactAsync(
@ -78,43 +91,57 @@ export class StakingWrapper {
txDefaults, txDefaults,
); );
// configure erc20 proxy to accept calls from zrx vault // configure erc20 proxy to accept calls from zrx vault
await this._erc20ProxyContract.addAuthorizedAddress.awaitTransactionSuccessAsync((this._zrxVaultContractIfExists as ZrxVaultContract).address); await this._erc20ProxyContract.addAuthorizedAddress.awaitTransactionSuccessAsync(
(this._zrxVaultContractIfExists as ZrxVaultContract).address,
);
// deploy staking contract // deploy staking contract
this._stakingContractIfExists = await StakingContract.deployFrom0xArtifactAsync( this._stakingContractIfExists = await StakingContract.deployFrom0xArtifactAsync(
artifacts.Staking, artifacts.Staking,
this._provider, this._provider,
txDefaults txDefaults,
); );
// deploy staking proxy // deploy staking proxy
this._stakingProxyContractIfExists = await StakingProxyContract.deployFrom0xArtifactAsync( this._stakingProxyContractIfExists = await StakingProxyContract.deployFrom0xArtifactAsync(
artifacts.StakingProxy, artifacts.StakingProxy,
this._provider, this._provider,
txDefaults, txDefaults,
(this._stakingContractIfExists as StakingContract).address (this._stakingContractIfExists as StakingContract).address,
); );
// set staking proxy contract in zrx vault // set staking proxy contract in zrx vault
await (this._zrxVaultContractIfExists as ZrxVaultContract).setStakingContractAddrsess.awaitTransactionSuccessAsync((this._stakingProxyContractIfExists as StakingProxyContract).address); await (this
._zrxVaultContractIfExists as ZrxVaultContract).setStakingContractAddrsess.awaitTransactionSuccessAsync(
(this._stakingProxyContractIfExists as StakingProxyContract).address,
);
// set zrx vault in staking contract // set zrx vault in staking contract
const setZrxVaultCalldata = await (this._stakingContractIfExists as StakingContract).setZrxVault.getABIEncodedTransactionData((this._zrxVaultContractIfExists as ZrxVaultContract).address); const setZrxVaultCalldata = await (this
._stakingContractIfExists as StakingContract).setZrxVault.getABIEncodedTransactionData(
(this._zrxVaultContractIfExists as ZrxVaultContract).address,
);
const setZrxVaultTxData = { const setZrxVaultTxData = {
from: this._ownerAddres, from: this._ownerAddres,
to: (this._stakingProxyContractIfExists as StakingProxyContract).address, to: (this._stakingProxyContractIfExists as StakingProxyContract).address,
data: setZrxVaultCalldata data: setZrxVaultCalldata,
} };
await this._web3Wrapper.awaitTransactionSuccessAsync( await this._web3Wrapper.awaitTransactionSuccessAsync(
await this._web3Wrapper.sendTransactionAsync(setZrxVaultTxData) await this._web3Wrapper.sendTransactionAsync(setZrxVaultTxData),
); );
// set staking proxy contract in reward vault // set staking proxy contract in reward vault
await (this._rewardVaultContractIfExists as RewardVaultContract).setStakingContractAddrsess.awaitTransactionSuccessAsync((this._stakingProxyContractIfExists as StakingProxyContract).address); await (this
._rewardVaultContractIfExists as RewardVaultContract).setStakingContractAddrsess.awaitTransactionSuccessAsync(
(this._stakingProxyContractIfExists as StakingProxyContract).address,
);
// set reward vault in staking contract // set reward vault in staking contract
const setRewardVaultCalldata = await (this._stakingContractIfExists as StakingContract).setRewardVault.getABIEncodedTransactionData((this._rewardVaultContractIfExists as RewardVaultContract).address); const setRewardVaultCalldata = await (this
._stakingContractIfExists as StakingContract).setRewardVault.getABIEncodedTransactionData(
(this._rewardVaultContractIfExists as RewardVaultContract).address,
);
const setRewardVaultTxData = { const setRewardVaultTxData = {
from: this._ownerAddres, from: this._ownerAddres,
to: (this._stakingProxyContractIfExists as StakingProxyContract).address, to: (this._stakingProxyContractIfExists as StakingProxyContract).address,
data: setRewardVaultCalldata data: setRewardVaultCalldata,
} };
await this._web3Wrapper.awaitTransactionSuccessAsync( await this._web3Wrapper.awaitTransactionSuccessAsync(
await this._web3Wrapper.sendTransactionAsync(setRewardVaultTxData) await this._web3Wrapper.sendTransactionAsync(setRewardVaultTxData),
); );
// deploy libmath test // deploy libmath test
this._LibFeeMathTestContractIfExists = await LibFeeMathTestContract.deployFrom0xArtifactAsync( this._LibFeeMathTestContractIfExists = await LibFeeMathTestContract.deployFrom0xArtifactAsync(
@ -123,26 +150,33 @@ export class StakingWrapper {
txDefaults, txDefaults,
); );
} }
private async _executeTransactionAsync(calldata: string, from?: string, value?: BigNumber, includeLogs?: boolean): Promise<TransactionReceiptWithDecodedLogs> { private async _executeTransactionAsync(
calldata: string,
from?: string,
value?: BigNumber,
includeLogs?: boolean,
): Promise<TransactionReceiptWithDecodedLogs> {
const txData = { const txData = {
from: (from ? from : this._ownerAddres), from: from ? from : this._ownerAddres,
to: this.getStakingProxyContract().address, to: this.getStakingProxyContract().address,
data: calldata, data: calldata,
gas: 3000000, gas: 3000000,
gasPrice: 0, gasPrice: 0,
value value,
} };
const txHash = await this._web3Wrapper.sendTransactionAsync(txData); const txHash = await this._web3Wrapper.sendTransactionAsync(txData);
const txReceipt = await (includeLogs ? this._logDecoder.getTxWithDecodedLogsAsync(txHash) : this._web3Wrapper.awaitTransactionSuccessAsync(txHash)); const txReceipt = await (includeLogs
? this._logDecoder.getTxWithDecodedLogsAsync(txHash)
: this._web3Wrapper.awaitTransactionSuccessAsync(txHash));
return txReceipt; return txReceipt;
} }
private async _callAsync(calldata: string, from?: string): Promise<any> { private async _callAsync(calldata: string, from?: string): Promise<any> {
const txData = { const txData = {
from: (from ? from : this._ownerAddres), from: from ? from : this._ownerAddres,
to: this.getStakingProxyContract().address, to: this.getStakingProxyContract().address,
data: calldata, data: calldata,
gas: 3000000 gas: 3000000,
} };
const returnValue = await this._web3Wrapper.callAsync(txData); const returnValue = await this._web3Wrapper.callAsync(txData);
return returnValue; return returnValue;
} }
@ -161,7 +195,11 @@ export class StakingWrapper {
const txReceipt = await this._executeTransactionAsync(calldata, owner); const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt; return txReceipt;
} }
public async depositAndDelegateAsync(owner: string, poolId: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> { public async depositAndDelegateAsync(
owner: string,
poolId: string,
amount: BigNumber,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().depositAndDelegate.getABIEncodedTransactionData(poolId, amount); const calldata = this.getStakingContract().depositAndDelegate.getABIEncodedTransactionData(poolId, amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner, new BigNumber(0), true); const txReceipt = await this._executeTransactionAsync(calldata, owner, new BigNumber(0), true);
return txReceipt; return txReceipt;
@ -171,18 +209,35 @@ export class StakingWrapper {
const txReceipt = await this._executeTransactionAsync(calldata, owner); const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt; return txReceipt;
} }
public async activateAndDelegateStakeAsync(owner: string, poolId: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> { public async activateAndDelegateStakeAsync(
const calldata = this.getStakingContract().activateAndDelegateStake.getABIEncodedTransactionData(poolId, amount); owner: string,
poolId: string,
amount: BigNumber,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().activateAndDelegateStake.getABIEncodedTransactionData(
poolId,
amount,
);
const txReceipt = await this._executeTransactionAsync(calldata, owner); const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt; return txReceipt;
} }
public async deactivateAndTimelockStakeAsync(owner: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> { public async deactivateAndTimelockStakeAsync(
owner: string,
amount: BigNumber,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().deactivateAndTimelockStake.getABIEncodedTransactionData(amount); const calldata = this.getStakingContract().deactivateAndTimelockStake.getABIEncodedTransactionData(amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner); const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt; return txReceipt;
} }
public async deactivateAndTimelockDelegatedStakeAsync(owner: string, poolId: string, amount: BigNumber): Promise<TransactionReceiptWithDecodedLogs> { public async deactivateAndTimelockDelegatedStakeAsync(
const calldata = this.getStakingContract().deactivateAndTimelockDelegatedStake.getABIEncodedTransactionData(poolId, amount); owner: string,
poolId: string,
amount: BigNumber,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().deactivateAndTimelockDelegatedStake.getABIEncodedTransactionData(
poolId,
amount,
);
const txReceipt = await this._executeTransactionAsync(calldata, owner, new BigNumber(0), true); const txReceipt = await this._executeTransactionAsync(calldata, owner, new BigNumber(0), true);
return txReceipt; return txReceipt;
} }
@ -246,7 +301,10 @@ export class StakingWrapper {
return value; return value;
} }
public async getStakeDelegatedToPoolByOwnerAsync(poolId: string, owner: string): Promise<BigNumber> { public async getStakeDelegatedToPoolByOwnerAsync(poolId: string, owner: string): Promise<BigNumber> {
const calldata = this.getStakingContract().getStakeDelegatedToPoolByOwner.getABIEncodedTransactionData(owner, poolId); const calldata = this.getStakingContract().getStakeDelegatedToPoolByOwner.getABIEncodedTransactionData(
owner,
poolId,
);
const returnData = await this._callAsync(calldata); const returnData = await this._callAsync(calldata);
const value = this.getStakingContract().getStakeDelegatedToPoolByOwner.getABIDecodedReturnData(returnData); const value = this.getStakingContract().getStakeDelegatedToPoolByOwner.getABIDecodedReturnData(returnData);
return value; return value;
@ -270,13 +328,29 @@ export class StakingWrapper {
const poolId = (createPoolLog as any).args.poolId; const poolId = (createPoolLog as any).args.poolId;
return poolId; return poolId;
} }
public async addMakerToPoolAsync(poolId: string, makerAddress: string, makerSignature: string, operatorAddress: string): Promise<TransactionReceiptWithDecodedLogs> { public async addMakerToPoolAsync(
const calldata = this.getStakingContract().addMakerToPool.getABIEncodedTransactionData(poolId, makerAddress, makerSignature); poolId: string,
makerAddress: string,
makerSignature: string,
operatorAddress: string,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().addMakerToPool.getABIEncodedTransactionData(
poolId,
makerAddress,
makerSignature,
);
const txReceipt = await this._executeTransactionAsync(calldata, operatorAddress); const txReceipt = await this._executeTransactionAsync(calldata, operatorAddress);
return txReceipt; return txReceipt;
} }
public async removeMakerFromPoolAsync(poolId: string, makerAddress: string, operatorAddress: string): Promise<TransactionReceiptWithDecodedLogs> { public async removeMakerFromPoolAsync(
const calldata = this.getStakingContract().removeMakerFromPool.getABIEncodedTransactionData(poolId, makerAddress); poolId: string,
makerAddress: string,
operatorAddress: string,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().removeMakerFromPool.getABIEncodedTransactionData(
poolId,
makerAddress,
);
const txReceipt = await this._executeTransactionAsync(calldata, operatorAddress); const txReceipt = await this._executeTransactionAsync(calldata, operatorAddress);
return txReceipt; return txReceipt;
} }
@ -291,16 +365,29 @@ export class StakingWrapper {
const makerAddresses = this.getStakingContract().getMakerAddressesForPool.getABIDecodedReturnData(returndata); const makerAddresses = this.getStakingContract().getMakerAddressesForPool.getABIDecodedReturnData(returndata);
return makerAddresses; return makerAddresses;
} }
public async isValidMakerSignatureAsync(poolId: string, makerAddress: string, makerSignature: string): Promise<Boolean> { public async isValidMakerSignatureAsync(
const calldata = this.getStakingContract().isValidMakerSignature.getABIEncodedTransactionData(poolId, makerAddress, makerSignature); poolId: string,
makerAddress: string,
makerSignature: string,
): Promise<Boolean> {
const calldata = this.getStakingContract().isValidMakerSignature.getABIEncodedTransactionData(
poolId,
makerAddress,
makerSignature,
);
const returndata = await this._callAsync(calldata); const returndata = await this._callAsync(calldata);
const isValid = this.getStakingContract().isValidMakerSignature.getABIDecodedReturnData(returndata); const isValid = this.getStakingContract().isValidMakerSignature.getABIDecodedReturnData(returndata);
return isValid; return isValid;
} }
public async getStakingPoolApprovalMessageHashAsync(poolId: string, makerAddress: string): Promise<string> { public async getStakingPoolApprovalMessageHashAsync(poolId: string, makerAddress: string): Promise<string> {
const calldata = this.getStakingContract().getStakingPoolApprovalMessageHash.getABIEncodedTransactionData(poolId, makerAddress); const calldata = this.getStakingContract().getStakingPoolApprovalMessageHash.getABIEncodedTransactionData(
poolId,
makerAddress,
);
const returndata = await this._callAsync(calldata); const returndata = await this._callAsync(calldata);
const messageHash = this.getStakingContract().getStakingPoolApprovalMessageHash.getABIDecodedReturnData(returndata); const messageHash = this.getStakingContract().getStakingPoolApprovalMessageHash.getABIDecodedReturnData(
returndata,
);
return messageHash; return messageHash;
} }
public signApprovalForStakingPool( public signApprovalForStakingPool(
@ -311,8 +398,12 @@ export class StakingWrapper {
chainIdIfExists?: number, chainIdIfExists?: number,
signatureType: SignatureType = SignatureType.EthSign, signatureType: SignatureType = SignatureType.EthSign,
): SignedStakingPoolApproval { ): SignedStakingPoolApproval {
const makerPrivateKey = makerPrivateKeyIfExists !== undefined ? makerPrivateKeyIfExists : testUtilsConstants.TESTRPC_PRIVATE_KEYS[this._accounts.indexOf(makerAddress)]; const makerPrivateKey =
const verifierAddress = verifierAddressIfExists !== undefined ? verifierAddressIfExists : this.getStakingProxyContract().address; makerPrivateKeyIfExists !== undefined
? makerPrivateKeyIfExists
: testUtilsConstants.TESTRPC_PRIVATE_KEYS[this._accounts.indexOf(makerAddress)];
const verifierAddress =
verifierAddressIfExists !== undefined ? verifierAddressIfExists : this.getStakingProxyContract().address;
const chainId = chainIdIfExists !== undefined ? chainIdIfExists : constants.CHAIN_ID; const chainId = chainIdIfExists !== undefined ? chainIdIfExists : constants.CHAIN_ID;
const approvalFactory = new ApprovalFactory(makerPrivateKey, verifierAddress, chainId); const approvalFactory = new ApprovalFactory(makerPrivateKey, verifierAddress, chainId);
const signedStakingPoolApproval = approvalFactory.newSignedApproval(poolId, makerAddress, signatureType); const signedStakingPoolApproval = approvalFactory.newSignedApproval(poolId, makerAddress, signatureType);
@ -322,7 +413,9 @@ export class StakingWrapper {
public async goToNextEpochAsync(): Promise<TransactionReceiptWithDecodedLogs> { public async goToNextEpochAsync(): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().finalizeFees.getABIEncodedTransactionData(); const calldata = this.getStakingContract().finalizeFees.getABIEncodedTransactionData();
const txReceipt = await this._executeTransactionAsync(calldata, undefined, new BigNumber(0), true); const txReceipt = await this._executeTransactionAsync(calldata, undefined, new BigNumber(0), true);
console.log(`finalization: gasUsed = ${txReceipt.gasUsed} / cumulativeGasUsed = ${txReceipt.cumulativeGasUsed}`); console.log(
`finalization: gasUsed = ${txReceipt.gasUsed} / cumulativeGasUsed = ${txReceipt.cumulativeGasUsed}`,
);
return txReceipt; return txReceipt;
} }
public async skipToNextEpochAsync(): Promise<TransactionReceiptWithDecodedLogs> { public async skipToNextEpochAsync(): Promise<TransactionReceiptWithDecodedLogs> {
@ -395,7 +488,11 @@ export class StakingWrapper {
return value; return value;
} }
///// PROTOCOL FEES ///// ///// PROTOCOL FEES /////
public async payProtocolFeeAsync(makerAddress: string, amount: BigNumber, exchangeAddress: string): Promise<TransactionReceiptWithDecodedLogs> { public async payProtocolFeeAsync(
makerAddress: string,
amount: BigNumber,
exchangeAddress: string,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().payProtocolFee.getABIEncodedTransactionData(makerAddress); const calldata = this.getStakingContract().payProtocolFee.getABIEncodedTransactionData(makerAddress);
const txReceipt = await this._executeTransactionAsync(calldata, exchangeAddress, amount); const txReceipt = await this._executeTransactionAsync(calldata, exchangeAddress, amount);
return txReceipt; return txReceipt;
@ -461,22 +558,36 @@ export class StakingWrapper {
return value; return value;
} }
public async getShadowBalanceInPoolByOwnerAsync(owner: string, poolId: string): Promise<BigNumber> { public async getShadowBalanceInPoolByOwnerAsync(owner: string, poolId: string): Promise<BigNumber> {
const calldata = this.getStakingContract().getShadowBalanceInPoolByOwner.getABIEncodedTransactionData(owner, poolId); const calldata = this.getStakingContract().getShadowBalanceInPoolByOwner.getABIEncodedTransactionData(
owner,
poolId,
);
const returnData = await this._callAsync(calldata); const returnData = await this._callAsync(calldata);
const value = this.getStakingContract().getShadowBalanceInPoolByOwner.getABIDecodedReturnData(returnData); const value = this.getStakingContract().getShadowBalanceInPoolByOwner.getABIDecodedReturnData(returnData);
return value; return value;
} }
public async withdrawOperatorRewardAsync(poolId: string, amount: BigNumber, operatorAddress: string): Promise<TransactionReceiptWithDecodedLogs> { public async withdrawOperatorRewardAsync(
poolId: string,
amount: BigNumber,
operatorAddress: string,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().withdrawOperatorReward.getABIEncodedTransactionData(poolId, amount); const calldata = this.getStakingContract().withdrawOperatorReward.getABIEncodedTransactionData(poolId, amount);
const txReceipt = await this._executeTransactionAsync(calldata, operatorAddress); const txReceipt = await this._executeTransactionAsync(calldata, operatorAddress);
return txReceipt; return txReceipt;
} }
public async withdrawRewardAsync(poolId: string, amount: BigNumber, owner: string): Promise<TransactionReceiptWithDecodedLogs> { public async withdrawRewardAsync(
poolId: string,
amount: BigNumber,
owner: string,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().withdrawReward.getABIEncodedTransactionData(poolId, amount); const calldata = this.getStakingContract().withdrawReward.getABIEncodedTransactionData(poolId, amount);
const txReceipt = await this._executeTransactionAsync(calldata, owner); const txReceipt = await this._executeTransactionAsync(calldata, owner);
return txReceipt; return txReceipt;
} }
public async withdrawTotalOperatorRewardAsync(poolId: string, operatorAddress: string): Promise<TransactionReceiptWithDecodedLogs> { public async withdrawTotalOperatorRewardAsync(
poolId: string,
operatorAddress: string,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getStakingContract().withdrawTotalOperatorReward.getABIEncodedTransactionData(poolId); const calldata = this.getStakingContract().withdrawTotalOperatorReward.getABIEncodedTransactionData(poolId);
const txReceipt = await this._executeTransactionAsync(calldata, operatorAddress); const txReceipt = await this._executeTransactionAsync(calldata, operatorAddress);
return txReceipt; return txReceipt;
@ -487,12 +598,18 @@ export class StakingWrapper {
return txReceipt; return txReceipt;
} }
///// REWARD VAULT ///// ///// REWARD VAULT /////
public async rewardVaultDepositForAsync(poolId: string, amount: BigNumber, stakingContractAddress: string): Promise<TransactionReceiptWithDecodedLogs> { public async rewardVaultDepositForAsync(
poolId: string,
amount: BigNumber,
stakingContractAddress: string,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getRewardVaultContract().depositFor.getABIEncodedTransactionData(poolId); const calldata = this.getRewardVaultContract().depositFor.getABIEncodedTransactionData(poolId);
const txReceipt = await this._executeTransactionAsync(calldata, stakingContractAddress, amount); const txReceipt = await this._executeTransactionAsync(calldata, stakingContractAddress, amount);
return txReceipt; return txReceipt;
} }
public async rewardVaultEnterCatastrophicFailureModeAsync(zeroExMultisigAddress: string): Promise<TransactionReceiptWithDecodedLogs> { public async rewardVaultEnterCatastrophicFailureModeAsync(
zeroExMultisigAddress: string,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getRewardVaultContract().enterCatostrophicFailure.getABIEncodedTransactionData(); const calldata = this.getRewardVaultContract().enterCatostrophicFailure.getABIEncodedTransactionData();
const txReceipt = await this._executeTransactionAsync(calldata, zeroExMultisigAddress); const txReceipt = await this._executeTransactionAsync(calldata, zeroExMultisigAddress);
return txReceipt; return txReceipt;
@ -509,8 +626,15 @@ export class StakingWrapper {
const balance = await this.getRewardVaultContract().balanceOfPool.callAsync(poolId); const balance = await this.getRewardVaultContract().balanceOfPool.callAsync(poolId);
return balance; return balance;
} }
public async rewardVaultCreatePoolAsync(poolId: string, poolOperatorShare: number, stakingContractAddress: string): Promise<TransactionReceiptWithDecodedLogs> { public async rewardVaultCreatePoolAsync(
const calldata = this.getRewardVaultContract().createPool.getABIEncodedTransactionData(poolId, poolOperatorShare); poolId: string,
poolOperatorShare: number,
stakingContractAddress: string,
): Promise<TransactionReceiptWithDecodedLogs> {
const calldata = this.getRewardVaultContract().createPool.getABIEncodedTransactionData(
poolId,
poolOperatorShare,
);
const txReceipt = await this._executeTransactionAsync(calldata, stakingContractAddress); const txReceipt = await this._executeTransactionAsync(calldata, stakingContractAddress);
return txReceipt; return txReceipt;
} }
@ -544,7 +668,7 @@ export class StakingWrapper {
ownerStake: BigNumber, ownerStake: BigNumber,
totalStake: BigNumber, totalStake: BigNumber,
alphaNumerator: BigNumber, alphaNumerator: BigNumber,
alphaDenominator: BigNumber alphaDenominator: BigNumber,
) { ) {
const output = await this.getLibFeeMathTestContract().cobbDouglas.callAsync( const output = await this.getLibFeeMathTestContract().cobbDouglas.callAsync(
totalRewards, totalRewards,
@ -553,7 +677,7 @@ export class StakingWrapper {
ownerStake, ownerStake,
totalStake, totalStake,
alphaNumerator, alphaNumerator,
alphaDenominator alphaDenominator,
); );
return output; return output;
} }
@ -563,7 +687,7 @@ export class StakingWrapper {
totalFees: BigNumber, totalFees: BigNumber,
ownerStake: BigNumber, ownerStake: BigNumber,
totalStake: BigNumber, totalStake: BigNumber,
alphaDenominator: BigNumber alphaDenominator: BigNumber,
) { ) {
const txReceipt = await this.getLibFeeMathTestContract().cobbDouglasSimplifiedInverse.awaitTransactionSuccessAsync( const txReceipt = await this.getLibFeeMathTestContract().cobbDouglasSimplifiedInverse.awaitTransactionSuccessAsync(
totalRewards, totalRewards,
@ -571,7 +695,7 @@ export class StakingWrapper {
totalFees, totalFees,
ownerStake, ownerStake,
totalStake, totalStake,
alphaDenominator alphaDenominator,
); );
const output = await this.getLibFeeMathTestContract().cobbDouglasSimplified.callAsync( const output = await this.getLibFeeMathTestContract().cobbDouglasSimplified.callAsync(
totalRewards, totalRewards,
@ -579,7 +703,7 @@ export class StakingWrapper {
totalFees, totalFees,
ownerStake, ownerStake,
totalStake, totalStake,
alphaDenominator alphaDenominator,
); );
return output; return output;
} }
@ -589,7 +713,7 @@ export class StakingWrapper {
totalFees: BigNumber, totalFees: BigNumber,
ownerStake: BigNumber, ownerStake: BigNumber,
totalStake: BigNumber, totalStake: BigNumber,
alphaDenominator: BigNumber alphaDenominator: BigNumber,
) { ) {
const txReceipt = await this.getLibFeeMathTestContract().cobbDouglasSimplifiedInverse.awaitTransactionSuccessAsync( const txReceipt = await this.getLibFeeMathTestContract().cobbDouglasSimplifiedInverse.awaitTransactionSuccessAsync(
totalRewards, totalRewards,
@ -597,7 +721,7 @@ export class StakingWrapper {
totalFees, totalFees,
ownerStake, ownerStake,
totalStake, totalStake,
alphaDenominator alphaDenominator,
); );
const output = await this.getLibFeeMathTestContract().cobbDouglasSimplifiedInverse.callAsync( const output = await this.getLibFeeMathTestContract().cobbDouglasSimplifiedInverse.callAsync(
@ -606,32 +730,35 @@ export class StakingWrapper {
totalFees, totalFees,
ownerStake, ownerStake,
totalStake, totalStake,
alphaDenominator alphaDenominator,
); );
return output; return output;
} }
public toBaseUnitAmount(amount: BigNumber | number): BigNumber { public toBaseUnitAmount(amount: BigNumber | number): BigNumber {
const decimals = 18; const decimals = 18;
const amountAsBigNumber = typeof(amount) === 'number' ? new BigNumber(amount) : amount; const amountAsBigNumber = typeof amount === 'number' ? new BigNumber(amount) : amount;
const baseUnitAmount = Web3Wrapper.toBaseUnitAmount(amountAsBigNumber, decimals); const baseUnitAmount = Web3Wrapper.toBaseUnitAmount(amountAsBigNumber, decimals);
return baseUnitAmount; return baseUnitAmount;
} }
public toFixedPoint(amount: BigNumber | number, decimals: number): BigNumber { public toFixedPoint(amount: BigNumber | number, decimals: number): BigNumber {
const amountAsBigNumber = typeof(amount) === 'number' ? new BigNumber(amount) : amount; const amountAsBigNumber = typeof amount === 'number' ? new BigNumber(amount) : amount;
const scalar = Math.pow(10, decimals); const scalar = Math.pow(10, decimals);
const amountAsFixedPoint = amountAsBigNumber.times(scalar); const amountAsFixedPoint = amountAsBigNumber.times(scalar);
return amountAsFixedPoint; return amountAsFixedPoint;
} }
public toFloatingPoint(amount: BigNumber | number, decimals: number): BigNumber { public toFloatingPoint(amount: BigNumber | number, decimals: number): BigNumber {
const amountAsBigNumber = typeof(amount) === 'number' ? new BigNumber(amount) : amount; const amountAsBigNumber = typeof amount === 'number' ? new BigNumber(amount) : amount;
const scalar = Math.pow(10, decimals); const scalar = Math.pow(10, decimals);
const amountAsFloatingPoint = amountAsBigNumber.dividedBy(scalar); const amountAsFloatingPoint = amountAsBigNumber.dividedBy(scalar);
return amountAsFloatingPoint; return amountAsFloatingPoint;
} }
public trimFloat(amount: BigNumber | number, decimals: number): BigNumber { public trimFloat(amount: BigNumber | number, decimals: number): BigNumber {
const amountAsBigNumber = typeof(amount) === 'number' ? new BigNumber(amount) : amount; const amountAsBigNumber = typeof amount === 'number' ? new BigNumber(amount) : amount;
const scalar = Math.pow(10, decimals); const scalar = Math.pow(10, decimals);
const amountAsFloatingPoint = ((amountAsBigNumber.multipliedBy(scalar)).dividedToIntegerBy(1)).dividedBy(scalar); const amountAsFloatingPoint = amountAsBigNumber
.multipliedBy(scalar)
.dividedToIntegerBy(1)
.dividedBy(scalar);
return amountAsFloatingPoint; return amountAsFloatingPoint;
} }
private _validateDeployedOrThrow() { private _validateDeployedOrThrow() {

44
contracts/staking/test/utils/types.ts
View File

@ -1,10 +1,10 @@
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
export interface StakingPoolApproval { export interface StakingPoolApproval {
makerAddress: string, makerAddress: string;
poolId: string, poolId: string;
verifyingContractAddress: string, verifyingContractAddress: string;
chainId: number chainId: number;
} }
export interface SignedStakingPoolApproval extends StakingPoolApproval { export interface SignedStakingPoolApproval extends StakingPoolApproval {
@ -29,22 +29,22 @@ export interface DelegatorBalances extends StakerBalances {
} }
export interface SimulationParams { export interface SimulationParams {
users: string[], users: string[];
numberOfPools: number, numberOfPools: number;
poolOperatorShares: number[], poolOperatorShares: number[];
stakeByPoolOperator: BigNumber[], stakeByPoolOperator: BigNumber[];
numberOfMakers: number, numberOfMakers: number;
numberOfMakersPerPool: number[], numberOfMakersPerPool: number[];
protocolFeesByMaker: BigNumber[], protocolFeesByMaker: BigNumber[];
numberOfDelegators: number, numberOfDelegators: number;
numberOfDelegatorsPerPool: number[], numberOfDelegatorsPerPool: number[];
stakeByDelegator: BigNumber[], stakeByDelegator: BigNumber[];
expectedFeesByPool: BigNumber[], expectedFeesByPool: BigNumber[];
expectedPayoutByPool: BigNumber[], expectedPayoutByPool: BigNumber[];
expectedPayoutByPoolOperator: BigNumber[], expectedPayoutByPoolOperator: BigNumber[];
expectedMembersPayoutByPool: BigNumber[], expectedMembersPayoutByPool: BigNumber[];
expectedPayoutByDelegator: BigNumber[], expectedPayoutByDelegator: BigNumber[];
exchangeAddress: string, exchangeAddress: string;
delegateInNextEpoch: Boolean, delegateInNextEpoch: Boolean;
withdrawByUndelegating: Boolean, withdrawByUndelegating: Boolean;
} }

5
contracts/staking/test/vaults_test.ts
View File

@ -21,7 +21,6 @@ import { StakingWrapper } from './utils/staking_wrapper';
import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy'; import { ERC20Wrapper, ERC20ProxyContract } from '@0x/contracts-asset-proxy';
import { StakingContract } from '../src'; import { StakingContract } from '../src';
import { StakerActor } from './actors/staker_actor'; import { StakerActor } from './actors/staker_actor';
import { DelegatorActor } from './actors/delegator_actor'; import { DelegatorActor } from './actors/delegator_actor';
@ -87,12 +86,12 @@ describe('Staking Vaults', () => {
// should fail to create pool if it already exists // should fail to create pool if it already exists
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
stakingWrapper.rewardVaultCreatePoolAsync(poolId, operatorShare, stakingContractAddress), stakingWrapper.rewardVaultCreatePoolAsync(poolId, operatorShare, stakingContractAddress),
RevertReason.PoolAlreadyExists RevertReason.PoolAlreadyExists,
); );
// should fail to create a pool from an address other than the staking contract // should fail to create a pool from an address other than the staking contract
await expectTransactionFailedAsync( await expectTransactionFailedAsync(
stakingWrapper.rewardVaultCreatePoolAsync(poolId, operatorShare, notStakingContractAddress), stakingWrapper.rewardVaultCreatePoolAsync(poolId, operatorShare, notStakingContractAddress),
RevertReason.OnlyCallableByStakingContract RevertReason.OnlyCallableByStakingContract,
); );
}); });
}); });

5
packages/order-utils/src/constants.ts
View File

@ -153,10 +153,7 @@ export const constants = {
STAKING_DOMAIN_VERSION: '1.0.0', STAKING_DOMAIN_VERSION: '1.0.0',
STAKING_POOL_APPROVAL_SCHEMA: { STAKING_POOL_APPROVAL_SCHEMA: {
name: 'StakingPoolApproval', name: 'StakingPoolApproval',
parameters: [ parameters: [{ name: 'poolId', type: 'bytes32' }, { name: 'makerAddress', type: 'address' }],
{ name: 'poolId', type: 'bytes32' },
{ name: 'makerAddress', type: 'address' },
],
}, },
ERC20_METHOD_ABI, ERC20_METHOD_ABI,
ERC721_METHOD_ABI, ERC721_METHOD_ABI,

4
packages/order-utils/src/eip712_utils.ts
View File

@ -133,13 +133,13 @@ export const eip712Utils = {
poolId: string, poolId: string,
makerAddress: string, makerAddress: string,
verifyingContractAddress: string, verifyingContractAddress: string,
chainId: number chainId: number,
): EIP712TypedData => { ): EIP712TypedData => {
const domain = { const domain = {
name: constants.STAKING_DOMAIN_NAME, name: constants.STAKING_DOMAIN_NAME,
version: constants.STAKING_DOMAIN_VERSION, version: constants.STAKING_DOMAIN_VERSION,
verifyingContractAddress, verifyingContractAddress,
chainId chainId,
}; };
const approval = { const approval = {
poolId, poolId,