feat: add NatSpec comments and tests to TeleportrDeposit

packages/contracts/contracts/L1/teleportr/TeleportrDeposit.sol

@@ -10,18 +10,57 @@ import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
  * https://github.com/0xclem/teleportr/blob/main/contracts/BridgeDeposit.sol
  */
 contract TeleportrDeposit is Ownable {
+    /// The minimum amount that be deposited in a receive.
     uint256 public minDepositAmount;
+    /// The maximum amount that be deposited in a receive.
     uint256 public maxDepositAmount;
+    /// The maximum balance the contract can hold after a receive.
     uint256 public maxBalance;
+    /// The total number of successful deposits received.
     uint256 public totalDeposits;
 
-    // Events
+    /**
+     * @notice Emitted any time the minimum deposit amount is set.
+     * @param previousAmount The previous minimum deposit amount.
+     * @param newAmount The new minimum deposit amount.
+     */
     event MinDepositAmountSet(uint256 previousAmount, uint256 newAmount);
+
+    /**
+     * @notice Emitted any time the maximum deposit amount is set.
+     * @param previousAmount The previous maximum deposit amount.
+     * @param newAmount The new maximum deposit amount.
+     */
     event MaxDepositAmountSet(uint256 previousAmount, uint256 newAmount);
+
+    /**
+     * @notice Emitted any time the contract maximum balance is set.
+     * @param previousBalance The previous maximum contract balance.
+     * @param newBalance The new maximum contract balance.
+     */
     event MaxBalanceSet(uint256 previousBalance, uint256 newBalance);
+
+    /**
+     * @notice Emitted any time the balance is withdrawn by the owner.
+     * @param owner The current owner and recipient of the funds.
+     * @param balance The current contract balance paid to the owner.
+     */
     event BalanceWithdrawn(address indexed owner, uint256 balance);
+
+    /**
+     * @notice Emitted any time a successful deposit is received.
+     * @param depositId A unique sequencer number identifying the deposit.
+     * @param emitter The sending address of the payer.
+     * @param amount The amount deposited by the payer.
+     */
     event EtherReceived(uint256 indexed depositId, address indexed emitter, uint256 indexed amount);
 
+    /**
+     * @notice Initializes a new TeleportrDeposit contract.
+     * @param _minDepositAmount The initial minimum deposit amount.
+     * @param _maxDepositAmount The initial maximum deposit amount.
+     * @param _maxBalance The initial maximum contract balance.
+     */
     constructor(
         uint256 _minDepositAmount,
         uint256 _maxDepositAmount,
@@ -36,9 +75,13 @@ contract TeleportrDeposit is Ownable {
         emit MaxBalanceSet(0, _maxBalance);
     }
 
-    // Receive function which reverts if the amount is outside the range
-    // [minDepositAmount, maxDepositAmount], or the amount would put the
-    // contract over its maxBalance.
+    /**
+     * @notice Accepts deposits that will be disbursed to the sender's address on L2.
+     * The method reverts if the amount is less than the current
+     * minDepositAmount, the amount is greater than the current
+     * maxDepositAmount, or the amount causes the contract to exceed its maximum
+     * allowed balance.
+     */
     receive() external payable {
         require(msg.value >= minDepositAmount, "Deposit amount is too small");
         require(msg.value <= maxDepositAmount, "Deposit amount is too big");
@@ -50,7 +93,9 @@ contract TeleportrDeposit is Ownable {
         }
     }
 
-    // Send the contract's balance to the owner
+    /**
+     * @notice Sends the contract's current balance to the owner.
+     */
     function withdrawBalance() external onlyOwner {
         address _owner = owner();
         uint256 _balance = address(this).balance;
@@ -58,17 +103,28 @@ contract TeleportrDeposit is Ownable {
         payable(_owner).transfer(_balance);
     }
 
-    // Setters
+    /**
+     * @notice Sets the minimum amount that can be deposited in a receive.
+     * @param _minDepositAmount The new minimum deposit amount.
+     */
     function setMinAmount(uint256 _minDepositAmount) external onlyOwner {
         emit MinDepositAmountSet(minDepositAmount, _minDepositAmount);
         minDepositAmount = _minDepositAmount;
     }
 
+    /**
+     * @notice Sets the maximum amount that can be deposited in a receive.
+     * @param _maxDepositAmount The new maximum deposit amount.
+     */
     function setMaxAmount(uint256 _maxDepositAmount) external onlyOwner {
         emit MaxDepositAmountSet(maxDepositAmount, _maxDepositAmount);
         maxDepositAmount = _maxDepositAmount;
     }
 
+    /**
+     * @notice Sets the maximum balance the contract can hold after a receive.
+     * @param _maxBalance The new maximum contract balance.
+     */
     function setMaxBalance(uint256 _maxBalance) external onlyOwner {
         emit MaxBalanceSet(maxBalance, _maxBalance);
         maxBalance = _maxBalance;

packages/contracts/docs/TeleportrDeposit.md

+# TeleportrDeposit
+
+
+
+> TeleportrDeposit Shout out to 0xclem for providing the inspiration for this contract: https://github.com/0xclem/teleportr/blob/main/contracts/BridgeDeposit.sol
+
+
+
+
+
+## Methods
+
+### maxBalance
+
+```solidity
+function maxBalance() external view returns (uint256)
+```
+
+The maximum balance the contract can hold after a receive.
+
+
+
+
+#### Returns
+
+| Name | Type | Description |
+|---|---|---|
+| _0 | uint256 | undefined
+
+### maxDepositAmount
+
+```solidity
+function maxDepositAmount() external view returns (uint256)
+```
+
+The maximum amount that be deposited in a receive.
+
+
+
+
+#### Returns
+
+| Name | Type | Description |
+|---|---|---|
+| _0 | uint256 | undefined
+
+### minDepositAmount
+
+```solidity
+function minDepositAmount() external view returns (uint256)
+```
+
+The minimum amount that be deposited in a receive.
+
+
+
+
+#### Returns
+
+| Name | Type | Description |
+|---|---|---|
+| _0 | uint256 | undefined
+
+### owner
+
+```solidity
+function owner() external view returns (address)
+```
+
+
+
+*Returns the address of the current owner.*
+
+
+#### Returns
+
+| Name | Type | Description |
+|---|---|---|
+| _0 | address | undefined
+
+### renounceOwnership
+
+```solidity
+function renounceOwnership() external nonpayable
+```
+
+
+
+*Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.*
+
+
+### setMaxAmount
+
+```solidity
+function setMaxAmount(uint256 _maxDepositAmount) external nonpayable
+```
+
+Sets the maximum amount that can be deposited in a receive.
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| _maxDepositAmount | uint256 | The new maximum deposit amount.
+
+### setMaxBalance
+
+```solidity
+function setMaxBalance(uint256 _maxBalance) external nonpayable
+```
+
+Sets the maximum balance the contract can hold after a receive.
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| _maxBalance | uint256 | The new maximum contract balance.
+
+### setMinAmount
+
+```solidity
+function setMinAmount(uint256 _minDepositAmount) external nonpayable
+```
+
+Sets the minimum amount that can be deposited in a receive.
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| _minDepositAmount | uint256 | The new minimum deposit amount.
+
+### totalDeposits
+
+```solidity
+function totalDeposits() external view returns (uint256)
+```
+
+The total number of successful deposits received.
+
+
+
+
+#### Returns
+
+| Name | Type | Description |
+|---|---|---|
+| _0 | uint256 | undefined
+
+### transferOwnership
+
+```solidity
+function transferOwnership(address newOwner) external nonpayable
+```
+
+
+
+*Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.*
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| newOwner | address | undefined
+
+### withdrawBalance
+
+```solidity
+function withdrawBalance() external nonpayable
+```
+
+Sends the contract's current balance to the owner.
+
+
+
+
+
+
+## Events
+
+### BalanceWithdrawn
+
+```solidity
+event BalanceWithdrawn(address indexed owner, uint256 balance)
+```
+
+Emitted any time the balance is withdrawn by the owner.
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| owner `indexed` | address | The current owner and recipient of the funds. |
+| balance  | uint256 | The current contract balance paid to the owner. |
+
+### EtherReceived
+
+```solidity
+event EtherReceived(uint256 indexed depositId, address indexed emitter, uint256 indexed amount)
+```
+
+Emitted any time a successful deposit is received.
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| depositId `indexed` | uint256 | A unique sequencer number identifying the deposit. |
+| emitter `indexed` | address | The sending address of the payer. |
+| amount `indexed` | uint256 | The amount deposited by the payer. |
+
+### MaxBalanceSet
+
+```solidity
+event MaxBalanceSet(uint256 previousBalance, uint256 newBalance)
+```
+
+Emitted any time the contract maximum balance is set.
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| previousBalance  | uint256 | The previous maximum contract balance. |
+| newBalance  | uint256 | The new maximum contract balance. |
+
+### MaxDepositAmountSet
+
+```solidity
+event MaxDepositAmountSet(uint256 previousAmount, uint256 newAmount)
+```
+
+Emitted any time the maximum deposit amount is set.
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| previousAmount  | uint256 | The previous maximum deposit amount. |
+| newAmount  | uint256 | The new maximum deposit amount. |
+
+### MinDepositAmountSet
+
+```solidity
+event MinDepositAmountSet(uint256 previousAmount, uint256 newAmount)
+```
+
+Emitted any time the minimum deposit amount is set.
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| previousAmount  | uint256 | The previous minimum deposit amount. |
+| newAmount  | uint256 | The new minimum deposit amount. |
+
+### OwnershipTransferred
+
+```solidity
+event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
+```
+
+
+
+
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| previousOwner `indexed` | address | undefined |
+| newOwner `indexed` | address | undefined |
+
+
+

packages/contracts/test/contracts/L1/teleportr/TeleportrDeposit.spec.ts

+/* External Imports */
+import { ethers } from 'hardhat'
+import { Signer, Contract, BigNumber } from 'ethers'
+
+/* Internal Imports */
+import { expect } from '../../../setup'
+
+const initialMinDepositAmount = ethers.utils.parseEther('0.01')
+const initialMaxDepositAmount = ethers.utils.parseEther('1')
+const initialMaxBalance = ethers.utils.parseEther('2')
+
+describe('TeleportrDeposit', async () => {
+  let teleportrDeposit: Contract
+  let signer: Signer
+  let signer2: Signer
+  let contractAddress: string
+  let signerAddress: string
+  let signer2Address: string
+  before(async () => {
+    ;[signer, signer2] = await ethers.getSigners()
+    teleportrDeposit = await (
+      await ethers.getContractFactory('TeleportrDeposit')
+    ).deploy(
+      initialMinDepositAmount,
+      initialMaxDepositAmount,
+      initialMaxBalance
+    )
+    contractAddress = teleportrDeposit.address
+    signerAddress = await signer.getAddress()
+    signer2Address = await signer2.getAddress()
+  })
+  describe('receive', async () => {
+    const oneETH = ethers.utils.parseEther('1.0')
+    const twoETH = ethers.utils.parseEther('2.0')
+    it('should revert if deposit amount is less than min amount', async () => {
+      await expect(
+        signer.sendTransaction({
+          to: contractAddress,
+          value: ethers.utils.parseEther('0.001'),
+        })
+      ).to.be.revertedWith('Deposit amount is too small')
+    })
+    it('should revert if deposit amount is greater than max amount', async () => {
+      await expect(
+        signer.sendTransaction({
+          to: contractAddress,
+          value: ethers.utils.parseEther('1.1'),
+        })
+      ).to.be.revertedWith('Deposit amount is too big')
+    })
+    it('should emit EtherReceived if called by non-owner', async () => {
+      await expect(
+        signer2.sendTransaction({
+          to: contractAddress,
+          value: oneETH,
+        })
+      )
+        .to.emit(teleportrDeposit, 'EtherReceived')
+        .withArgs(BigNumber.from('0'), signer2Address, oneETH)
+    })
+    it('should increase the contract balance by deposit amount', async () => {
+      await expect(await ethers.provider.getBalance(contractAddress)).to.equal(
+        oneETH
+      )
+    })
+    it('should emit EtherReceived if called by owner', async () => {
+      await expect(
+        signer.sendTransaction({
+          to: contractAddress,
+          value: oneETH,
+        })
+      )
+        .to.emit(teleportrDeposit, 'EtherReceived')
+        .withArgs(BigNumber.from('1'), signerAddress, oneETH)
+    })
+    it('should increase the contract balance by deposit amount', async () => {
+      await expect(await ethers.provider.getBalance(contractAddress)).to.equal(
+        twoETH
+      )
+    })
+    it('should revert if deposit will exceed max balance', async () => {
+      await expect(
+        signer.sendTransaction({
+          to: contractAddress,
+          value: initialMinDepositAmount,
+        })
+      ).to.be.revertedWith('Contract max balance exceeded')
+    })
+  })
+  describe('withdrawBalance', async () => {
+    let initialContractBalance: BigNumber
+    let initialSignerBalance: BigNumber
+    before(async () => {
+      initialContractBalance = await ethers.provider.getBalance(contractAddress)
+      initialSignerBalance = await ethers.provider.getBalance(signerAddress)
+    })
+    it('should revert if called by non-owner', async () => {
+      await expect(
+        teleportrDeposit.connect(signer2).withdrawBalance()
+      ).to.be.revertedWith('Ownable: caller is not the owner')
+    })
+    it('should emit BalanceWithdrawn if called by owner', async () => {
+      await expect(teleportrDeposit.withdrawBalance())
+        .to.emit(teleportrDeposit, 'BalanceWithdrawn')
+        .withArgs(signerAddress, initialContractBalance)
+    })
+    it('should leave the contract with zero balance', async () => {
+      await expect(await ethers.provider.getBalance(contractAddress)).to.equal(
+        ethers.utils.parseEther('0')
+      )
+    })
+    it('should credit owner with contract balance - fees', async () => {
+      const expSignerBalance = initialSignerBalance.add(initialContractBalance)
+      await expect(
+        await ethers.provider.getBalance(signerAddress)
+      ).to.be.closeTo(expSignerBalance, 10 ** 15)
+    })
+  })
+  describe('setMinAmount', async () => {
+    const newMinDepositAmount = ethers.utils.parseEther('0.02')
+    it('should revert if called by non-owner', async () => {
+      await expect(
+        teleportrDeposit.connect(signer2).setMinAmount(newMinDepositAmount)
+      ).to.be.revertedWith('Ownable: caller is not the owner')
+    })
+    it('should emit MinDepositAmountSet if called by owner', async () => {
+      await expect(teleportrDeposit.setMinAmount(newMinDepositAmount))
+        .to.emit(teleportrDeposit, 'MinDepositAmountSet')
+        .withArgs(initialMinDepositAmount, newMinDepositAmount)
+    })
+    it('should have updated minDepositAmount after success', async () => {
+      await expect(await teleportrDeposit.minDepositAmount()).to.be.eq(
+        newMinDepositAmount
+      )
+    })
+  })
+  describe('setMaxAmount', async () => {
+    const newMaxDepositAmount = ethers.utils.parseEther('2')
+    it('should revert if called non-owner', async () => {
+      await expect(
+        teleportrDeposit.connect(signer2).setMaxAmount(newMaxDepositAmount)
+      ).to.be.revertedWith('Ownable: caller is not the owner')
+    })
+    it('should emit MaxDepositAmountSet if called by owner', async () => {
+      await expect(teleportrDeposit.setMaxAmount(newMaxDepositAmount))
+        .to.emit(teleportrDeposit, 'MaxDepositAmountSet')
+        .withArgs(initialMaxDepositAmount, newMaxDepositAmount)
+    })
+    it('should have an updated maxDepositAmount after success', async () => {
+      await expect(await teleportrDeposit.maxDepositAmount()).to.be.eq(
+        newMaxDepositAmount
+      )
+    })
+  })
+  describe('setMaxBalance', async () => {
+    const newMaxBalance = ethers.utils.parseEther('2000')
+    it('should revert if called by non-owner', async () => {
+      await expect(
+        teleportrDeposit.connect(signer2).setMaxBalance(newMaxBalance)
+      ).to.be.revertedWith('Ownable: caller is not the owner')
+    })
+    it('should emit MaxBalanceSet if called by owner', async () => {
+      await expect(teleportrDeposit.setMaxBalance(newMaxBalance))
+        .to.emit(teleportrDeposit, 'MaxBalanceSet')
+        .withArgs(initialMaxBalance, newMaxBalance)
+    })
+    it('should have an updated maxBalance after success', async () => {
+      await expect(await teleportrDeposit.maxBalance()).to.be.eq(newMaxBalance)
+    })
+  })
+})