NoBey/openzeppelin-contracts
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ERC4626 inflation attack mitigation (#3979)

Browse Source 
Co-authored-by: Francisco <fg@frang.io>
This commit is contained in:
Hadrien Croubois
2023-02-17 10:08:31 +01:00
committed by GitHub
parent d5d9d4bd3d
commit d64d7aa5d1
18 changed files with 628 additions and 488 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
test/token/ERC20/extensions/ERC4626.t.sol
View File

@ -15,22 +15,4 @@ contract ERC4626StdTest is ERC4626Test {
_vaultMayBeEmpty = false;
_unlimitedAmount = true;
}
// solhint-disable-next-line func-name-mixedcase
function test_RT_mint_withdraw(ERC4626Test.Init memory init, uint256 shares) public override {
// There is an edge case where we currently behave different than the property tests,
// when all assets are lost to negative yield.
// Sum all initially deposited assets.
int256 initAssets = 0;
for (uint256 i = 0; i < init.share.length; i++) {
vm.assume(init.share[i] <= uint256(type(int256).max - initAssets));
initAssets += SafeCast.toInt256(init.share[i]);
}
// Reject tests where the yield loses all assets from the vault.
vm.assume(init.yield > -initAssets);
super.test_RT_mint_withdraw(init, shares);
}
}

772
test/token/ERC20/extensions/ERC4626.test.js
View File

@ -1,34 +1,16 @@
const { BN, constants, expectEvent, expectRevert } = require('@openzeppelin/test-helpers');
const { constants, expectEvent, expectRevert } = require('@openzeppelin/test-helpers');
const { expect } = require('chai');
const ERC20Decimals = artifacts.require('$ERC20DecimalsMock');
const ERC4626 = artifacts.require('$ERC4626');
const ERC4626Decimals = artifacts.require('$ERC4626DecimalsMock');
const parseToken = token => new BN(token).mul(new BN('1000000000000'));
const parseShare = share => new BN(share).mul(new BN('1000000000000000000'));
const ERC4626OffsetMock = artifacts.require('$ERC4626OffsetMock');
contract('ERC4626', function (accounts) {
const [holder, recipient, spender, other, user1, user2] = accounts;
const name = 'My Token';
const symbol = 'MTKN';
beforeEach(async function () {
this.token = await ERC20Decimals.new(name, symbol, 12);
this.vault = await ERC4626Decimals.new(name + ' Vault', symbol + 'V', this.token.address, 18);
await this.token.$_mint(holder, web3.utils.toWei('100'));
await this.token.approve(this.vault.address, constants.MAX_UINT256, { from: holder });
await this.vault.approve(spender, constants.MAX_UINT256, { from: holder });
});
it('metadata', async function () {
expect(await this.vault.name()).to.be.equal(name + ' Vault');
expect(await this.vault.symbol()).to.be.equal(symbol + 'V');
expect(await this.vault.decimals()).to.be.bignumber.equal('18');
expect(await this.vault.asset()).to.be.equal(this.token.address);
});
const decimals = web3.utils.toBN(18);
it('inherit decimals if from asset', async function () {
for (const decimals of [0, 9, 12, 18, 36].map(web3.utils.toBN)) {
@ -38,372 +20,378 @@ contract('ERC4626', function (accounts) {
}
});
describe('empty vault: no assets & no shares', function () {
it('status', async function () {
expect(await this.vault.totalAssets()).to.be.bignumber.equal('0');
});
for (const offset of [0, 6, 18].map(web3.utils.toBN)) {
const parseToken = token => web3.utils.toBN(10).pow(decimals).muln(token);
const parseShare = share => web3.utils.toBN(10).pow(decimals.add(offset)).muln(share);
it('deposit', async function () {
expect(await this.vault.maxDeposit(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewDeposit(parseToken(1))).to.be.bignumber.equal(parseShare(1));
const virtualAssets = web3.utils.toBN(1);
const virtualShares = web3.utils.toBN(10).pow(offset);
const { tx } = await this.vault.deposit(parseToken(1), recipient, { from: holder });
describe(`offset: ${offset}`, function () {
beforeEach(async function () {
this.token = await ERC20Decimals.new(name, symbol, decimals);
this.vault = await ERC4626OffsetMock.new(name + ' Vault', symbol + 'V', this.token.address, offset);
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: parseToken(1),
await this.token.$_mint(holder, constants.MAX_INT256); // 50% of maximum
await this.token.approve(this.vault.address, constants.MAX_UINT256, { from: holder });
await this.vault.approve(spender, constants.MAX_UINT256, { from: holder });
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: parseShare(1),
it('metadata', async function () {
expect(await this.vault.name()).to.be.equal(name + ' Vault');
expect(await this.vault.symbol()).to.be.equal(symbol + 'V');
expect(await this.vault.decimals()).to.be.bignumber.equal(decimals.add(offset));
expect(await this.vault.asset()).to.be.equal(this.token.address);
});
describe('empty vault: no assets & no shares', function () {
it('status', async function () {
expect(await this.vault.totalAssets()).to.be.bignumber.equal('0');
});
it('deposit', async function () {
expect(await this.vault.maxDeposit(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewDeposit(parseToken(1))).to.be.bignumber.equal(parseShare(1));
const { tx } = await this.vault.deposit(parseToken(1), recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: parseToken(1),
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: parseShare(1),
});
});
it('mint', async function () {
expect(await this.vault.maxMint(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewMint(parseShare(1))).to.be.bignumber.equal(parseToken(1));
const { tx } = await this.vault.mint(parseShare(1), recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: parseToken(1),
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: parseShare(1),
});
});
it('withdraw', async function () {
expect(await this.vault.maxWithdraw(holder)).to.be.bignumber.equal('0');
expect(await this.vault.previewWithdraw('0')).to.be.bignumber.equal('0');
const { tx } = await this.vault.withdraw('0', recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: '0',
});
});
it('redeem', async function () {
expect(await this.vault.maxRedeem(holder)).to.be.bignumber.equal('0');
expect(await this.vault.previewRedeem('0')).to.be.bignumber.equal('0');
const { tx } = await this.vault.redeem('0', recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: '0',
});
});
});
describe('inflation attack: offset price by direct deposit of assets', function () {
beforeEach(async function () {
// Donate 1 token to the vault to offset the price
await this.token.$_mint(this.vault.address, parseToken(1));
});
it('status', async function () {
expect(await this.vault.totalSupply()).to.be.bignumber.equal('0');
expect(await this.vault.totalAssets()).to.be.bignumber.equal(parseToken(1));
});
/**
* | offset | deposited assets | redeemable assets |
* |--------|----------------------|----------------------|
* | 0 | 1.000000000000000000 | 0. |
* | 6 | 1.000000000000000000 | 0.999999000000000000 |
* | 18 | 1.000000000000000000 | 0.999999999999999999 |
*
* Attack is possible, but made difficult by the offset. For the attack to be successful
* the attacker needs to frontrun a deposit 10**offset times bigger than what the victim
* was trying to deposit
*/
it('deposit', async function () {
const effectiveAssets = await this.vault.totalAssets().then(x => x.add(virtualAssets));
const effectiveShares = await this.vault.totalSupply().then(x => x.add(virtualShares));
const depositAssets = parseToken(1);
const expectedShares = depositAssets.mul(effectiveShares).div(effectiveAssets);
expect(await this.vault.maxDeposit(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewDeposit(depositAssets)).to.be.bignumber.equal(expectedShares);
const { tx } = await this.vault.deposit(depositAssets, recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: depositAssets,
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: expectedShares,
});
});
/**
* | offset | deposited assets | redeemable assets |
* |--------|----------------------|----------------------|
* | 0 | 1000000000000000001. | 1000000000000000001. |
* | 6 | 1000000000000000001. | 1000000000000000001. |
* | 18 | 1000000000000000001. | 1000000000000000001. |
*
* Using mint protects against inflation attack, but makes minting shares very expensive.
* The ER20 allowance for the underlying asset is needed to protect the user from (too)
* large deposits.
*/
it('mint', async function () {
const effectiveAssets = await this.vault.totalAssets().then(x => x.add(virtualAssets));
const effectiveShares = await this.vault.totalSupply().then(x => x.add(virtualShares));
const mintShares = parseShare(1);
const expectedAssets = mintShares.mul(effectiveAssets).div(effectiveShares);
expect(await this.vault.maxMint(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewMint(mintShares)).to.be.bignumber.equal(expectedAssets);
const { tx } = await this.vault.mint(mintShares, recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: expectedAssets,
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: mintShares,
});
});
it('withdraw', async function () {
expect(await this.vault.maxWithdraw(holder)).to.be.bignumber.equal('0');
expect(await this.vault.previewWithdraw('0')).to.be.bignumber.equal('0');
const { tx } = await this.vault.withdraw('0', recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: '0',
});
});
it('redeem', async function () {
expect(await this.vault.maxRedeem(holder)).to.be.bignumber.equal('0');
expect(await this.vault.previewRedeem('0')).to.be.bignumber.equal('0');
const { tx } = await this.vault.redeem('0', recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: '0',
});
});
});
describe('full vault: assets & shares', function () {
beforeEach(async function () {
// Add 1 token of underlying asset and 100 shares to the vault
await this.token.$_mint(this.vault.address, parseToken(1));
await this.vault.$_mint(holder, parseShare(100));
});
it('status', async function () {
expect(await this.vault.totalSupply()).to.be.bignumber.equal(parseShare(100));
expect(await this.vault.totalAssets()).to.be.bignumber.equal(parseToken(1));
});
/**
* | offset | deposited assets | redeemable assets |
* |--------|--------------------- |----------------------|
* | 0 | 1.000000000000000000 | 0.999999999999999999 |
* | 6 | 1.000000000000000000 | 0.999999999999999999 |
* | 18 | 1.000000000000000000 | 0.999999999999999999 |
*
* Virtual shares & assets captures part of the value
*/
it('deposit', async function () {
const effectiveAssets = await this.vault.totalAssets().then(x => x.add(virtualAssets));
const effectiveShares = await this.vault.totalSupply().then(x => x.add(virtualShares));
const depositAssets = parseToken(1);
const expectedShares = depositAssets.mul(effectiveShares).div(effectiveAssets);
expect(await this.vault.maxDeposit(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewDeposit(depositAssets)).to.be.bignumber.equal(expectedShares);
const { tx } = await this.vault.deposit(depositAssets, recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: depositAssets,
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: expectedShares,
});
});
/**
* | offset | deposited assets | redeemable assets |
* |--------|--------------------- |----------------------|
* | 0 | 0.010000000000000001 | 0.010000000000000000 |
* | 6 | 0.010000000000000001 | 0.010000000000000000 |
* | 18 | 0.010000000000000001 | 0.010000000000000000 |
*
* Virtual shares & assets captures part of the value
*/
it('mint', async function () {
const effectiveAssets = await this.vault.totalAssets().then(x => x.add(virtualAssets));
const effectiveShares = await this.vault.totalSupply().then(x => x.add(virtualShares));
const mintShares = parseShare(1);
const expectedAssets = mintShares.mul(effectiveAssets).div(effectiveShares).addn(1); // add for the rounding
expect(await this.vault.maxMint(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewMint(mintShares)).to.be.bignumber.equal(expectedAssets);
const { tx } = await this.vault.mint(mintShares, recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: expectedAssets,
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: mintShares,
});
});
it('withdraw', async function () {
const effectiveAssets = await this.vault.totalAssets().then(x => x.add(virtualAssets));
const effectiveShares = await this.vault.totalSupply().then(x => x.add(virtualShares));
const withdrawAssets = parseToken(1);
const expectedShares = withdrawAssets.mul(effectiveShares).div(effectiveAssets).addn(1); // add for the rounding
expect(await this.vault.maxWithdraw(holder)).to.be.bignumber.equal(withdrawAssets);
expect(await this.vault.previewWithdraw(withdrawAssets)).to.be.bignumber.equal(expectedShares);
const { tx } = await this.vault.withdraw(withdrawAssets, recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: withdrawAssets,
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: expectedShares,
});
});
it('withdraw with approval', async function () {
await expectRevert(
this.vault.withdraw(parseToken(1), recipient, holder, { from: other }),
'ERC20: insufficient allowance',
);
await this.vault.withdraw(parseToken(1), recipient, holder, { from: spender });
});
it('redeem', async function () {
expect(await this.vault.maxRedeem(holder)).to.be.bignumber.equal(parseShare(100));
expect(await this.vault.previewRedeem(parseShare(100))).to.be.bignumber.equal(parseToken(1));
const { tx } = await this.vault.redeem(parseShare(100), recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: parseToken(1),
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: parseShare(100),
});
});
it('redeem with approval', async function () {
await expectRevert(
this.vault.redeem(parseShare(100), recipient, holder, { from: other }),
'ERC20: insufficient allowance',
);
await this.vault.redeem(parseShare(100), recipient, holder, { from: spender });
});
});
});
it('mint', async function () {
expect(await this.vault.maxMint(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewMint(parseShare(1))).to.be.bignumber.equal(parseToken(1));
const { tx } = await this.vault.mint(parseShare(1), recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: parseToken(1),
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: parseShare(1),
});
});
it('withdraw', async function () {
expect(await this.vault.maxWithdraw(holder)).to.be.bignumber.equal('0');
expect(await this.vault.previewWithdraw('0')).to.be.bignumber.equal('0');
const { tx } = await this.vault.withdraw('0', recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: '0',
});
});
it('redeem', async function () {
expect(await this.vault.maxRedeem(holder)).to.be.bignumber.equal('0');
expect(await this.vault.previewRedeem('0')).to.be.bignumber.equal('0');
const { tx } = await this.vault.redeem('0', recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: '0',
});
});
});
describe('partially empty vault: assets & no shares', function () {
beforeEach(async function () {
await this.token.$_mint(this.vault.address, parseToken(1)); // 1 token
});
it('status', async function () {
expect(await this.vault.totalAssets()).to.be.bignumber.equal(parseToken(1));
});
it('deposit', async function () {
expect(await this.vault.maxDeposit(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewDeposit(parseToken(1))).to.be.bignumber.equal(parseShare(1));
const { tx } = await this.vault.deposit(parseToken(1), recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: parseToken(1),
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: parseShare(1),
});
});
it('mint', async function () {
expect(await this.vault.maxMint(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewMint(parseShare(1))).to.be.bignumber.equal(parseToken(1));
const { tx } = await this.vault.mint(parseShare(1), recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: parseToken(1),
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: parseShare(1),
});
});
it('withdraw', async function () {
expect(await this.vault.maxWithdraw(holder)).to.be.bignumber.equal('0');
expect(await this.vault.previewWithdraw('0')).to.be.bignumber.equal('0');
const { tx } = await this.vault.withdraw('0', recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: '0',
});
});
it('redeem', async function () {
expect(await this.vault.maxRedeem(holder)).to.be.bignumber.equal('0');
expect(await this.vault.previewRedeem('0')).to.be.bignumber.equal('0');
const { tx } = await this.vault.redeem('0', recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: '0',
});
});
});
describe('partially empty vault: shares & no assets', function () {
beforeEach(async function () {
await this.vault.$_mint(holder, parseShare(1)); // 1 share
});
it('status', async function () {
expect(await this.vault.totalAssets()).to.be.bignumber.equal('0');
});
it('deposit', async function () {
expect(await this.vault.maxDeposit(holder)).to.be.bignumber.equal('0');
// Can deposit 0 (max deposit)
const { tx } = await this.vault.deposit(0, recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: '0',
});
// Cannot deposit more than 0
await expectRevert.unspecified(this.vault.previewDeposit(parseToken(1)));
await expectRevert(
this.vault.deposit(parseToken(1), recipient, { from: holder }),
'ERC4626: deposit more than max',
);
});
it('mint', async function () {
expect(await this.vault.maxMint(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewMint(parseShare(1))).to.be.bignumber.equal('0');
const { tx } = await this.vault.mint(parseShare(1), recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: parseShare(1),
});
});
it('withdraw', async function () {
expect(await this.vault.maxWithdraw(holder)).to.be.bignumber.equal('0');
expect(await this.vault.previewWithdraw('0')).to.be.bignumber.equal('0');
await expectRevert.unspecified(this.vault.previewWithdraw('1'));
const { tx } = await this.vault.withdraw('0', recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: '0',
});
});
it('redeem', async function () {
expect(await this.vault.maxRedeem(holder)).to.be.bignumber.equal(parseShare(1));
expect(await this.vault.previewRedeem(parseShare(1))).to.be.bignumber.equal('0');
const { tx } = await this.vault.redeem(parseShare(1), recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: '0',
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: parseShare(1),
});
});
});
describe('full vault: assets & shares', function () {
beforeEach(async function () {
await this.token.$_mint(this.vault.address, parseToken(1)); // 1 tokens
await this.vault.$_mint(holder, parseShare(100)); // 100 share
});
it('status', async function () {
expect(await this.vault.totalAssets()).to.be.bignumber.equal(parseToken(1));
});
it('deposit', async function () {
expect(await this.vault.maxDeposit(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewDeposit(parseToken(1))).to.be.bignumber.equal(parseShare(100));
const { tx } = await this.vault.deposit(parseToken(1), recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: parseToken(1),
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: parseShare(100),
});
});
it('mint', async function () {
expect(await this.vault.maxMint(holder)).to.be.bignumber.equal(constants.MAX_UINT256);
expect(await this.vault.previewMint(parseShare(1))).to.be.bignumber.equal(parseToken(1).divn(100));
const { tx } = await this.vault.mint(parseShare(1), recipient, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: holder,
to: this.vault.address,
value: parseToken(1).divn(100),
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
to: recipient,
value: parseShare(1),
});
});
it('withdraw', async function () {
expect(await this.vault.maxWithdraw(holder)).to.be.bignumber.equal(parseToken(1));
expect(await this.vault.previewWithdraw(parseToken(1))).to.be.bignumber.equal(parseShare(100));
const { tx } = await this.vault.withdraw(parseToken(1), recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: parseToken(1),
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: parseShare(100),
});
});
it('withdraw with approval', async function () {
await expectRevert(
this.vault.withdraw(parseToken(1), recipient, holder, { from: other }),
'ERC20: insufficient allowance',
);
await this.vault.withdraw(parseToken(1), recipient, holder, { from: spender });
});
it('redeem', async function () {
expect(await this.vault.maxRedeem(holder)).to.be.bignumber.equal(parseShare(100));
expect(await this.vault.previewRedeem(parseShare(100))).to.be.bignumber.equal(parseToken(1));
const { tx } = await this.vault.redeem(parseShare(100), recipient, holder, { from: holder });
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: recipient,
value: parseToken(1),
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: holder,
to: constants.ZERO_ADDRESS,
value: parseShare(100),
});
});
it('redeem with approval', async function () {
await expectRevert(
this.vault.redeem(parseShare(100), recipient, holder, { from: other }),
'ERC20: insufficient allowance',
);
await this.vault.redeem(parseShare(100), recipient, holder, { from: spender });
});
});
}
/// Scenario inspired by solmate ERC4626 tests:
/// https://github.com/transmissions11/solmate/blob/main/src/test/ERC4626.t.sol
@ -468,8 +456,8 @@ contract('ERC4626', function (accounts) {
expect(await this.vault.balanceOf(user1)).to.be.bignumber.equal('2000');
expect(await this.vault.balanceOf(user2)).to.be.bignumber.equal('4000');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user1))).to.be.bignumber.equal('3000');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user2))).to.be.bignumber.equal('6000');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user1))).to.be.bignumber.equal('2999'); // used to be 3000, but virtual assets/shares captures part of the yield
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user2))).to.be.bignumber.equal('5999'); // used to be 6000, but virtual assets/shares captures part of the yield
expect(await this.vault.totalSupply()).to.be.bignumber.equal('6000');
expect(await this.vault.totalAssets()).to.be.bignumber.equal('9000');
@ -503,7 +491,7 @@ contract('ERC4626', function (accounts) {
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: user2,
to: this.vault.address,
value: '3001',
value: '3000', // used to be 3001
});
await expectEvent.inTransaction(tx, this.vault, 'Transfer', {
from: constants.ZERO_ADDRESS,
@ -513,10 +501,10 @@ contract('ERC4626', function (accounts) {
expect(await this.vault.balanceOf(user1)).to.be.bignumber.equal('3333');
expect(await this.vault.balanceOf(user2)).to.be.bignumber.equal('6000');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user1))).to.be.bignumber.equal('5000');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user1))).to.be.bignumber.equal('4999'); // used to be 5000
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user2))).to.be.bignumber.equal('9000');
expect(await this.vault.totalSupply()).to.be.bignumber.equal('9333');
expect(await this.vault.totalAssets()).to.be.bignumber.equal('14001');
expect(await this.vault.totalAssets()).to.be.bignumber.equal('14000'); // used to be 14001
}
// 6. Vault mutates by +3000 tokens
@ -525,10 +513,10 @@ contract('ERC4626', function (accounts) {
expect(await this.vault.balanceOf(user1)).to.be.bignumber.equal('3333');
expect(await this.vault.balanceOf(user2)).to.be.bignumber.equal('6000');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user1))).to.be.bignumber.equal('6071');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user2))).to.be.bignumber.equal('10929');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user1))).to.be.bignumber.equal('6070'); // used to be 6071
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user2))).to.be.bignumber.equal('10928'); // used to be 10929
expect(await this.vault.totalSupply()).to.be.bignumber.equal('9333');
expect(await this.vault.totalAssets()).to.be.bignumber.equal('17001');
expect(await this.vault.totalAssets()).to.be.bignumber.equal('17000'); // used to be 17001
// 7. Alice redeem 1333 shares (2428 assets)
{
@ -541,7 +529,7 @@ contract('ERC4626', function (accounts) {
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: user1,
value: '2428',
value: '2427', // used to be 2428
});
expect(await this.vault.balanceOf(user1)).to.be.bignumber.equal('2000');
@ -592,7 +580,7 @@ contract('ERC4626', function (accounts) {
expect(await this.vault.balanceOf(user1)).to.be.bignumber.equal('0');
expect(await this.vault.balanceOf(user2)).to.be.bignumber.equal('4392');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user1))).to.be.bignumber.equal('0');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user2))).to.be.bignumber.equal('8001');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user2))).to.be.bignumber.equal('8000'); // used to be 8001
expect(await this.vault.totalSupply()).to.be.bignumber.equal('4392');
expect(await this.vault.totalAssets()).to.be.bignumber.equal('8001');
}
@ -608,7 +596,7 @@ contract('ERC4626', function (accounts) {
await expectEvent.inTransaction(tx, this.token, 'Transfer', {
from: this.vault.address,
to: user2,
value: '8001',
value: '8000', // used to be 8001
});
expect(await this.vault.balanceOf(user1)).to.be.bignumber.equal('0');
@ -616,7 +604,7 @@ contract('ERC4626', function (accounts) {
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user1))).to.be.bignumber.equal('0');
expect(await this.vault.convertToAssets(await this.vault.balanceOf(user2))).to.be.bignumber.equal('0');
expect(await this.vault.totalSupply()).to.be.bignumber.equal('0');
expect(await this.vault.totalAssets()).to.be.bignumber.equal('0');
expect(await this.vault.totalAssets()).to.be.bignumber.equal('1'); // used to be 0
}
});
});