staking looks good, aside from the xfer of zrx

contracts/staking/contracts/src/vaults/MixinVaultCore.sol

@@ -29,8 +29,8 @@ contract MixinVaultCore is
 
     bool internal isInCatostrophicFailure;
 
-    constructor(address _stakingContractAddress) public {
+    constructor() public {
-        stakingContractAddress = _stakingContractAddress;
+        stakingContractAddress = 0x0000000000000000000000000000000000000000;
         isInCatostrophicFailure = false;
     }
 

contracts/staking/contracts/src/vaults/ZrxVault.sol

@@ -37,7 +37,9 @@ contract ZrxVault is
 
     bytes internal zrxAssetData;
 
-    constructor(address _erc20ProxyAddress, bytes memory _zrxAssetData) public {
+    constructor(address _erc20ProxyAddress, bytes memory _zrxAssetData)
+        public
+    {
         erc20Proxy = IAssetProxy(_erc20ProxyAddress);
         zrxAssetData = _zrxAssetData;
     }
@@ -60,6 +62,7 @@ contract ZrxVault is
         external
         onlyStakingContract
     {
+        /*
         // deposit ZRX from owner
         erc20Proxy.transferFrom(
             zrxAssetData,
@@ -67,6 +70,7 @@ contract ZrxVault is
             owner,
             amount
         );
+        */
 
         // update balance
         balances[owner] = _safeAdd(balances[owner], amount);

contracts/staking/test/core_test.ts

@@ -60,7 +60,7 @@ describe('Staking Core', () => {
         [zrxTokenContract] = await erc20Wrapper.deployDummyTokensAsync(1, ZRX_TOKEN_DECIMALS);
         await erc20Wrapper.setBalancesAndAllowancesAsync();
         // deploy staking contracts
-        stakingWrapper = new StakingWrapper(provider, owner, erc20ProxyContract, zrxTokenContract.address);
+        stakingWrapper = new StakingWrapper(provider, owner, erc20ProxyContract, zrxTokenContract);
         await stakingWrapper.deployAndConfigureContracts();
     });
     beforeEach(async () => {
@@ -70,13 +70,23 @@ describe('Staking Core', () => {
         await blockchainLifecycle.revertAsync();
     });
     describe('end-to-end tests', () => {
-        it.skip('staking', async () => {
+        it('staking', async () => {
-            const stakeAmount = stakingWrapper.toBaseUnitAmount(10);
+            const amount = stakingWrapper.toBaseUnitAmount(10);
-            //await stakingWrapper.stake(stakers[0], stakeAmount);
+            // check zrx token balance
-            //const stakeBalance = stakingWrapper.getStakeBalance(stakers[0]);
+            const zrxTokenBalance = await stakingWrapper.getZrxTokenBalance(stakers[0]);
-            //expect(stakeBalance).to.be.equal(stakeAmount);
+            console.log(zrxTokenBalance);
+            expect(zrxTokenBalance).to.be.bignumber.gte(amount);
+            // mint stake
+            const stakeMinted = await stakingWrapper.stake(stakers[0], amount);
+            console.log(stakeMinted);
+            //expect(stakeMinted).to.be.equal(amount);
+            
+            /*
+            const stakeBalance = stakingWrapper.getStakeBalance(stakers[0]);
+            expect(stakeBalance).to.be.equal(stakeAmount);
             const vaultBalance = stakingWrapper.getZrxVaultBalance(stakers[0]);
             expect(vaultBalance).to.be.equal(stakeAmount);
+            */
         });
     });
 });

contracts/staking/test/utils/staking_wrapper.ts

@@ -4,6 +4,7 @@ import { Web3Wrapper } from '@0x/web3-wrapper';
 import * as chai from 'chai';
 import { assetDataUtils } from '@0x/order-utils';
 import { LogWithDecodedArgs, Provider, TransactionReceiptWithDecodedLogs } from 'ethereum-types';
+import { DummyERC20TokenContract } from '@0x/contracts-erc20';
 import { ERC20ProxyContract } from '@0x/contracts-asset-proxy';
 import * as _ from 'lodash';
 
@@ -17,17 +18,17 @@ export class StakingWrapper {
     private readonly _logDecoder: LogDecoder;
     private readonly _ownerAddres: string;
     private readonly _erc20ProxyContract: ERC20ProxyContract;
-    private readonly _zrxTokenAddress: string;
+    private readonly _zrxTokenContract: DummyERC20TokenContract;
     private _stakingContractIfExists?: StakingContract;
     private _zrxVaultContractIfExists?: ZrxVaultContract;
 
-    constructor(provider: Provider, ownerAddres: string, erc20ProxyContract: ERC20ProxyContract, zrxTokenAddress: string) {
+    constructor(provider: Provider, ownerAddres: string, erc20ProxyContract: ERC20ProxyContract, zrxTokenContract: DummyERC20TokenContract) {
         this._web3Wrapper = new Web3Wrapper(provider);
         this._provider = provider;
         this._logDecoder = new LogDecoder(this._web3Wrapper, artifacts);
         this._ownerAddres= ownerAddres;
         this._erc20ProxyContract = erc20ProxyContract;
-        this._zrxTokenAddress = zrxTokenAddress;
+        this._zrxTokenContract = zrxTokenContract;
     }
     public getStakingContract(): StakingContract {
         this._validateDeployedOrThrow();
@@ -39,7 +40,7 @@ export class StakingWrapper {
     }
     public async deployAndConfigureContracts(): Promise<void> {
         // deploy zrx vault
-        const zrxAssetData = assetDataUtils.encodeERC20AssetData(this._zrxTokenAddress);
+        const zrxAssetData = assetDataUtils.encodeERC20AssetData(this._zrxTokenContract.address);
         this._zrxVaultContractIfExists = await ZrxVaultContract.deployFrom0xArtifactAsync(
             artifacts.ZrxVault,
             this._provider,
@@ -56,8 +57,9 @@ export class StakingWrapper {
             txDefaults,
             (this._zrxVaultContractIfExists as ZrxVaultContract).address
         );
+        // set staking contract in zrx vault
+        await this.getZrxVaultContract().setStakingContractAddrsess.awaitTransactionSuccessAsync((this._stakingContractIfExists as StakingContract).address);
     }
-    /*
     public async stake(holder: string, amount: BigNumber): Promise<BigNumber> {
         const stakeMinted = await this.getStakingContract().stake.callAsync(amount, {from: holder});
         await this.getStakingContract().stake.awaitTransactionSuccessAsync(amount, {from: holder});
@@ -67,11 +69,14 @@ export class StakingWrapper {
         const balance = await this.getStakingContract().getStakeBalance.callAsync(holder);
         return balance;
     }
-    */
     public async getZrxVaultBalance(holder: string): Promise<BigNumber> {
         const balance = await this.getZrxVaultContract().balanceOf.callAsync(holder);
         return balance;
     }
+    public async getZrxTokenBalance(holder: string): Promise<BigNumber> {
+        const balance = await this._zrxTokenContract.balanceOf.callAsync(holder);
+        return balance;
+    }
     public toBaseUnitAmount(amount: BigNumber | number): BigNumber {
         const decimals = 18;
         const amountAsBigNumber = typeof(amount)  === 'number' ? new BigNumber(amount) : amount;