Skip to content

Claiming Rewards

SNX stakers (aka minters, aka issuers) get staking rewards each week, in the form of sUSD trading fees and SNX inflationary rewards (see incentives for more information).

In Mintr, this is how they perform the task:

Via the contracts, the process is as follows:

API

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): ProxyFeePool

Underlying contract (ABI): FeePool

Methods

Events Emitted

On a successful transaction, the following events occur:

name emitted on address from address to uint value
Transfer ProxysUSD FEE_ADDRESS to 0x0 amount of sUSD
name emitted on address account uint value
Burned ProxysUSD FEE_ADDRESS amount
name emitted on address from address to uint value
Transfer ProxysUSD 0x0 msg.sender (or user) amount of sUSD
name emitted on address account uint value
Issued ProxysUSD msg.sender (or user) amount of sUSD
name emitted on address beneficiary uint time uint value
VestingEntryCreated RewardEscrow msg.sender
(or user)
now amount of SNX rewards
name emitted on address account uint sUSDAmount uint snxRewards
FeesClaimed ProxyFeePool msg.sender (or user) sUSDAmount snxRewards

Examples from Mainnet

  • ProxyFeePool.claimFees()

  • ProxyFeePool.claimOnBehalf(0xa16de11)


Code Snippets

Claiming

 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
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 {
    // send transaction
    const txn = await snxjs.FeePool.claimFees();

    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
37
38
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 { abi } = synthetix.getSource({
  network,
  contract: 'FeePool',
});
const { address } = synthetix.getTarget({
  network,
  contract: 'ProxyFeePool',
});

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 FeePool = new ethers.Contract(address, abi, signer);

(async () => {
  try {
    // send transaction
    const txn = await FeePool.claimFees();
    // 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
pragma solidity 0.5.16;

import "synthetix/contracts/interfaces/IAddressResolver.sol";
import "synthetix/contracts/interfaces/IFeePool.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 synthetixClaim() external {
      IFeePool feePool = synthetixResolver.getAddress("FeePool");
      require(feePool != address(0), "FeePool is missing from Synthetix resolver");

      // Claim as msg.sender = address(MyContractd)
      feePool.claimFees();
    }

    function synthetixClaimOnBehalf(address user) external {
        IFeePool feePool = synthetixResolver.getAddress("FeePool");
        require(feePool != address(0), "FeePool is missing from Synthetix resolver");

        // Note: this will fail if `DelegateApprovals.approveClaimOnBehalf(address(MyContract))` has
        // not yet been invoked by the `user`
        feePool.claimOnBehalf(user);
    }
}