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

Migrate address to ethersjs (#4739)

Browse Source 
Co-authored-by: Hadrien Croubois <hadrien.croubois@gmail.com>
Co-authored-by: ernestognw <ernestognw@gmail.com>
This commit is contained in:
Renan Souza
2023-11-23 04:52:44 +00:00
committed by GitHub
parent 6a56b3b08d
commit bf75bccaea
1 changed files with 139 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

332
test/utils/Address.test.js
View File

@ -1,333 +1,279 @@
const { balance, constants, ether, expectRevert, send, expectEvent } = require('@openzeppelin/test-helpers'); const { ethers } = require('hardhat');
const { expect } = require('chai'); const { expect } = require('chai');
const { expectRevertCustomError } = require('../helpers/customError'); const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic');
const Address = artifacts.require('$Address'); const coder = ethers.AbiCoder.defaultAbiCoder();
const EtherReceiver = artifacts.require('EtherReceiverMock');
const CallReceiverMock = artifacts.require('CallReceiverMock');
contract('Address', function (accounts) { async function fixture() {
const [recipient, other] = accounts; const [recipient, other] = await ethers.getSigners();
const mock = await ethers.deployContract('$Address');
const target = await ethers.deployContract('CallReceiverMock');
const targetEther = await ethers.deployContract('EtherReceiverMock');
return { recipient, other, mock, target, targetEther };
}
describe('Address', function () {
beforeEach(async function () { beforeEach(async function () {
this.mock = await Address.new(); Object.assign(this, await loadFixture(fixture));
}); });
describe('sendValue', function () { describe('sendValue', function () {
beforeEach(async function () { describe('when sender contract has no funds', function () {
this.recipientTracker = await balance.tracker(recipient);
});
context('when sender contract has no funds', function () {
it('sends 0 wei', async function () { it('sends 0 wei', async function () {
await this.mock.$sendValue(other, 0); await expect(this.mock.$sendValue(this.other, 0)).to.changeEtherBalance(this.recipient, 0);
expect(await this.recipientTracker.delta()).to.be.bignumber.equal('0');
}); });
it('reverts when sending non-zero amounts', async function () { it('reverts when sending non-zero amounts', async function () {
await expectRevertCustomError(this.mock.$sendValue(other, 1), 'AddressInsufficientBalance', [ await expect(this.mock.$sendValue(this.other, 1))
this.mock.address, .to.be.revertedWithCustomError(this.mock, 'AddressInsufficientBalance')
]); .withArgs(this.mock.target);
}); });
}); });
context('when sender contract has funds', function () { describe('when sender contract has funds', function () {
const funds = ether('1'); const funds = ethers.parseEther('1');
beforeEach(async function () { beforeEach(async function () {
await send.ether(other, this.mock.address, funds); await this.other.sendTransaction({ to: this.mock, value: funds });
}); });
it('sends 0 wei', async function () { describe('with EOA recipient', function () {
await this.mock.$sendValue(recipient, 0); it('sends 0 wei', async function () {
expect(await this.recipientTracker.delta()).to.be.bignumber.equal('0'); await expect(this.mock.$sendValue(this.recipient, 0)).to.changeEtherBalance(this.recipient.address, 0);
});
it('sends non-zero amounts', async function () {
await this.mock.$sendValue(recipient, funds.subn(1));
expect(await this.recipientTracker.delta()).to.be.bignumber.equal(funds.subn(1));
});
it('sends the whole balance', async function () {
await this.mock.$sendValue(recipient, funds);
expect(await this.recipientTracker.delta()).to.be.bignumber.equal(funds);
expect(await balance.current(this.mock.address)).to.be.bignumber.equal('0');
});
it('reverts when sending more than the balance', async function () {
await expectRevertCustomError(this.mock.$sendValue(recipient, funds.addn(1)), 'AddressInsufficientBalance', [
this.mock.address,
]);
});
context('with contract recipient', function () {
beforeEach(async function () {
this.target = await EtherReceiver.new();
}); });
it('sends non-zero amounts', async function () {
await expect(this.mock.$sendValue(this.recipient, funds - 1n)).to.changeEtherBalance(
this.recipient,
funds - 1n,
);
});
it('sends the whole balance', async function () {
await expect(this.mock.$sendValue(this.recipient, funds)).to.changeEtherBalance(this.recipient, funds);
expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
});
it('reverts when sending more than the balance', async function () {
await expect(this.mock.$sendValue(this.recipient, funds + 1n))
.to.be.revertedWithCustomError(this.mock, 'AddressInsufficientBalance')
.withArgs(this.mock.target);
});
});
describe('with contract recipient', function () {
it('sends funds', async function () { it('sends funds', async function () {
const tracker = await balance.tracker(this.target.address); await this.targetEther.setAcceptEther(true);
await expect(this.mock.$sendValue(this.targetEther, funds)).to.changeEtherBalance(this.targetEther, funds);
await this.target.setAcceptEther(true);
await this.mock.$sendValue(this.target.address, funds);
expect(await tracker.delta()).to.be.bignumber.equal(funds);
}); });
it('reverts on recipient revert', async function () { it('reverts on recipient revert', async function () {
await this.target.setAcceptEther(false); await this.targetEther.setAcceptEther(false);
await expectRevertCustomError(this.mock.$sendValue(this.target.address, funds), 'FailedInnerCall', []); await expect(this.mock.$sendValue(this.targetEther, funds)).to.be.revertedWithCustomError(
this.mock,
'FailedInnerCall',
);
}); });
}); });
}); });
}); });
describe('functionCall', function () { describe('functionCall', function () {
beforeEach(async function () { describe('with valid contract receiver', function () {
this.target = await CallReceiverMock.new();
});
context('with valid contract receiver', function () {
it('calls the requested function', async function () { it('calls the requested function', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunction');
const receipt = await this.mock.$functionCall(this.target.address, abiEncodedCall); await expect(this.mock.$functionCall(this.target, call))
.to.emit(this.target, 'MockFunctionCalled')
expectEvent(receipt, 'return$functionCall', { .to.emit(this.mock, 'return$functionCall')
ret0: web3.eth.abi.encodeParameters(['string'], ['0x1234']), .withArgs(coder.encode(['string'], ['0x1234']));
});
await expectEvent.inTransaction(receipt.tx, CallReceiverMock, 'MockFunctionCalled');
}); });
it('calls the requested empty return function', async function () { it('calls the requested empty return function', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunctionEmptyReturn().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunctionEmptyReturn');
const receipt = await this.mock.$functionCall(this.target.address, abiEncodedCall); await expect(this.mock.$functionCall(this.target, call)).to.emit(this.target, 'MockFunctionCalled');
await expectEvent.inTransaction(receipt.tx, CallReceiverMock, 'MockFunctionCalled');
}); });
it('reverts when the called function reverts with no reason', async function () { it('reverts when the called function reverts with no reason', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunctionRevertsNoReason().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunctionRevertsNoReason');
await expectRevertCustomError( await expect(this.mock.$functionCall(this.target, call)).to.be.revertedWithCustomError(
this.mock.$functionCall(this.target.address, abiEncodedCall), this.mock,
'FailedInnerCall', 'FailedInnerCall',
[],
); );
}); });
it('reverts when the called function reverts, bubbling up the revert reason', async function () { it('reverts when the called function reverts, bubbling up the revert reason', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunctionRevertsReason().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunctionRevertsReason');
await expectRevert(this.mock.$functionCall(this.target.address, abiEncodedCall), 'CallReceiverMock: reverting'); await expect(this.mock.$functionCall(this.target, call)).to.be.revertedWith('CallReceiverMock: reverting');
}); });
it('reverts when the called function runs out of gas', async function () { it('reverts when the called function runs out of gas', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunctionOutOfGas().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunctionOutOfGas');
await expectRevertCustomError( await expect(this.mock.$functionCall(this.target, call, { gasLimit: 120_000n })).to.be.revertedWithCustomError(
this.mock.$functionCall(this.target.address, abiEncodedCall, { gas: '120000' }), this.mock,
'FailedInnerCall', 'FailedInnerCall',
[],
); );
}); });
it('reverts when the called function throws', async function () { it('reverts when the called function throws', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunctionThrows().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunctionThrows');
await expectRevert.unspecified(this.mock.$functionCall(this.target.address, abiEncodedCall)); await expect(this.mock.$functionCall(this.target, call)).to.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR);
}); });
it('reverts when function does not exist', async function () { it('reverts when function does not exist', async function () {
const abiEncodedCall = web3.eth.abi.encodeFunctionCall( const interface = new ethers.Interface(['function mockFunctionDoesNotExist()']);
{ const call = interface.encodeFunctionData('mockFunctionDoesNotExist');
name: 'mockFunctionDoesNotExist',
type: 'function',
inputs: [],
},
[],
);
await expectRevertCustomError( await expect(this.mock.$functionCall(this.target, call)).to.be.revertedWithCustomError(
this.mock.$functionCall(this.target.address, abiEncodedCall), this.mock,
'FailedInnerCall', 'FailedInnerCall',
[],
); );
}); });
}); });
context('with non-contract receiver', function () { describe('with non-contract receiver', function () {
it('reverts when address is not a contract', async function () { it('reverts when address is not a contract', async function () {
const [recipient] = accounts; const call = this.target.interface.encodeFunctionData('mockFunction');
const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
await expectRevertCustomError(this.mock.$functionCall(recipient, abiEncodedCall), 'AddressEmptyCode', [ await expect(this.mock.$functionCall(this.recipient, call))
recipient, .to.be.revertedWithCustomError(this.mock, 'AddressEmptyCode')
]); .withArgs(this.recipient.address);
}); });
}); });
}); });
describe('functionCallWithValue', function () { describe('functionCallWithValue', function () {
beforeEach(async function () { describe('with zero value', function () {
this.target = await CallReceiverMock.new();
});
context('with zero value', function () {
it('calls the requested function', async function () { it('calls the requested function', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunction');
const receipt = await this.mock.$functionCallWithValue(this.target.address, abiEncodedCall, 0); await expect(this.mock.$functionCallWithValue(this.target, call, 0))
expectEvent(receipt, 'return$functionCallWithValue', { .to.emit(this.target, 'MockFunctionCalled')
ret0: web3.eth.abi.encodeParameters(['string'], ['0x1234']), .to.emit(this.mock, 'return$functionCallWithValue')
}); .withArgs(coder.encode(['string'], ['0x1234']));
await expectEvent.inTransaction(receipt.tx, CallReceiverMock, 'MockFunctionCalled');
}); });
}); });
context('with non-zero value', function () { describe('with non-zero value', function () {
const amount = ether('1.2'); const value = ethers.parseEther('1.2');
it('reverts if insufficient sender balance', async function () { it('reverts if insufficient sender balance', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunction');
await expectRevertCustomError( await expect(this.mock.$functionCallWithValue(this.target, call, value))
this.mock.$functionCallWithValue(this.target.address, abiEncodedCall, amount), .to.be.revertedWithCustomError(this.mock, 'AddressInsufficientBalance')
'AddressInsufficientBalance', .withArgs(this.mock.target);
[this.mock.address],
);
}); });
it('calls the requested function with existing value', async function () { it('calls the requested function with existing value', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI(); await this.other.sendTransaction({ to: this.mock, value });
const tracker = await balance.tracker(this.target.address); const call = this.target.interface.encodeFunctionData('mockFunction');
const tx = await this.mock.$functionCallWithValue(this.target, call, value);
await send.ether(other, this.mock.address, amount); await expect(tx).to.changeEtherBalance(this.target, value);
const receipt = await this.mock.$functionCallWithValue(this.target.address, abiEncodedCall, amount); await expect(tx)
expectEvent(receipt, 'return$functionCallWithValue', { .to.emit(this.target, 'MockFunctionCalled')
ret0: web3.eth.abi.encodeParameters(['string'], ['0x1234']), .to.emit(this.mock, 'return$functionCallWithValue')
}); .withArgs(coder.encode(['string'], ['0x1234']));
await expectEvent.inTransaction(receipt.tx, CallReceiverMock, 'MockFunctionCalled');
expect(await tracker.delta()).to.be.bignumber.equal(amount);
}); });
it('calls the requested function with transaction funds', async function () { it('calls the requested function with transaction funds', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI(); expect(await ethers.provider.getBalance(this.mock)).to.equal(0n);
const tracker = await balance.tracker(this.target.address); const call = this.target.interface.encodeFunctionData('mockFunction');
const tx = await this.mock.connect(this.other).$functionCallWithValue(this.target, call, value, { value });
expect(await balance.current(this.mock.address)).to.be.bignumber.equal('0'); await expect(tx).to.changeEtherBalance(this.target, value);
await expect(tx)
const receipt = await this.mock.$functionCallWithValue(this.target.address, abiEncodedCall, amount, { .to.emit(this.target, 'MockFunctionCalled')
from: other, .to.emit(this.mock, 'return$functionCallWithValue')
value: amount, .withArgs(coder.encode(['string'], ['0x1234']));
});
expectEvent(receipt, 'return$functionCallWithValue', {
ret0: web3.eth.abi.encodeParameters(['string'], ['0x1234']),
});
await expectEvent.inTransaction(receipt.tx, CallReceiverMock, 'MockFunctionCalled');
expect(await tracker.delta()).to.be.bignumber.equal(amount);
}); });
it('reverts when calling non-payable functions', async function () { it('reverts when calling non-payable functions', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunctionNonPayable().encodeABI(); await this.other.sendTransaction({ to: this.mock, value });
await send.ether(other, this.mock.address, amount); const call = this.target.interface.encodeFunctionData('mockFunctionNonPayable');
await expectRevertCustomError(
this.mock.$functionCallWithValue(this.target.address, abiEncodedCall, amount), await expect(this.mock.$functionCallWithValue(this.target, call, value)).to.be.revertedWithCustomError(
this.mock,
'FailedInnerCall', 'FailedInnerCall',
[],
); );
}); });
}); });
}); });
describe('functionStaticCall', function () { describe('functionStaticCall', function () {
beforeEach(async function () {
this.target = await CallReceiverMock.new();
});
it('calls the requested function', async function () { it('calls the requested function', async function () {
const abiEncodedCall = this.target.contract.methods.mockStaticFunction().encodeABI(); const call = this.target.interface.encodeFunctionData('mockStaticFunction');
expect(await this.mock.$functionStaticCall(this.target.address, abiEncodedCall)).to.be.equal( expect(await this.mock.$functionStaticCall(this.target, call)).to.equal(coder.encode(['string'], ['0x1234']));
web3.eth.abi.encodeParameters(['string'], ['0x1234']),
);
}); });
it('reverts on a non-static function', async function () { it('reverts on a non-static function', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunction');
await expectRevertCustomError( await expect(this.mock.$functionStaticCall(this.target, call)).to.be.revertedWithCustomError(
this.mock.$functionStaticCall(this.target.address, abiEncodedCall), this.mock,
'FailedInnerCall', 'FailedInnerCall',
[],
); );
}); });
it('bubbles up revert reason', async function () { it('bubbles up revert reason', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunctionRevertsReason().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunctionRevertsReason');
await expectRevert( await expect(this.mock.$functionStaticCall(this.target, call)).to.be.revertedWith('CallReceiverMock: reverting');
this.mock.$functionStaticCall(this.target.address, abiEncodedCall),
'CallReceiverMock: reverting',
);
}); });
it('reverts when address is not a contract', async function () { it('reverts when address is not a contract', async function () {
const [recipient] = accounts; const call = this.target.interface.encodeFunctionData('mockFunction');
const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
await expectRevertCustomError(this.mock.$functionStaticCall(recipient, abiEncodedCall), 'AddressEmptyCode', [ await expect(this.mock.$functionStaticCall(this.recipient, call))
recipient, .to.be.revertedWithCustomError(this.mock, 'AddressEmptyCode')
]); .withArgs(this.recipient.address);
}); });
}); });
describe('functionDelegateCall', function () { describe('functionDelegateCall', function () {
beforeEach(async function () {
this.target = await CallReceiverMock.new();
});
it('delegate calls the requested function', async function () { it('delegate calls the requested function', async function () {
// pseudorandom values const slot = ethers.hexlify(ethers.randomBytes(32));
const slot = '0x93e4c53af435ddf777c3de84bb9a953a777788500e229a468ea1036496ab66a0'; const value = ethers.hexlify(ethers.randomBytes(32));
const value = '0x6a465d1c49869f71fb65562bcbd7e08c8044074927f0297127203f2a9924ff5b';
const abiEncodedCall = this.target.contract.methods.mockFunctionWritesStorage(slot, value).encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunctionWritesStorage', [slot, value]);
expect(await web3.eth.getStorageAt(this.mock.address, slot)).to.be.equal(constants.ZERO_BYTES32); expect(await ethers.provider.getStorage(this.mock, slot)).to.equal(ethers.ZeroHash);
expectEvent( await expect(await this.mock.$functionDelegateCall(this.target, call))
await this.mock.$functionDelegateCall(this.target.address, abiEncodedCall), .to.emit(this.mock, 'return$functionDelegateCall')
'return$functionDelegateCall', .withArgs(coder.encode(['string'], ['0x1234']));
{ ret0: web3.eth.abi.encodeParameters(['string'], ['0x1234']) },
);
expect(await web3.eth.getStorageAt(this.mock.address, slot)).to.be.equal(value); expect(await ethers.provider.getStorage(this.mock, slot)).to.equal(value);
}); });
it('bubbles up revert reason', async function () { it('bubbles up revert reason', async function () {
const abiEncodedCall = this.target.contract.methods.mockFunctionRevertsReason().encodeABI(); const call = this.target.interface.encodeFunctionData('mockFunctionRevertsReason');
await expectRevert( await expect(this.mock.$functionDelegateCall(this.target, call)).to.be.revertedWith(
this.mock.$functionDelegateCall(this.target.address, abiEncodedCall),
'CallReceiverMock: reverting', 'CallReceiverMock: reverting',
); );
}); });
it('reverts when address is not a contract', async function () { it('reverts when address is not a contract', async function () {
const [recipient] = accounts; const call = this.target.interface.encodeFunctionData('mockFunction');
const abiEncodedCall = this.target.contract.methods.mockFunction().encodeABI();
await expectRevertCustomError(this.mock.$functionDelegateCall(recipient, abiEncodedCall), 'AddressEmptyCode', [ await expect(this.mock.$functionDelegateCall(this.recipient, call))
recipient, .to.be.revertedWithCustomError(this.mock, 'AddressEmptyCode')
]); .withArgs(this.recipient.address);
}); });
}); });