@elizaos/autonomous 2.0.0-alpha.21 → 2.0.0-alpha.23

package/test/contracts/lib/openzeppelin-contracts/test/token/ERC20/extensions/draft-ERC20Permit.test.js

@@ -0,0 +1,103 @@
+/* eslint-disable */
+
+const { BN, constants, expectRevert, time } = require('@openzeppelin/test-helpers');
+const { expect } = require('chai');
+const { MAX_UINT256 } = constants;
+
+const { fromRpcSig } = require('ethereumjs-util');
+const ethSigUtil = require('eth-sig-util');
+const Wallet = require('ethereumjs-wallet').default;
+
+const ERC20Permit = artifacts.require('$ERC20Permit');
+
+const { Permit, getDomain, domainType, domainSeparator } = require('../../../helpers/eip712');
+const { getChainId } = require('../../../helpers/chainid');
+
+contract('ERC20Permit', function (accounts) {
+  const [initialHolder, spender] = accounts;
+
+  const name = 'My Token';
+  const symbol = 'MTKN';
+  const version = '1';
+
+  const initialSupply = new BN(100);
+
+  beforeEach(async function () {
+    this.chainId = await getChainId();
+
+    this.token = await ERC20Permit.new(name, symbol, name);
+    await this.token.$_mint(initialHolder, initialSupply);
+  });
+
+  it('initial nonce is 0', async function () {
+    expect(await this.token.nonces(initialHolder)).to.be.bignumber.equal('0');
+  });
+
+  it('domain separator', async function () {
+    expect(await this.token.DOMAIN_SEPARATOR()).to.equal(await getDomain(this.token).then(domainSeparator));
+  });
+
+  describe('permit', function () {
+    const wallet = Wallet.generate();
+
+    const owner = wallet.getAddressString();
+    const value = new BN(42);
+    const nonce = 0;
+    const maxDeadline = MAX_UINT256;
+
+    const buildData = (contract, deadline = maxDeadline) =>
+      getDomain(contract).then(domain => ({
+        primaryType: 'Permit',
+        types: { EIP712Domain: domainType(domain), Permit },
+        domain,
+        message: { owner, spender, value, nonce, deadline },
+      }));
+
+    it('accepts owner signature', async function () {
+      const { v, r, s } = await buildData(this.token)
+        .then(data => ethSigUtil.signTypedMessage(wallet.getPrivateKey(), { data }))
+        .then(fromRpcSig);
+
+      await this.token.permit(owner, spender, value, maxDeadline, v, r, s);
+
+      expect(await this.token.nonces(owner)).to.be.bignumber.equal('1');
+      expect(await this.token.allowance(owner, spender)).to.be.bignumber.equal(value);
+    });
+
+    it('rejects reused signature', async function () {
+      const { v, r, s } = await buildData(this.token)
+        .then(data => ethSigUtil.signTypedMessage(wallet.getPrivateKey(), { data }))
+        .then(fromRpcSig);
+
+      await this.token.permit(owner, spender, value, maxDeadline, v, r, s);
+
+      await expectRevert(
+        this.token.permit(owner, spender, value, maxDeadline, v, r, s),
+        'ERC20Permit: invalid signature',
+      );
+    });
+
+    it('rejects other signature', async function () {
+      const otherWallet = Wallet.generate();
+
+      const { v, r, s } = await buildData(this.token)
+        .then(data => ethSigUtil.signTypedMessage(otherWallet.getPrivateKey(), { data }))
+        .then(fromRpcSig);
+
+      await expectRevert(
+        this.token.permit(owner, spender, value, maxDeadline, v, r, s),
+        'ERC20Permit: invalid signature',
+      );
+    });
+
+    it('rejects expired permit', async function () {
+      const deadline = (await time.latest()) - time.duration.weeks(1);
+
+      const { v, r, s } = await buildData(this.token, deadline)
+        .then(data => ethSigUtil.signTypedMessage(wallet.getPrivateKey(), { data }))
+        .then(fromRpcSig);
+
+      await expectRevert(this.token.permit(owner, spender, value, deadline, v, r, s), 'ERC20Permit: expired deadline');
+    });
+  });
+});

package/test/contracts/lib/openzeppelin-contracts/test/token/ERC20/presets/ERC20PresetFixedSupply.test.js

@@ -0,0 +1,42 @@
+const { BN, constants, expectEvent } = require('@openzeppelin/test-helpers');
+const { ZERO_ADDRESS } = constants;
+
+const { expect } = require('chai');
+
+const ERC20PresetFixedSupply = artifacts.require('ERC20PresetFixedSupply');
+
+contract('ERC20PresetFixedSupply', function (accounts) {
+  const [deployer, owner] = accounts;
+
+  const name = 'PresetFixedSupply';
+  const symbol = 'PFS';
+
+  const initialSupply = new BN('50000');
+  const amount = new BN('10000');
+
+  before(async function () {
+    this.token = await ERC20PresetFixedSupply.new(name, symbol, initialSupply, owner, { from: deployer });
+  });
+
+  it('deployer has the balance equal to initial supply', async function () {
+    expect(await this.token.balanceOf(owner)).to.be.bignumber.equal(initialSupply);
+  });
+
+  it('total supply is equal to initial supply', async function () {
+    expect(await this.token.totalSupply()).to.be.bignumber.equal(initialSupply);
+  });
+
+  describe('burning', function () {
+    it('holders can burn their tokens', async function () {
+      const remainingBalance = initialSupply.sub(amount);
+      const receipt = await this.token.burn(amount, { from: owner });
+      expectEvent(receipt, 'Transfer', { from: owner, to: ZERO_ADDRESS, value: amount });
+      expect(await this.token.balanceOf(owner)).to.be.bignumber.equal(remainingBalance);
+    });
+
+    it('decrements totalSupply', async function () {
+      const expectedSupply = initialSupply.sub(amount);
+      expect(await this.token.totalSupply()).to.be.bignumber.equal(expectedSupply);
+    });
+  });
+});

package/test/contracts/lib/openzeppelin-contracts/test/token/ERC20/presets/ERC20PresetMinterPauser.test.js

@@ -0,0 +1,110 @@
+const { BN, constants, expectEvent, expectRevert } = require('@openzeppelin/test-helpers');
+const { ZERO_ADDRESS } = constants;
+
+const { expect } = require('chai');
+
+const ERC20PresetMinterPauser = artifacts.require('ERC20PresetMinterPauser');
+
+contract('ERC20PresetMinterPauser', function (accounts) {
+  const [deployer, other] = accounts;
+
+  const name = 'MinterPauserToken';
+  const symbol = 'DRT';
+
+  const amount = new BN('5000');
+
+  const DEFAULT_ADMIN_ROLE = '0x0000000000000000000000000000000000000000000000000000000000000000';
+  const MINTER_ROLE = web3.utils.soliditySha3('MINTER_ROLE');
+  const PAUSER_ROLE = web3.utils.soliditySha3('PAUSER_ROLE');
+
+  beforeEach(async function () {
+    this.token = await ERC20PresetMinterPauser.new(name, symbol, { from: deployer });
+  });
+
+  it('deployer has the default admin role', async function () {
+    expect(await this.token.getRoleMemberCount(DEFAULT_ADMIN_ROLE)).to.be.bignumber.equal('1');
+    expect(await this.token.getRoleMember(DEFAULT_ADMIN_ROLE, 0)).to.equal(deployer);
+  });
+
+  it('deployer has the minter role', async function () {
+    expect(await this.token.getRoleMemberCount(MINTER_ROLE)).to.be.bignumber.equal('1');
+    expect(await this.token.getRoleMember(MINTER_ROLE, 0)).to.equal(deployer);
+  });
+
+  it('deployer has the pauser role', async function () {
+    expect(await this.token.getRoleMemberCount(PAUSER_ROLE)).to.be.bignumber.equal('1');
+    expect(await this.token.getRoleMember(PAUSER_ROLE, 0)).to.equal(deployer);
+  });
+
+  it('minter and pauser role admin is the default admin', async function () {
+    expect(await this.token.getRoleAdmin(MINTER_ROLE)).to.equal(DEFAULT_ADMIN_ROLE);
+    expect(await this.token.getRoleAdmin(PAUSER_ROLE)).to.equal(DEFAULT_ADMIN_ROLE);
+  });
+
+  describe('minting', function () {
+    it('deployer can mint tokens', async function () {
+      const receipt = await this.token.mint(other, amount, { from: deployer });
+      expectEvent(receipt, 'Transfer', { from: ZERO_ADDRESS, to: other, value: amount });
+
+      expect(await this.token.balanceOf(other)).to.be.bignumber.equal(amount);
+    });
+
+    it('other accounts cannot mint tokens', async function () {
+      await expectRevert(
+        this.token.mint(other, amount, { from: other }),
+        'ERC20PresetMinterPauser: must have minter role to mint',
+      );
+    });
+  });
+
+  describe('pausing', function () {
+    it('deployer can pause', async function () {
+      const receipt = await this.token.pause({ from: deployer });
+      expectEvent(receipt, 'Paused', { account: deployer });
+
+      expect(await this.token.paused()).to.equal(true);
+    });
+
+    it('deployer can unpause', async function () {
+      await this.token.pause({ from: deployer });
+
+      const receipt = await this.token.unpause({ from: deployer });
+      expectEvent(receipt, 'Unpaused', { account: deployer });
+
+      expect(await this.token.paused()).to.equal(false);
+    });
+
+    it('cannot mint while paused', async function () {
+      await this.token.pause({ from: deployer });
+
+      await expectRevert(
+        this.token.mint(other, amount, { from: deployer }),
+        'ERC20Pausable: token transfer while paused',
+      );
+    });
+
+    it('other accounts cannot pause', async function () {
+      await expectRevert(this.token.pause({ from: other }), 'ERC20PresetMinterPauser: must have pauser role to pause');
+    });
+
+    it('other accounts cannot unpause', async function () {
+      await this.token.pause({ from: deployer });
+
+      await expectRevert(
+        this.token.unpause({ from: other }),
+        'ERC20PresetMinterPauser: must have pauser role to unpause',
+      );
+    });
+  });
+
+  describe('burning', function () {
+    it('holders can burn their tokens', async function () {
+      await this.token.mint(other, amount, { from: deployer });
+
+      const receipt = await this.token.burn(amount.subn(1), { from: other });
+      expectEvent(receipt, 'Transfer', { from: other, to: ZERO_ADDRESS, value: amount.subn(1) });
+
+      expect(await this.token.balanceOf(other)).to.be.bignumber.equal('1');
+    });
+  });
+});

package/test/contracts/lib/openzeppelin-contracts/test/token/ERC20/utils/SafeERC20.test.js

@@ -0,0 +1,350 @@
+const { constants, expectEvent, expectRevert } = require('@openzeppelin/test-helpers');
+
+const SafeERC20 = artifacts.require('$SafeERC20');
+const ERC20ReturnFalseMock = artifacts.require('$ERC20ReturnFalseMock');
+const ERC20ReturnTrueMock = artifacts.require('$ERC20'); // default implementation returns true
+const ERC20NoReturnMock = artifacts.require('$ERC20NoReturnMock');
+const ERC20PermitNoRevertMock = artifacts.require('$ERC20PermitNoRevertMock');
+const ERC20ForceApproveMock = artifacts.require('$ERC20ForceApproveMock');
+
+const { getDomain, domainType, Permit } = require('../../../helpers/eip712');
+
+const { fromRpcSig } = require('ethereumjs-util');
+const ethSigUtil = require('eth-sig-util');
+const Wallet = require('ethereumjs-wallet').default;
+
+const name = 'ERC20Mock';
+const symbol = 'ERC20Mock';
+
+contract('SafeERC20', function (accounts) {
+  const [hasNoCode] = accounts;
+
+  before(async function () {
+    this.mock = await SafeERC20.new();
+  });
+
+  describe('with address that has no contract code', function () {
+    beforeEach(async function () {
+      this.token = { address: hasNoCode };
+    });
+
+    shouldRevertOnAllCalls(accounts, 'Address: call to non-contract');
+  });
+
+  describe('with token that returns false on all calls', function () {
+    beforeEach(async function () {
+      this.token = await ERC20ReturnFalseMock.new(name, symbol);
+    });
+
+    shouldRevertOnAllCalls(accounts, 'SafeERC20: ERC20 operation did not succeed');
+  });
+
+  describe('with token that returns true on all calls', function () {
+    beforeEach(async function () {
+      this.token = await ERC20ReturnTrueMock.new(name, symbol);
+    });
+
+    shouldOnlyRevertOnErrors(accounts);
+  });
+
+  describe('with token that returns no boolean values', function () {
+    beforeEach(async function () {
+      this.token = await ERC20NoReturnMock.new(name, symbol);
+    });
+
+    shouldOnlyRevertOnErrors(accounts);
+  });
+
+  describe("with token that doesn't revert on invalid permit", function () {
+    const wallet = Wallet.generate();
+    const owner = wallet.getAddressString();
+    const spender = hasNoCode;
+
+    beforeEach(async function () {
+      this.token = await ERC20PermitNoRevertMock.new(name, symbol, name);
+
+      this.data = await getDomain(this.token).then(domain => ({
+        primaryType: 'Permit',
+        types: { EIP712Domain: domainType(domain), Permit },
+        domain,
+        message: { owner, spender, value: '42', nonce: '0', deadline: constants.MAX_UINT256 },
+      }));
+
+      this.signature = fromRpcSig(ethSigUtil.signTypedMessage(wallet.getPrivateKey(), { data: this.data }));
+    });
+
+    it('accepts owner signature', async function () {
+      expect(await this.token.nonces(owner)).to.be.bignumber.equal('0');
+      expect(await this.token.allowance(owner, spender)).to.be.bignumber.equal('0');
+
+      await this.mock.$safePermit(
+        this.token.address,
+        this.data.message.owner,
+        this.data.message.spender,
+        this.data.message.value,
+        this.data.message.deadline,
+        this.signature.v,
+        this.signature.r,
+        this.signature.s,
+      );
+
+      expect(await this.token.nonces(owner)).to.be.bignumber.equal('1');
+      expect(await this.token.allowance(owner, spender)).to.be.bignumber.equal(this.data.message.value);
+    });
+
+    it('revert on reused signature', async function () {
+      expect(await this.token.nonces(owner)).to.be.bignumber.equal('0');
+      // use valid signature and consume nounce
+      await this.mock.$safePermit(
+        this.token.address,
+        this.data.message.owner,
+        this.data.message.spender,
+        this.data.message.value,
+        this.data.message.deadline,
+        this.signature.v,
+        this.signature.r,
+        this.signature.s,
+      );
+      expect(await this.token.nonces(owner)).to.be.bignumber.equal('1');
+      // invalid call does not revert for this token implementation
+      await this.token.permit(
+        this.data.message.owner,
+        this.data.message.spender,
+        this.data.message.value,
+        this.data.message.deadline,
+        this.signature.v,
+        this.signature.r,
+        this.signature.s,
+      );
+      expect(await this.token.nonces(owner)).to.be.bignumber.equal('1');
+      // invalid call revert when called through the SafeERC20 library
+      await expectRevert(
+        this.mock.$safePermit(
+          this.token.address,
+          this.data.message.owner,
+          this.data.message.spender,
+          this.data.message.value,
+          this.data.message.deadline,
+          this.signature.v,
+          this.signature.r,
+          this.signature.s,
+        ),
+        'SafeERC20: permit did not succeed',
+      );
+      expect(await this.token.nonces(owner)).to.be.bignumber.equal('1');
+    });
+
+    it('revert on invalid signature', async function () {
+      // signature that is not valid for owner
+      const invalidSignature = {
+        v: 27,
+        r: '0x71753dc5ecb5b4bfc0e3bc530d79ce5988760ed3f3a234c86a5546491f540775',
+        s: '0x0049cedee5aed990aabed5ad6a9f6e3c565b63379894b5fa8b512eb2b79e485d',
+      };
+
+      // invalid call does not revert for this token implementation
+      await this.token.permit(
+        this.data.message.owner,
+        this.data.message.spender,
+        this.data.message.value,
+        this.data.message.deadline,
+        invalidSignature.v,
+        invalidSignature.r,
+        invalidSignature.s,
+      );
+
+      // invalid call revert when called through the SafeERC20 library
+      await expectRevert(
+        this.mock.$safePermit(
+          this.token.address,
+          this.data.message.owner,
+          this.data.message.spender,
+          this.data.message.value,
+          this.data.message.deadline,
+          invalidSignature.v,
+          invalidSignature.r,
+          invalidSignature.s,
+        ),
+        'SafeERC20: permit did not succeed',
+      );
+    });
+  });
+
+  describe('with usdt approval beaviour', function () {
+    const spender = hasNoCode;
+
+    beforeEach(async function () {
+      this.token = await ERC20ForceApproveMock.new(name, symbol);
+    });
+
+    describe('with initial approval', function () {
+      beforeEach(async function () {
+        await this.token.$_approve(this.mock.address, spender, 100);
+      });
+
+      it('safeApprove fails to update approval to non-zero', async function () {
+        await expectRevert(
+          this.mock.$safeApprove(this.token.address, spender, 200),
+          'SafeERC20: approve from non-zero to non-zero allowance',
+        );
+      });
+
+      it('safeApprove can update approval to zero', async function () {
+        await this.mock.$safeApprove(this.token.address, spender, 0);
+      });
+
+      it('safeApprove can increase approval', async function () {
+        await expectRevert(this.mock.$safeIncreaseAllowance(this.token.address, spender, 10), 'USDT approval failure');
+      });
+
+      it('safeApprove can decrease approval', async function () {
+        await expectRevert(this.mock.$safeDecreaseAllowance(this.token.address, spender, 10), 'USDT approval failure');
+      });
+
+      it('forceApprove works', async function () {
+        await this.mock.$forceApprove(this.token.address, spender, 200);
+      });
+    });
+  });
+});
+
+function shouldRevertOnAllCalls([receiver, spender], reason) {
+  it('reverts on transfer', async function () {
+    await expectRevert(this.mock.$safeTransfer(this.token.address, receiver, 0), reason);
+  });
+
+  it('reverts on transferFrom', async function () {
+    await expectRevert(this.mock.$safeTransferFrom(this.token.address, this.mock.address, receiver, 0), reason);
+  });
+
+  it('reverts on approve', async function () {
+    await expectRevert(this.mock.$safeApprove(this.token.address, spender, 0), reason);
+  });
+
+  it('reverts on increaseAllowance', async function () {
+    // [TODO] make sure it's reverting for the right reason
+    await expectRevert.unspecified(this.mock.$safeIncreaseAllowance(this.token.address, spender, 0));
+  });
+
+  it('reverts on decreaseAllowance', async function () {
+    // [TODO] make sure it's reverting for the right reason
+    await expectRevert.unspecified(this.mock.$safeDecreaseAllowance(this.token.address, spender, 0));
+  });
+
+  it('reverts on forceApprove', async function () {
+    await expectRevert(this.mock.$forceApprove(this.token.address, spender, 0), reason);
+  });
+}
+
+function shouldOnlyRevertOnErrors([owner, receiver, spender]) {
+  describe('transfers', function () {
+    beforeEach(async function () {
+      await this.token.$_mint(owner, 100);
+      await this.token.$_mint(this.mock.address, 100);
+      await this.token.approve(this.mock.address, constants.MAX_UINT256, { from: owner });
+    });
+
+    it("doesn't revert on transfer", async function () {
+      const { tx } = await this.mock.$safeTransfer(this.token.address, receiver, 10);
+      await expectEvent.inTransaction(tx, this.token, 'Transfer', {
+        from: this.mock.address,
+        to: receiver,
+        value: '10',
+      });
+    });
+
+    it("doesn't revert on transferFrom", async function () {
+      const { tx } = await this.mock.$safeTransferFrom(this.token.address, owner, receiver, 10);
+      await expectEvent.inTransaction(tx, this.token, 'Transfer', {
+        from: owner,
+        to: receiver,
+        value: '10',
+      });
+    });
+  });
+
+  describe('approvals', function () {
+    context('with zero allowance', function () {
+      beforeEach(async function () {
+        await this.token.$_approve(this.mock.address, spender, 0);
+      });
+
+      it("doesn't revert when approving a non-zero allowance", async function () {
+        await this.mock.$safeApprove(this.token.address, spender, 100);
+        expect(await this.token.allowance(this.mock.address, spender)).to.be.bignumber.equal('100');
+      });
+
+      it("doesn't revert when approving a zero allowance", async function () {
+        await this.mock.$safeApprove(this.token.address, spender, 0);
+        expect(await this.token.allowance(this.mock.address, spender)).to.be.bignumber.equal('0');
+      });
+
+      it("doesn't revert when force approving a non-zero allowance", async function () {
+        await this.mock.$forceApprove(this.token.address, spender, 100);
+        expect(await this.token.allowance(this.mock.address, spender)).to.be.bignumber.equal('100');
+      });
+
+      it("doesn't revert when force approving a zero allowance", async function () {
+        await this.mock.$forceApprove(this.token.address, spender, 0);
+        expect(await this.token.allowance(this.mock.address, spender)).to.be.bignumber.equal('0');
+      });
+
+      it("doesn't revert when increasing the allowance", async function () {
+        await this.mock.$safeIncreaseAllowance(this.token.address, spender, 10);
+        expect(await this.token.allowance(this.mock.address, spender)).to.be.bignumber.equal('10');
+      });
+
+      it('reverts when decreasing the allowance', async function () {
+        await expectRevert(
+          this.mock.$safeDecreaseAllowance(this.token.address, spender, 10),
+          'SafeERC20: decreased allowance below zero',
+        );
+      });
+    });
+
+    context('with non-zero allowance', function () {
+      beforeEach(async function () {
+        await this.token.$_approve(this.mock.address, spender, 100);
+      });
+
+      it('reverts when approving a non-zero allowance', async function () {
+        await expectRevert(
+          this.mock.$safeApprove(this.token.address, spender, 20),
+          'SafeERC20: approve from non-zero to non-zero allowance',
+        );
+      });
+
+      it("doesn't revert when approving a zero allowance", async function () {
+        await this.mock.$safeApprove(this.token.address, spender, 0);
+        expect(await this.token.allowance(this.mock.address, spender)).to.be.bignumber.equal('0');
+      });
+
+      it("doesn't revert when force approving a non-zero allowance", async function () {
+        await this.mock.$forceApprove(this.token.address, spender, 20);
+        expect(await this.token.allowance(this.mock.address, spender)).to.be.bignumber.equal('20');
+      });
+
+      it("doesn't revert when force approving a zero allowance", async function () {
+        await this.mock.$forceApprove(this.token.address, spender, 0);
+        expect(await this.token.allowance(this.mock.address, spender)).to.be.bignumber.equal('0');
+      });
+
+      it("doesn't revert when increasing the allowance", async function () {
+        await this.mock.$safeIncreaseAllowance(this.token.address, spender, 10);
+        expect(await this.token.allowance(this.mock.address, spender)).to.be.bignumber.equal('110');
+      });
+
+      it("doesn't revert when decreasing the allowance to a positive value", async function () {
+        await this.mock.$safeDecreaseAllowance(this.token.address, spender, 50);
+        expect(await this.token.allowance(this.mock.address, spender)).to.be.bignumber.equal('50');
+      });
+
+      it('reverts when decreasing the allowance to a negative value', async function () {
+        await expectRevert(
+          this.mock.$safeDecreaseAllowance(this.token.address, spender, 200),
+          'SafeERC20: decreased allowance below zero',
+        );
+      });
+    });
+  });
+}

package/test/contracts/lib/openzeppelin-contracts/test/token/ERC20/utils/TokenTimelock.test.js

@@ -0,0 +1,71 @@
+const { BN, expectRevert, time } = require('@openzeppelin/test-helpers');
+
+const { expect } = require('chai');
+
+const ERC20 = artifacts.require('$ERC20');
+const TokenTimelock = artifacts.require('TokenTimelock');
+
+contract('TokenTimelock', function (accounts) {
+  const [beneficiary] = accounts;
+
+  const name = 'My Token';
+  const symbol = 'MTKN';
+
+  const amount = new BN(100);
+
+  context('with token', function () {
+    beforeEach(async function () {
+      this.token = await ERC20.new(name, symbol);
+    });
+
+    it('rejects a release time in the past', async function () {
+      const pastReleaseTime = (await time.latest()).sub(time.duration.years(1));
+      await expectRevert(
+        TokenTimelock.new(this.token.address, beneficiary, pastReleaseTime),
+        'TokenTimelock: release time is before current time',
+      );
+    });
+
+    context('once deployed', function () {
+      beforeEach(async function () {
+        this.releaseTime = (await time.latest()).add(time.duration.years(1));
+        this.timelock = await TokenTimelock.new(this.token.address, beneficiary, this.releaseTime);
+        await this.token.$_mint(this.timelock.address, amount);
+      });
+
+      it('can get state', async function () {
+        expect(await this.timelock.token()).to.equal(this.token.address);
+        expect(await this.timelock.beneficiary()).to.equal(beneficiary);
+        expect(await this.timelock.releaseTime()).to.be.bignumber.equal(this.releaseTime);
+      });
+
+      it('cannot be released before time limit', async function () {
+        await expectRevert(this.timelock.release(), 'TokenTimelock: current time is before release time');
+      });
+
+      it('cannot be released just before time limit', async function () {
+        await time.increaseTo(this.releaseTime.sub(time.duration.seconds(3)));
+        await expectRevert(this.timelock.release(), 'TokenTimelock: current time is before release time');
+      });
+
+      it('can be released just after limit', async function () {
+        await time.increaseTo(this.releaseTime.add(time.duration.seconds(1)));
+        await this.timelock.release();
+        expect(await this.token.balanceOf(beneficiary)).to.be.bignumber.equal(amount);
+      });
+
+      it('can be released after time limit', async function () {
+        await time.increaseTo(this.releaseTime.add(time.duration.years(1)));
+        await this.timelock.release();
+        expect(await this.token.balanceOf(beneficiary)).to.be.bignumber.equal(amount);
+      });
+
+      it('cannot be released twice', async function () {
+        await time.increaseTo(this.releaseTime.add(time.duration.years(1)));
+        await this.timelock.release();
+        await expectRevert(this.timelock.release(), 'TokenTimelock: no tokens to release');
+        expect(await this.token.balanceOf(beneficiary)).to.be.bignumber.equal(amount);
+      });
+    });
+  });
+});