Commit ⋅ Synthetixio/synthetix

	1	+	pragma solidity ^0.5.16;
	2	+
	3	+	// Inheritance
	4	+	import "./Owned.sol";
	5	+	import "./MixinResolver.sol";
	6	+	import "./interfaces/ISynthetixBridgeToBase.sol";
	7	+
	8	+	// Internal references
	9	+	import "./interfaces/ISynthetix.sol";
	10	+
	11	+	// solhint-disable indent
	12	+	import "@eth-optimism/rollup-contracts/build/contracts/bridge/interfaces/CrossDomainMessenger.interface.sol";
	13	+
	14	+
	15	+	contract SynthetixBridgeToBase is Owned, MixinResolver, ISynthetixBridgeToBase {
	16	+	uint32 private constant CROSS_DOMAIN_MESSAGE_GAS_LIMIT = 3e6; //TODO: verify value
	17	+
	18	+	/* ========== ADDRESS RESOLVER CONFIGURATION ========== */
	19	+	bytes32 private constant CONTRACT_EXT_MESSENGER = "ext:Messenger";
	20	+	bytes32 private constant CONTRACT_SYNTHETIX = "Synthetix";
	21	+	bytes32 private constant CONTRACT_SYNTHETIX_BRIDGE_TO_OPTIMISM = "base:SynthetixBridgeToOptimism";
	22	+
	23	+	bytes32[24] private addressesToCache = [
	24	+	CONTRACT_EXT_MESSENGER,
	25	+	CONTRACT_SYNTHETIX,
	26	+	CONTRACT_SYNTHETIX_BRIDGE_TO_OPTIMISM
	27	+	];
	28	+
	29	+	//
	30	+	// ========== CONSTRUCTOR ==========
	31	+
	32	+	constructor(address _owner, address _resolver) public Owned(_owner) MixinResolver(_resolver, addressesToCache) {}
	33	+
	34	+	//
	35	+	// ========== INTERNALS ============
	36	+
	37	+	function messenger() internal view returns (ICrossDomainMessenger) {
	38	+	return ICrossDomainMessenger(requireAndGetAddress(CONTRACT_EXT_MESSENGER, "Missing Messenger address"));
	39	+	}
	40	+
	41	+	function synthetix() internal view returns (ISynthetix) {
	42	+	return ISynthetix(requireAndGetAddress(CONTRACT_SYNTHETIX, "Missing Synthetix address"));
	43	+	}
	44	+
	45	+	function synthetixBridgeToOptimism() internal view returns (address) {
	46	+	return requireAndGetAddress(CONTRACT_SYNTHETIX_BRIDGE_TO_OPTIMISM, "Missing Bridge address");
	47	+	}
	48	+
	49	+	// ========== PUBLIC FUNCTIONS =========
	50	+
	51	+	// invoked by user on L2
	52	+	function initiateWithdrawal(uint amount) external {
	53	+	// instruct L2 Synthetix to burn this supply
	54	+	synthetix().burnSecondary(msg.sender, amount);
	55	+
	56	+	// create message payload for L1
	57	+	bytes memory messageData = abi.encodeWithSignature("completeWithdrawal(address,uint256)", msg.sender, amount);
	58	+
	59	+	// relay the message to Bridge on L1 via L2 Messenger
	60	+	messenger().sendMessage(synthetixBridgeToOptimism(), messageData, CROSS_DOMAIN_MESSAGE_GAS_LIMIT);
	61	+
	62	+	emit WithdrawalInitiated(msg.sender, amount);
	63	+	}
	64	+
	65	+	// ========= RESTRICTED FUNCTIONS ==============
	66	+
	67	+	// invoked by Messenger on L2
	68	+	function mintSecondaryFromDeposit(address account, uint amount) external {
	69	+	// ensure function only callable from the L2 bridge via messenger (aka relayer)
	70	+	require(msg.sender == address(messenger()), "Only the relayer can call this");
	71	+	require(messenger().xDomainMessageSender() == synthetixBridgeToOptimism(), "Only the L1 bridge can invoke");
	72	+
	73	+	// now tell Synthetix to mint these tokens, deposited in L1, into the same account for L2
	74	+	synthetix().mintSecondary(account, amount);
	75	+
	76	+	emit MintedSecondary(account, amount);
	77	+	}
	78	+
	79	+	// ========== EVENTS ==========
	80	+	event MintedSecondary(address indexed account, uint amount);
	81	+	event WithdrawalInitiated(address indexed account, uint amount);
	82	+	}
0	83		imilarity index 50%
1	84		ename from contracts/SecondaryDeposit.sol
2	85		ename to contracts/SynthetixBridgeToOptimism.sol

@@ -128,10 +128,6 @@

        return getTradingRewardsEnabled();
    }

    function maximumDeposit() external view returns (uint) {
        return getMaximumDeposit();
    }

    // ========== RESTRICTED ==========

    function setTradingRewardsEnabled(bool _tradingRewardsEnabled) external onlyOwner {

@@ -252,11 +248,6 @@

        emit AggregatorWarningFlagsUpdated(_flags);
    }

    function setMaximumDeposit(uint _maxDeposit) external onlyOwner {
        flexibleStorage().setUIntValue(SETTING_CONTRACT_NAME, SETTING_MAXIMUM_DEPOSIT, _maxDeposit);
        emit MaximumDepositUpdated(_maxDeposit);
    }

    // ========== EVENTS ==========
    event TradingRewardsEnabled(bool enabled);
    event WaitingPeriodSecsUpdated(uint waitingPeriodSecs);

@@ -272,5 +263,4 @@

    event MinimumStakeTimeUpdated(uint minimumStakeTime);
    event DebtSnapshotStaleTimeUpdated(uint debtSnapshotStaleTime);
    event AggregatorWarningFlagsUpdated(address flags);
    event MaximumDepositUpdated(uint maxDeposit);
}

@@ -5,7 +5,7 @@



contract MintableSynthetix is Synthetix {
    bytes32 private constant CONTRACT_SECONDARYDEPOSIT = "SecondaryDeposit";
    bytes32 private constant CONTRACT_SYNTHETIX_BRIDGE = "SynthetixBridgeToBase";

    constructor(
        address payable _proxy,

@@ -14,19 +14,19 @@

        uint _totalSupply,
        address _resolver
    ) public Synthetix(_proxy, _tokenState, _owner, _totalSupply, _resolver) {
        appendToAddressCache(CONTRACT_SECONDARYDEPOSIT);
        appendToAddressCache(CONTRACT_SYNTHETIX_BRIDGE);
    }

    /* ========== VIEWS ======================= */

    function secondaryDeposit() internal view returns (address) {
        return requireAndGetAddress(CONTRACT_SECONDARYDEPOSIT, "Resolver is missing SecondaryDeposit address");
    function synthetixBridge() internal view returns (address) {
        return requireAndGetAddress(CONTRACT_SYNTHETIX_BRIDGE, "Resolver is missing SynthetixBridgeToBase address");
    }

    /* ========== RESTRICTED FUNCTIONS ========== */

    function mintSecondary(address account, uint amount) external {
        require(msg.sender == secondaryDeposit(), "Can only be invoked by the SecondaryDeposit contract");
        require(msg.sender == synthetixBridge(), "Can only be invoked by the SynthetixBridgeToBase contract");

        tokenState.setBalanceOf(account, tokenState.balanceOf(account).add(amount));
        emitTransfer(address(this), account, amount);

@@ -34,7 +34,7 @@

    }

    function burnSecondary(address account, uint amount) external {
        require(msg.sender == secondaryDeposit(), "Can only be invoked by the SecondaryDeposit contract");
        require(msg.sender == synthetixBridge(), "Can only be invoked by the SynthetixBridgeToBase contract");

        tokenState.setBalanceOf(account, tokenState.balanceOf(account).sub(amount));
        emitTransfer(account, address(0), amount);

@@ -3,46 +3,41 @@

// Inheritance
import "./Owned.sol";
import "./MixinResolver.sol";
import "./MixinSystemSettings.sol";
import "./interfaces/ISecondaryDeposit.sol";
import "./interfaces/ISynthetixBridgeToOptimism.sol";

// Internal references
import "./interfaces/ISynthetix.sol";
import "./interfaces/IERC20.sol";
import "./interfaces/IIssuer.sol";
import "./interfaces/IRewardEscrow.sol";
// import "./interfaces/IRewardEscrow.sol";

// solhint-disable indent
import "@eth-optimism/rollup-contracts/build/contracts/bridge/interfaces/CrossDomainMessenger.interface.sol";


contract SecondaryDeposit is Owned, MixinResolver, MixinSystemSettings, ISecondaryDeposit {
    bool public activated;
contract SynthetixBridgeToOptimism is Owned, MixinResolver, ISynthetixBridgeToOptimism {
    uint32 private constant CROSS_DOMAIN_MESSAGE_GAS_LIMIT = 3e6; //TODO: verify value, uint32 to uint in new version

    /* ========== ADDRESS RESOLVER CONFIGURATION ========== */
    bytes32 private constant CONTRACT_EXT_MESSENGER = "ext:Messenger";
    bytes32 private constant CONTRACT_SYNTHETIX = "Synthetix";
    bytes32 private constant CONTRACT_ISSUER = "Issuer";
    bytes32 private constant CONTRACT_REWARDESCROW = "RewardEscrow";
    bytes32 private constant CONTRACT_ALT_SECONDARYDEPOSIT = "alt:SecondaryDeposit";
    // bytes32 private constant CONTRACT_REWARDESCROW = "RewardEscrow";
    bytes32 private constant CONTRACT_SYNTHETIX_BRIDGE_TO_BASE = "ovm:SynthetixBridgeToBase";

    bytes32[24] private addressesToCache = [
        CONTRACT_EXT_MESSENGER,
        CONTRACT_SYNTHETIX,
        CONTRACT_ISSUER,
        CONTRACT_REWARDESCROW,
        CONTRACT_ALT_SECONDARYDEPOSIT
        // CONTRACT_REWARDESCROW,
        CONTRACT_SYNTHETIX_BRIDGE_TO_BASE
    ];

    //
    bool public activated;

    // ========== CONSTRUCTOR ==========

    constructor(address _owner, address _resolver)
        public
        Owned(_owner)
        MixinResolver(_resolver, addressesToCache)
        MixinSystemSettings()
    {
    constructor(address _owner, address _resolver) public Owned(_owner) MixinResolver(_resolver, addressesToCache) {
        activated = true;
    }


@@ -70,14 +65,8 @@

    //     return IRewardEscrow(requireAndGetAddress(CONTRACT_REWARDESCROW, "Missing RewardEscrow address"));
    // }

    function companion() internal view returns (address) {
        return requireAndGetAddress(CONTRACT_ALT_SECONDARYDEPOSIT, "Missing Companion address");
    }

    /// ========= VIEWS =================

    function maximumDeposit() external view returns (uint) {
        return getMaximumDeposit();
    function synthetixBridgeToBase() internal view returns (address) {
        return requireAndGetAddress(CONTRACT_SYNTHETIX_BRIDGE_TO_BASE, "Missing Bridge address");
    }

    // ========== PUBLIC FUNCTIONS =========

@@ -86,8 +75,6 @@

    function deposit(uint amount) external {
        require(activated, "Function deactivated");

        require(amount <= getMaximumDeposit(), "Cannot deposit more than the max");

        require(issuer().debtBalanceOf(msg.sender, "sUSD") == 0, "Cannot deposit with debt");

        // now remove their reward escrow

@@ -100,73 +87,42 @@

        // create message payload for L2
        bytes memory messageData = abi.encodeWithSignature("mintSecondaryFromDeposit(address,uint256)", msg.sender, amount);

        // relay the message to this contract on L2 via Messenger1
        messenger().sendMessage(companion(), messageData, 3e6);
        // relay the message to this contract on L2 via L1 Messenger
        messenger().sendMessage(synthetixBridgeToBase(), messageData, CROSS_DOMAIN_MESSAGE_GAS_LIMIT);

        emit Deposit(msg.sender, amount);
    }

    // invoked by user on L2
    function initiateWithdrawal(
        uint /*amount*/
    ) external {
        revert("Not implemented");

        // instruct L2 Synthetix to burn this supply
        // synthetix().burnSecondary(msg.sender, amount);

        // // create message payload for L1
        // bytes memory messageData = abi.encodeWithSignature("completeWithdrawal(address,uint256)", msg.sender, amount);

        // // relay the message to SecondaryDepost on L1 via Messenger2
        // messenger().sendMessage(companion(), messageData, 3e6);
    }

    // ========= RESTRICTED FUNCTIONS ==============

    // invoked by Messenger2 on L2
    function mintSecondaryFromDeposit(address account, uint amount) external {
        // ensure function only callable from SecondaryDeposit1 via messenger (aka relayer)
    // invoked by Messenger on L1 after L2 waiting period elapses
    function completeWithdrawal(address account, uint amount) external {
        // ensure function only callable from L2 Bridge via messenger (aka relayer)
        require(msg.sender == address(messenger()), "Only the relayer can call this");
        require(messenger().xDomainMessageSender() == companion(), "Only deposit contract can invoke");

        // now tell Synthetix to mint these tokens, deposited in L1, into the same account for L2
        synthetix().mintSecondary(account, amount);

        emit MintedSecondary(account, amount);
    }

    // invoked by Messenger1 on L1 after L2 waiting period elapses
    function completeWithdrawal(
        address, /*account*/
        uint /*amount*/
    ) external {
        revert("Not implemented");
        // ensure function only callable from SecondaryDeposit2 via messenger (aka relayer)
        // require(msg.sender == address(messenger()), "Only the relayer can call this");
        // require(messenger().xDomainMessageSender() == companion(), "Only deposit contract can invoke");
        require(messenger().xDomainMessageSender() == synthetixBridgeToBase(), "Only the L2 bridge can invoke");

        // // transfer amount back to user
        // synthetixERC20().transfer(account, amount);
        // transfer amount back to user
        synthetixERC20().transfer(account, amount);

        // no escrow actions - escrow remains on L2
        emit WithdrawalCompleted(account, amount);
    }

    // invoked by the owner for migrating the contract to the new version that will allow for withdrawals
    function migrateDeposit(address newDeposit) external onlyOwner {
    function migrateBridge(address newBridge) external onlyOwner {
        activated = false;

        IERC20 ERC20Synthetix = synthetixERC20();
        // get the current contract balance and transfer it to the new SecondaryDeposit contract
        // get the current contract balance and transfer it to the new SynthetixL1ToL2Bridge contract
        uint contractBalance = ERC20Synthetix.balanceOf(address(this));
        ERC20Synthetix.transfer(newDeposit, contractBalance);
        ERC20Synthetix.transfer(newBridge, contractBalance);

        emit DepositMigrated(address(this), newDeposit, contractBalance);
        emit BridgeMigrated(address(this), newBridge, contractBalance);
    }

    // ========== EVENTS ==========

    event Deposit(address indexed account, uint amount);
    event DepositMigrated(address oldDeposit, address newDeposit, uint amount);
    event MintedSecondary(address indexed account, uint amount);
    event BridgeMigrated(address oldBridge, address newBridge, uint amount);
    event WithdrawalCompleted(address indexed account, uint amount);
}

@@ -22,7 +22,6 @@

    bytes32 internal constant SETTING_MINIMUM_STAKE_TIME = "minimumStakeTime";
    bytes32 internal constant SETTING_AGGREGATOR_WARNING_FLAGS = "aggregatorWarningFlags";
    bytes32 internal constant SETTING_TRADING_REWARDS_ENABLED = "tradingRewardsEnabled";
    bytes32 internal constant SETTING_MAXIMUM_DEPOSIT = "maximumDeposit";
    bytes32 internal constant SETTING_DEBT_SNAPSHOT_STALE_TIME = "debtSnapshotStaleTime";

    bytes32 private constant CONTRACT_FLEXIBLESTORAGE = "FlexibleStorage";

@@ -94,10 +93,6 @@

        return flexibleStorage().getAddressValue(SETTING_CONTRACT_NAME, SETTING_AGGREGATOR_WARNING_FLAGS);
    }

    function getMaximumDeposit() internal view returns (uint) {
        return flexibleStorage().getUIntValue(SETTING_CONTRACT_NAME, SETTING_MAXIMUM_DEPOSIT);
    }

    function getDebtSnapshotStaleTime() internal view returns (uint) {
        return flexibleStorage().getUIntValue(SETTING_CONTRACT_NAME, SETTING_DEBT_SNAPSHOT_STALE_TIME);
    }

Files		•	•	•	Coverage
contracts	3,901	3,830	0	71	98.18%
Project Totals (58 files)	3,901	3,830	0	71	98.18%

View CI Build Download

No yaml found.

Create your codecov.yml to customize your Codecov experience

Read the docs

Interact now

The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.

SVG

Learn more about the coverage sunburst graph

128	128		return getTradingRewardsEnabled();
129	129		}
130	130
131		-	function maximumDeposit() external view returns (uint) {
132		-	return getMaximumDeposit();
133		-	}
134		-
135	131		// ========== RESTRICTED ==========
136	132
137	133		function setTradingRewardsEnabled(bool _tradingRewardsEnabled) external onlyOwner {

252	248		emit AggregatorWarningFlagsUpdated(_flags);
253	249		}
254	250
255		-	function setMaximumDeposit(uint _maxDeposit) external onlyOwner {
256		-	flexibleStorage().setUIntValue(SETTING_CONTRACT_NAME, SETTING_MAXIMUM_DEPOSIT, _maxDeposit);
257		-	emit MaximumDepositUpdated(_maxDeposit);
258		-	}
259		-
260	251		// ========== EVENTS ==========
261	252		event TradingRewardsEnabled(bool enabled);
262	253		event WaitingPeriodSecsUpdated(uint waitingPeriodSecs);

272	263		event MinimumStakeTimeUpdated(uint minimumStakeTime);
273	264		event DebtSnapshotStaleTimeUpdated(uint debtSnapshotStaleTime);
274	265		event AggregatorWarningFlagsUpdated(address flags);
275		-	event MaximumDepositUpdated(uint maxDeposit);
276	266		}

100	87		// create message payload for L2
101	88		bytes memory messageData = abi.encodeWithSignature("mintSecondaryFromDeposit(address,uint256)", msg.sender, amount);
102	89
103		-	// relay the message to this contract on L2 via Messenger1
104		-	messenger().sendMessage(companion(), messageData, 3e6);
	90	+	// relay the message to this contract on L2 via L1 Messenger
	91	+	messenger().sendMessage(synthetixBridgeToBase(), messageData, CROSS_DOMAIN_MESSAGE_GAS_LIMIT);
105	92
106	93		emit Deposit(msg.sender, amount);
107	94		}
108	95
109		-	// invoked by user on L2
110		-	function initiateWithdrawal(
111		-	uint /amount/
112		-	) external {
113		-	revert("Not implemented");
114		-
115		-	// instruct L2 Synthetix to burn this supply
116		-	// synthetix().burnSecondary(msg.sender, amount);
117		-
118		-	// // create message payload for L1
119		-	// bytes memory messageData = abi.encodeWithSignature("completeWithdrawal(address,uint256)", msg.sender, amount);
120		-
121		-	// // relay the message to SecondaryDepost on L1 via Messenger2
122		-	// messenger().sendMessage(companion(), messageData, 3e6);
123		-	}
124		-
125	96		// ========= RESTRICTED FUNCTIONS ==============
126	97
127		-	// invoked by Messenger2 on L2
128		-	function mintSecondaryFromDeposit(address account, uint amount) external {
129		-	// ensure function only callable from SecondaryDeposit1 via messenger (aka relayer)
	98	+	// invoked by Messenger on L1 after L2 waiting period elapses
	99	+	function completeWithdrawal(address account, uint amount) external {
	100	+	// ensure function only callable from L2 Bridge via messenger (aka relayer)
130	101		require(msg.sender == address(messenger()), "Only the relayer can call this");
131		-	require(messenger().xDomainMessageSender() == companion(), "Only deposit contract can invoke");
132		-
133		-	// now tell Synthetix to mint these tokens, deposited in L1, into the same account for L2
134		-	synthetix().mintSecondary(account, amount);
135		-
136		-	emit MintedSecondary(account, amount);
137		-	}
138		-
139		-	// invoked by Messenger1 on L1 after L2 waiting period elapses
140		-	function completeWithdrawal(
141		-	address, /account/
142		-	uint /amount/
143		-	) external {
144		-	revert("Not implemented");
145		-	// ensure function only callable from SecondaryDeposit2 via messenger (aka relayer)
146		-	// require(msg.sender == address(messenger()), "Only the relayer can call this");
147		-	// require(messenger().xDomainMessageSender() == companion(), "Only deposit contract can invoke");
	102	+	require(messenger().xDomainMessageSender() == synthetixBridgeToBase(), "Only the L2 bridge can invoke");
148	103
149		-	// // transfer amount back to user
150		-	// synthetixERC20().transfer(account, amount);
	104	+	// transfer amount back to user
	105	+	synthetixERC20().transfer(account, amount);
151	106
152	107		// no escrow actions - escrow remains on L2
	108	+	emit WithdrawalCompleted(account, amount);
153	109		}
154	110
155	111		// invoked by the owner for migrating the contract to the new version that will allow for withdrawals
156		-	function migrateDeposit(address newDeposit) external onlyOwner {
	112	+	function migrateBridge(address newBridge) external onlyOwner {
157	113		activated = false;
158	114
159	115		IERC20 ERC20Synthetix = synthetixERC20();
160		-	// get the current contract balance and transfer it to the new SecondaryDeposit contract
	116	+	// get the current contract balance and transfer it to the new SynthetixL1ToL2Bridge contract
161	117		uint contractBalance = ERC20Synthetix.balanceOf(address(this));
162		-	ERC20Synthetix.transfer(newDeposit, contractBalance);
	118	+	ERC20Synthetix.transfer(newBridge, contractBalance);
163	119
164		-	emit DepositMigrated(address(this), newDeposit, contractBalance);
	120	+	emit BridgeMigrated(address(this), newBridge, contractBalance);
165	121		}
166	122
167	123		// ========== EVENTS ==========
168	124
169	125		event Deposit(address indexed account, uint amount);
170		-	event DepositMigrated(address oldDeposit, address newDeposit, uint amount);
171		-	event MintedSecondary(address indexed account, uint amount);
	126	+	event BridgeMigrated(address oldBridge, address newBridge, uint amount);
	127	+	event WithdrawalCompleted(address indexed account, uint amount);
172	128		}

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits

5	5
6	6
7	7		contract MintableSynthetix is Synthetix {
8		-	bytes32 private constant CONTRACT_SECONDARYDEPOSIT = "SecondaryDeposit";
	8	+	bytes32 private constant CONTRACT_SYNTHETIX_BRIDGE = "SynthetixBridgeToBase";
9	9
10	10		constructor(
11	11		address payable _proxy,

14	14		uint _totalSupply,
15	15		address _resolver
16	16		) public Synthetix(_proxy, _tokenState, _owner, _totalSupply, _resolver) {
17		-	appendToAddressCache(CONTRACT_SECONDARYDEPOSIT);
	17	+	appendToAddressCache(CONTRACT_SYNTHETIX_BRIDGE);
18	18		}
19	19
20	20		/* ========== VIEWS ======================= */
21	21
22		-	function secondaryDeposit() internal view returns (address) {
23		-	return requireAndGetAddress(CONTRACT_SECONDARYDEPOSIT, "Resolver is missing SecondaryDeposit address");
	22	+	function synthetixBridge() internal view returns (address) {
	23	+	return requireAndGetAddress(CONTRACT_SYNTHETIX_BRIDGE, "Resolver is missing SynthetixBridgeToBase address");
24	24		}
25	25
26	26		/* ========== RESTRICTED FUNCTIONS ========== */
27	27
28	28		function mintSecondary(address account, uint amount) external {
29		-	require(msg.sender == secondaryDeposit(), "Can only be invoked by the SecondaryDeposit contract");
	29	+	require(msg.sender == synthetixBridge(), "Can only be invoked by the SynthetixBridgeToBase contract");
30	30
31	31		tokenState.setBalanceOf(account, tokenState.balanceOf(account).add(amount));
32	32		emitTransfer(address(this), account, amount);

34	34		}
35	35
36	36		function burnSecondary(address account, uint amount) external {
37		-	require(msg.sender == secondaryDeposit(), "Can only be invoked by the SecondaryDeposit contract");
	37	+	require(msg.sender == synthetixBridge(), "Can only be invoked by the SynthetixBridgeToBase contract");
38	38
39	39		tokenState.setBalanceOf(account, tokenState.balanceOf(account).sub(amount));
40	40		emitTransfer(account, address(0), amount);

70	65		// return IRewardEscrow(requireAndGetAddress(CONTRACT_REWARDESCROW, "Missing RewardEscrow address"));
71	66		// }
72	67
73		-	function companion() internal view returns (address) {
74		-	return requireAndGetAddress(CONTRACT_ALT_SECONDARYDEPOSIT, "Missing Companion address");
75		-	}
76		-
77		-	/// ========= VIEWS =================
78		-
79		-	function maximumDeposit() external view returns (uint) {
80		-	return getMaximumDeposit();
	68	+	function synthetixBridgeToBase() internal view returns (address) {
	69	+	return requireAndGetAddress(CONTRACT_SYNTHETIX_BRIDGE_TO_BASE, "Missing Bridge address");
81	70		}
82	71
83	72		// ========== PUBLIC FUNCTIONS =========

86	75		function deposit(uint amount) external {
87	76		require(activated, "Function deactivated");
88	77
89		-	require(amount <= getMaximumDeposit(), "Cannot deposit more than the max");
90		-
91	78		require(issuer().debtBalanceOf(msg.sender, "sUSD") == 0, "Cannot deposit with debt");
92	79
93	80		// now remove their reward escrow

22	22		bytes32 internal constant SETTING_MINIMUM_STAKE_TIME = "minimumStakeTime";
23	23		bytes32 internal constant SETTING_AGGREGATOR_WARNING_FLAGS = "aggregatorWarningFlags";
24	24		bytes32 internal constant SETTING_TRADING_REWARDS_ENABLED = "tradingRewardsEnabled";
25		-	bytes32 internal constant SETTING_MAXIMUM_DEPOSIT = "maximumDeposit";
26	25		bytes32 internal constant SETTING_DEBT_SNAPSHOT_STALE_TIME = "debtSnapshotStaleTime";
27	26
28	27		bytes32 private constant CONTRACT_FLEXIBLESTORAGE = "FlexibleStorage";

94	93		return flexibleStorage().getAddressValue(SETTING_CONTRACT_NAME, SETTING_AGGREGATOR_WARNING_FLAGS);
95	94		}
96	95
97		-	function getMaximumDeposit() internal view returns (uint) {
98		-	return flexibleStorage().getUIntValue(SETTING_CONTRACT_NAME, SETTING_MAXIMUM_DEPOSIT);
99		-	}
100		-
101	96		function getDebtSnapshotStaleTime() internal view returns (uint) {
102	97		return flexibleStorage().getUIntValue(SETTING_CONTRACT_NAME, SETTING_DEBT_SNAPSHOT_STALE_TIME);
103	98		}