@0x:contracts-exchange Added the MixinStakingManager contract

contracts/exchange/test/staking_manager.ts

@@ -0,0 +1,143 @@
+import { blockchainTests, constants, expect, LogDecoder } from '@0x/contracts-test-utils';
+import { BigNumber, OwnableRevertErrors } from '@0x/utils';
+import { LogWithDecodedArgs } from 'ethereum-types';
+
+import {
+    artifacts,
+    ExchangeContract,
+    ExchangeUpdatedProtocolFeeMultiplierEventArgs,
+    ExchangeUpdatedStakingAddressEventArgs,
+    ExchangeUpdatedWethAddressEventArgs,
+} from '../src';
+
+blockchainTests.resets('MixinStakingManager', env => {
+    let accounts: string[];
+    let exchange: ExchangeContract;
+    let logDecoder: LogDecoder;
+    let nonOwner: string;
+    let owner: string;
+    let staking: string;
+    let weth: string;
+
+    // The protocolFeeMultiplier that will be used to test the update functions.
+    const protocolFeeMultiplier = new BigNumber(15000);
+
+    before(async () => {
+        accounts = await env.web3Wrapper.getAvailableAddressesAsync();
+        owner = accounts[0];
+        nonOwner = accounts[1];
+        staking = accounts[2];
+        weth = accounts[3];
+
+        // Update the from address of the txDefaults. This is the address that will become the owner.
+        env.txDefaults.from = owner;
+
+        // Deploy the exchange contract.
+        exchange = await ExchangeContract.deployFrom0xArtifactAsync(
+            artifacts.Exchange,
+            env.provider,
+            env.txDefaults,
+            {},
+            new BigNumber(1337),
+        );
+
+        // Configure the log decoder
+        logDecoder = new LogDecoder(env.web3Wrapper, artifacts);
+    });
+
+    blockchainTests.resets('updateProtocolFeeMultiplier', () => {
+        it('should revert if msg.sender != owner', async () => {
+            const expectedError = new OwnableRevertErrors.OnlyOwnerError(nonOwner, owner);
+
+            // Ensure that the transaction reverts with the expected rich error.
+            const tx = exchange.updateStakingAddress.sendTransactionAsync(staking, {
+                from: nonOwner,
+            });
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('should succeed and emit an UpdatedProtocolFeeMultiplier event if msg.sender == owner', async () => {
+            // Call the `updateProtocolFeeMultiplier()` function and get the receipt.
+            const receipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await exchange.updateProtocolFeeMultiplier.sendTransactionAsync(protocolFeeMultiplier, {
+                    from: owner,
+                }),
+            );
+
+            // Verify that the staking address was actually updated to the correct address.
+            const updated = await exchange.protocolFeeMultiplier.callAsync();
+            expect(updated).bignumber.to.be.eq(protocolFeeMultiplier);
+
+            // Ensure that the correct `UpdatedStakingAddress` event was logged.
+            // tslint:disable:no-unnecessary-type-assertion
+            const updatedEvent = receipt.logs[0] as LogWithDecodedArgs<ExchangeUpdatedProtocolFeeMultiplierEventArgs>;
+            expect(updatedEvent.event).to.be.eq('UpdatedProtocolFeeMultiplier');
+            expect(updatedEvent.args.oldProtocolFeeMultiplier).bignumber.to.be.eq(constants.ZERO_AMOUNT);
+            expect(updatedEvent.args.updatedProtocolFeeMultiplier).bignumber.to.be.eq(protocolFeeMultiplier);
+        });
+    });
+
+    blockchainTests.resets('updateStakingAddress', () => {
+        it('should revert if msg.sender != owner', async () => {
+            const expectedError = new OwnableRevertErrors.OnlyOwnerError(nonOwner, owner);
+
+            // Ensure that the transaction reverts with the expected rich error.
+            const tx = exchange.updateStakingAddress.sendTransactionAsync(staking, {
+                from: nonOwner,
+            });
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('should succeed and emit an UpdatedStakingAddress event if msg.sender == owner', async () => {
+            // Call the `updateStakingAddress()` function and get the receipt.
+            const receipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await exchange.updateStakingAddress.sendTransactionAsync(staking, {
+                    from: owner,
+                }),
+            );
+
+            // Verify that the staking address was actually updated to the correct address.
+            const updated = await exchange.staking.callAsync();
+            expect(updated).to.be.eq(staking);
+
+            // Ensure that the correct `UpdatedStakingAddress` event was logged.
+            // tslint:disable:no-unnecessary-type-assertion
+            const updatedEvent = receipt.logs[0] as LogWithDecodedArgs<ExchangeUpdatedStakingAddressEventArgs>;
+            expect(updatedEvent.event).to.be.eq('UpdatedStakingAddress');
+            expect(updatedEvent.args.oldStaking).to.be.eq(constants.NULL_ADDRESS);
+            expect(updatedEvent.args.updatedStaking).to.be.eq(staking);
+        });
+    });
+
+    blockchainTests.resets('updateWethAddress', () => {
+        it('should revert if msg.sender != owner', async () => {
+            const expectedError = new OwnableRevertErrors.OnlyOwnerError(nonOwner, owner);
+
+            // Ensure that the transaction reverts with the expected rich error.
+            const tx = exchange.updateWethAddress.sendTransactionAsync(weth, {
+                from: nonOwner,
+            });
+            return expect(tx).to.revertWith(expectedError);
+        });
+
+        it('should succeed and emit an UpdatedStakingAddress event if msg.sender == owner', async () => {
+            // Call the `updateWethAddress()` function and get the receipt.
+            const receipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await exchange.updateWethAddress.sendTransactionAsync(weth, {
+                    from: owner,
+                }),
+            );
+
+            // Verify that the staking address was actually updated to the correct address.
+            const updated = await exchange.weth.callAsync();
+            expect(updated).to.be.eq(weth);
+
+            // Ensure that the correct `UpdatedStakingAddress` event was logged.
+            // tslint:disable:no-unnecessary-type-assertion
+            const updatedEvent = receipt.logs[0] as LogWithDecodedArgs<ExchangeUpdatedWethAddressEventArgs>;
+            expect(updatedEvent.event).to.be.eq('UpdatedWethAddress');
+            expect(updatedEvent.args.oldWeth).to.be.eq(constants.NULL_ADDRESS);
+            expect(updatedEvent.args.updatedWeth).to.be.eq(weth);
+        });
+    });
+});