SIP-140 Exchange with tracking for initiator (Synthetixio#1279)

Author: justin j. moses

contracts/BaseSynthetix.sol

@@ -292,6 +292,16 @@ contract BaseSynthetix is IERC20, ExternStateToken, MixinResolver, ISynthetix {
         return issuer().burnSynthsToTargetOnBehalf(burnForAddress, messageSender);
     }
 
+    function exchangeWithTrackingForInitiator(
+        bytes32,
+        uint,
+        bytes32,
+        address,
+        bytes32
+    ) external returns (uint amountReceived) {
+        _notImplemented();
+    }
+
     function exchangeWithVirtual(
         bytes32,
         uint,

contracts/Synthetix.sol

@@ -72,6 +72,29 @@ contract Synthetix is BaseSynthetix {
             );
     }
 
+    // SIP-140 The initiating user of this exchange will receive the proceeds of the exchange
+    // Note: this function may have unintended consequences if not understood correctly. Please
+    // read SIP-140 for more information on the use-case
+    function exchangeWithTrackingForInitiator(
+        bytes32 sourceCurrencyKey,
+        uint sourceAmount,
+        bytes32 destinationCurrencyKey,
+        address originator,
+        bytes32 trackingCode
+    ) external exchangeActive(sourceCurrencyKey, destinationCurrencyKey) optionalProxy returns (uint amountReceived) {
+        return
+            exchanger().exchangeWithTracking(
+                messageSender,
+                sourceCurrencyKey,
+                sourceAmount,
+                destinationCurrencyKey,
+                // solhint-disable avoid-tx-origin
+                tx.origin,
+                originator,
+                trackingCode
+            );
+    }
+
     function settle(bytes32 currencyKey)
         external
         optionalProxy

contracts/interfaces/ISynthetix.sol

@@ -73,6 +73,14 @@ interface ISynthetix {
         bytes32 trackingCode
     ) external returns (uint amountReceived);
 
+    function exchangeWithTrackingForInitiator(
+        bytes32 sourceCurrencyKey,
+        uint sourceAmount,
+        bytes32 destinationCurrencyKey,
+        address originator,
+        bytes32 trackingCode
+    ) external returns (uint amountReceived);
+
     function exchangeOnBehalfWithTracking(
         address exchangeForAddress,
         bytes32 sourceCurrencyKey,

contracts/test-helpers/MockThirdPartyExchangeContract.sol

@@ -0,0 +1,22 @@
+pragma solidity ^0.5.16;
+
+import "../interfaces/IAddressResolver.sol";
+import "../interfaces/ISynthetix.sol";
+
+contract MockThirdPartyExchangeContract {
+    IAddressResolver public resolver;
+
+    constructor(IAddressResolver _resolver) public {
+        resolver = _resolver;
+    }
+
+    function exchange(
+        bytes32 src,
+        uint amount,
+        bytes32 dest
+    ) external {
+        ISynthetix synthetix = ISynthetix(resolver.getAddress("Synthetix"));
+
+        synthetix.exchangeWithTrackingForInitiator(src, amount, dest, address(this), "TRACKING_CODE");
+    }
+}

publish/releases.json

@@ -244,7 +244,7 @@
 			"minor": 46
 		},
 		"sources": ["Exchanger", "Synthetix"],
-		"sips": [138, 139]
+		"sips": [138, 139, 140]
 	},
 	{
 		"name": "Alnitak (Optimism)",
@@ -254,6 +254,6 @@
 		},
 		"ovm": true,
 		"sources": ["Exchanger", "MintableSynthetix"],
-		"sips": [138, 139]
+		"sips": [138, 139, 140]
 	}
 ]

test/contracts/BaseSynthetix.js

@@ -90,6 +90,7 @@ contract('BaseSynthetix', async accounts => {
 				'exchangeOnBehalf',
 				'exchangeOnBehalfWithTracking',
 				'exchangeWithTracking',
+				'exchangeWithTrackingForInitiator',
 				'exchangeWithVirtual',
 				'issueMaxSynths',
 				'issueMaxSynthsOnBehalf',
@@ -142,15 +143,25 @@ contract('BaseSynthetix', async accounts => {
 
 	describe('non-basic functions always revert', () => {
 		const amount = 100;
-		it('ExchangeWithVirtual should revert no matter who the caller is', async () => {
+		it('exchangeWithVirtual should revert no matter who the caller is', async () => {
 			await onlyGivenAddressCanInvoke({
 				fnc: baseSynthetix.exchangeWithVirtual,
 				accounts,
 				args: [sUSD, amount, sAUD, toBytes32('AGGREGATOR')],
 				reason: 'Cannot be run on this layer',
 			});
 		});
-		it('Mint should revert no matter who the caller is', async () => {
+
+		it('exchangeWithTrackingForInitiator should revert no matter who the caller is', async () => {
+			await onlyGivenAddressCanInvoke({
+				fnc: baseSynthetix.exchangeWithTrackingForInitiator,
+				accounts,
+				args: [sUSD, amount, sAUD, owner, toBytes32('AGGREGATOR')],
+				reason: 'Cannot be run on this layer',
+			});
+		});
+
+		it('mint should revert no matter who the caller is', async () => {
 			await onlyGivenAddressCanInvoke({
 				fnc: baseSynthetix.mint,
 				accounts,
@@ -159,31 +170,31 @@ contract('BaseSynthetix', async accounts => {
 			});
 		});
 
-		it('LiquidateDelinquentAccount should revert no matter who the caller is', async () => {
+		it('liquidateDelinquentAccount should revert no matter who the caller is', async () => {
 			await onlyGivenAddressCanInvoke({
 				fnc: baseSynthetix.liquidateDelinquentAccount,
 				accounts,
 				args: [account1, amount],
 				reason: 'Cannot be run on this layer',
 			});
 		});
-		it('MintSecondary should revert no matter who the caller is', async () => {
+		it('mintSecondary should revert no matter who the caller is', async () => {
 			await onlyGivenAddressCanInvoke({
 				fnc: baseSynthetix.mintSecondary,
 				accounts,
 				args: [account1, amount],
 				reason: 'Cannot be run on this layer',
 			});
 		});
-		it('MintSecondaryRewards should revert no matter who the caller is', async () => {
+		it('mintSecondaryRewards should revert no matter who the caller is', async () => {
 			await onlyGivenAddressCanInvoke({
 				fnc: baseSynthetix.mintSecondaryRewards,
 				accounts,
 				args: [amount],
 				reason: 'Cannot be run on this layer',
 			});
 		});
-		it('BurnSecondary should revert no matter who the caller is', async () => {
+		it('burnSecondary should revert no matter who the caller is', async () => {
 			await onlyGivenAddressCanInvoke({
 				fnc: baseSynthetix.burnSecondary,
 				accounts,
@@ -322,7 +333,7 @@ contract('BaseSynthetix', async accounts => {
 
 		it('exchangeOnBehalf is called with the right arguments ', async () => {
 			await baseSynthetix.exchangeOnBehalf(account1, currencyKey1, amount1, currencyKey2, {
-				from: owner,
+				from: msgSender,
 			});
 			assert.equal(smockExchanger.smocked.exchangeOnBehalf.calls[0][0], account1);
 			assert.equal(smockExchanger.smocked.exchangeOnBehalf.calls[0][1], msgSender);
@@ -338,7 +349,7 @@ contract('BaseSynthetix', async accounts => {
 				currencyKey2,
 				account2,
 				trackingCode,
-				{ from: owner }
+				{ from: msgSender }
 			);
 			assert.equal(smockExchanger.smocked.exchangeWithTracking.calls[0][0], msgSender);
 			assert.equal(smockExchanger.smocked.exchangeWithTracking.calls[0][1], currencyKey1);

test/contracts/Synthetix.js

@@ -24,9 +24,9 @@ const {
 } = require('../..');
 
 contract('Synthetix', async accounts => {
-	const [sAUD, sEUR] = ['sAUD', 'sEUR'].map(toBytes32);
+	const [sAUD, sEUR, sUSD, sETH] = ['sAUD', 'sEUR', 'sUSD', 'sETH'].map(toBytes32);
 
-	const [, owner, account1, account2] = accounts;
+	const [, owner, account1, account2, account3] = accounts;
 
 	let synthetix,
 		exchangeRates,
@@ -36,7 +36,9 @@ contract('Synthetix', async accounts => {
 		rewardEscrowV2,
 		oracle,
 		addressResolver,
-		systemStatus;
+		systemStatus,
+		sUSDContract,
+		sETHContract;
 
 	before(async () => {
 		({
@@ -48,6 +50,8 @@ contract('Synthetix', async accounts => {
 			RewardEscrow: rewardEscrow,
 			RewardEscrowV2: rewardEscrowV2,
 			SupplySchedule: supplySchedule,
+			SynthsUSD: sUSDContract,
+			SynthsETH: sETHContract,
 		} = await setupAllContracts({
 			accounts,
 			synths: ['sUSD', 'sETH', 'sEUR', 'sAUD'],
@@ -105,6 +109,7 @@ contract('Synthetix', async accounts => {
 		beforeEach(async () => {
 			smockExchanger = await smockit(artifacts.require('Exchanger').abi);
 			smockExchanger.smocked.exchangeWithVirtual.will.return.with(() => ['1', account1]);
+			smockExchanger.smocked.exchangeWithTracking.will.return.with(() => ['1']);
 			await addressResolver.importAddresses(
 				['Exchanger'].map(toBytes32),
 				[smockExchanger.address],
@@ -130,6 +135,24 @@ contract('Synthetix', async accounts => {
 			assert.equal(smockExchanger.smocked.exchangeWithVirtual.calls[0][4], msgSender);
 			assert.equal(smockExchanger.smocked.exchangeWithVirtual.calls[0][5], trackingCode);
 		});
+
+		it('exchangeWithTrackingForInitiator is called with the right arguments ', async () => {
+			await synthetix.exchangeWithTrackingForInitiator(
+				currencyKey1,
+				amount1,
+				currencyKey2,
+				account2,
+				trackingCode,
+				{ from: account3 }
+			);
+			assert.equal(smockExchanger.smocked.exchangeWithTracking.calls[0][0], account3);
+			assert.equal(smockExchanger.smocked.exchangeWithTracking.calls[0][1], currencyKey1);
+			assert.equal(smockExchanger.smocked.exchangeWithTracking.calls[0][2].toString(), amount1);
+			assert.equal(smockExchanger.smocked.exchangeWithTracking.calls[0][3], currencyKey2);
+			assert.equal(smockExchanger.smocked.exchangeWithTracking.calls[0][4], account3); // destination address (tx.origin)
+			assert.equal(smockExchanger.smocked.exchangeWithTracking.calls[0][5], account2);
+			assert.equal(smockExchanger.smocked.exchangeWithTracking.calls[0][6], trackingCode);
+		});
 	});
 
 	describe('mint() - inflationary supply minting', async () => {
@@ -390,4 +413,58 @@ contract('Synthetix', async accounts => {
 			assert.bnEqual(await synthetix.balanceOf(rewardEscrow.address), 0);
 		});
 	});
+
+	describe('Using a contract to invoke exchangeWithTrackingForInitiator', () => {
+		describe('when a third party contract is setup to exchange synths', () => {
+			let contractExample;
+			let amountOfsUSD;
+			beforeEach(async () => {
+				amountOfsUSD = toUnit('100');
+
+				const MockThirdPartyExchangeContract = artifacts.require('MockThirdPartyExchangeContract');
+
+				// create a contract
+				contractExample = await MockThirdPartyExchangeContract.new(addressResolver.address);
+
+				// ensure rates are set
+				await updateRatesWithDefaults({ exchangeRates, oracle, debtCache });
+
+				// issue sUSD from the owner
+				await synthetix.issueSynths(amountOfsUSD, { from: owner });
+
+				// transfer the sUSD to the contract
+				await sUSDContract.transfer(contractExample.address, toUnit('100'), { from: owner });
+			});
+
+			describe('when Barrie invokes the exchange function on the contract', () => {
+				let txn;
+				beforeEach(async () => {
+					// Barrie has no sETH to start
+					assert.equal(await sETHContract.balanceOf(account3), '0');
+
+					txn = await contractExample.exchange(sUSD, amountOfsUSD, sETH, { from: account3 });
+				});
+				it('then Barrie has the synths in her account', async () => {
+					assert.bnGt(await sETHContract.balanceOf(account3), toUnit('0.01'));
+				});
+				it('and the contract has none', async () => {
+					assert.equal(await sETHContract.balanceOf(contractExample.address), '0');
+				});
+				it('and the event emitted indicates that Barrie was the destinationAddress', async () => {
+					const logs = artifacts.require('Synthetix').decodeLogs(txn.receipt.rawLogs);
+					assert.eventEqual(
+						logs.find(log => log.event === 'SynthExchange'),
+						'SynthExchange',
+						{
+							account: contractExample.address,
+							fromCurrencyKey: sUSD,
+							fromAmount: amountOfsUSD,
+							toCurrencyKey: sETH,
+							toAddress: account3,
+						}
+					);
+				});
+			});
+		});
+	});
 });