Skip to content

Unstaking: Closing a Position

In order to close their position, SNX stakers need to burn enough sUSD to cover their debt position (Synthetix.debtBalanceOf(user, "sUSD")).

Via the contracts, the process is as follows:

Burning API

To burn sUSD in Mintr, this is how they perform the task:

Contract

Use the Proxies

Note: The transaction's to parameter can be to either the proxy or the underlying, however two things are worth noting:

  1. the underlying is subject to change (and does most releases); and
  2. the events will always be emitted on the proxy, regardless of the to parameter in the transaction.

For best results, always interact with the proxy using the ABI of the underlying.

Destination contract (address): ProxyERC20 (preferred) or ProxySynthetix (deprecated, see this notice)

Target contract (ABI): Synthetix

Methods

Events Emitted

On a successful transaction, the following events occur:

name emitted on address from address to uint value
Transfer ProxysUSD msg.sender (or user) 0x0 amount of sUSD
name emitted on address account uint value
Burned ProxysUSD msg.sender (or user) amount
name emitted on address account uint debtRatio uint debtEntryIndex uint feePeriodStartingDebtIndex
IssuanceDebtRatioEntry FeePool msg.sender (or user) debtRatio debtEntryIndex feePeriodStartingDebtIndex

Examples from Mainnet

  • ProxySynthetix.burnSynths(3e18)

  • ProxySynthetix.burnSynthsToTargetOnBehalf(0x3bf10de)


Code Snippets

Unstaking (burning)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
const { SynthetixJs } = require('synthetix-js');
const privateKey = '0x' + '1'.repeat(64); // don't actually put a private key in code obviously

// parameters: default provider, default networkId, private key as a string
const networkId = 3; // ropsten, (use 1 for mainnet)
const signer = new SynthetixJs.signers.PrivateKey(null, networkId, privateKey);
const snxjs = new SynthetixJs({ signer, networkId });

(async () => {
    try {
        // get debt owing
        const debt = await snxjs.Synthetix.debtBalanceOf(signer.address, snxjs.utils.toUtf8Bytes32('sUSD'));

        // burn all debt owing
        const txn = await snxjs.Synthetix.burnSynths(debt);

        console.log('hash is mining', txn.hash);

        // wait for mining
        await txn.wait();

        // fetch logs of transaction
        const { logs } = await signer.provider.getTransactionReceipt(txn.hash);

        // show them
        console.log(JSON.stringify(logs, null, '\t'));
    } catch (err) {
        console.log('Error', err);
    }
})();
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
const synthetix = require('synthetix'); // nodejs
const ethers = require('ethers'); // nodejs
// or using ES modules:
// import synthetix from 'synthetix';
// import ethers from 'ethers';

const network = 'ropsten';
const provider = ethers.getDefaultProvider(network === 'mainnet' ? 'homestead' : network);

const { address } = synthetix.getTarget({ network, contract: 'ProxyERC20' });
const { abi } = synthetix.getSource({ network, contract: 'Synthetix' });

const privateKey = '0x' + '1'.repeat(64); // don't actually put a private key in code obviously
const signer = new ethers.Wallet(privateKey).connect(provider);

// see https://docs.ethers.io/ethers.js/html/api-contract.html#connecting-to-existing-contracts
const Synthetix = new ethers.Contract(address, abi, signer);

(async () => {
try {

    const debt = await Synthetix.debtBalanceOf(signer.address, synthetix.toBytes32('sUSD'));

    // burn all debt owing
    const txn = await Synthetix.burnSynths(debt);

    // wait for mining
    await txn.wait();
    // fetch logs of transaction
    const { logs } = await provider.getTransactionReceipt(txn.hash);
    // display
    console.log(JSON.stringify(logs, null, '\t'));
} catch (err) {
    console.log('Error', err);
}
})();
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
pragma solidity 0.5.16;

import "synthetix/contracts/interfaces/IAddressResolver.sol";
import "synthetix/contracts/interfaces/ISynthetix.sol";


contract MyContract {

    // This should be instantiated with our ReadProxyAddressResolver
    // it's a ReadProxy that won't change, so safe to code it here without a setter
    // see https://docs.synthetix.io/addresses for addresses in mainnet and testnets
    IAddressResolver public synthetixResolver;

    constructor(IAddressResolver _snxResolver) public {
        synthetixResolver = _snxResolver;
    }

    function synthetixBurn() external {
        ISynthetix synthetix = synthetixResolver.getAddress("Synthetix");
        require(synthetix != address(0), "Synthetix is missing from Synthetix resolver");

        uint debt = synthetix.debtBalanceOf(msg.sender, "sUSD");

        // Burn for msg.sender = address(MyContract)
        synthetix.burnSynths(debt);
    }

    function synthetixBurnOnBehalf(address user) external {
        ISynthetix synthetix = synthetixResolver.getAddress("Synthetix");
        require(synthetix != address(0), "Synthetix is missing from Synthetix resolver");

        uint debt = synthetix.debtBalanceOf(user, "sUSD");

        // Note: this will fail if `DelegateApprovals.approveBurnOnBehalf(address(MyContract))` has
        // not yet been invoked by the `user`
        synthetix.burnSynthsOnBehalf(user, debt);
    }
}