diff --git a/.github/workflows/integration-tests-api.yml b/.github/workflows/integration-tests-api.yml index e666e78826..ebaf00c28d 100644 --- a/.github/workflows/integration-tests-api.yml +++ b/.github/workflows/integration-tests-api.yml @@ -51,6 +51,10 @@ jobs: - name: List running containers run: docker ps + - name: Show localhost accounts + run: | + cd packages/integration-tests/src/playbook + npx hardhat accounts --network localhost - name: API tests run (parallel) run: | cd packages/integration-tests diff --git a/package-lock.json b/package-lock.json index d692d63046..50ed8290c3 100644 --- a/package-lock.json +++ b/package-lock.json @@ -58325,7 +58325,7 @@ "supertest": "^6.3.3", "ts-jest": "^29.0.5", "ts-node": "^10.9.1", - "zksync-web3": "^0.14.3" + "zksync-web3": "^0.17.1" } }, "packages/integration-tests/node_modules/@ethersproject/networks": { @@ -58858,12 +58858,16 @@ "dev": true }, "packages/integration-tests/node_modules/zksync-web3": { - "version": "0.14.4", - "resolved": "https://registry.npmjs.org/zksync-web3/-/zksync-web3-0.14.4.tgz", - "integrity": "sha512-kYehMD/S6Uhe1g434UnaMN+sBr9nQm23Ywn0EUP5BfQCsbjcr3ORuS68PosZw8xUTu3pac7G6YMSnNHk+fwzvg==", + "version": "0.17.1", + "resolved": "https://registry.npmjs.org/zksync-web3/-/zksync-web3-0.17.1.tgz", + "integrity": "sha512-jMV4gfAQyehkIbNs81i4uvccHLe+XBu/tNPFb0Rm38pXccWY5VXzVE6XWS0dBiHlMfjdfUGn/sxwzJbWZDGYGQ==", + "deprecated": "This package has been deprecated in favor of zksync-ethers@5.0.0", "dev": true, + "dependencies": { + "ethers": "~5.7.0" + }, "peerDependencies": { - "ethers": "^5.7.0" + "ethers": "~5.7.0" } }, "packages/worker": { diff --git a/packages/integration-tests/package.json b/packages/integration-tests/package.json index 24ee6ad63a..d8cfe560f3 100644 --- a/packages/integration-tests/package.json +++ b/packages/integration-tests/package.json @@ -36,7 +36,7 @@ "supertest": "^6.3.3", "ts-jest": "^29.0.5", "ts-node": "^10.9.1", - "zksync-web3": "^0.14.3" + "zksync-web3": "^0.17.1" }, "dependencies": { "ts-jest-resolver": "^2.0.0" diff --git a/packages/integration-tests/src/playbook/contracts/InitialMultiTransfer.sol b/packages/integration-tests/src/playbook/contracts/InitialMultiTransfer.sol new file mode 100644 index 0000000000..a7301ef4df --- /dev/null +++ b/packages/integration-tests/src/playbook/contracts/InitialMultiTransfer.sol @@ -0,0 +1,63 @@ +// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.6.0 + +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import "@openzeppelin/contracts/utils/Address.sol"; + +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.16; + + +contract TokenF2L2 { + // Declare the using directive on the contract scope + using SafeERC20 for IERC20; + using Address for address payable; + + //Be able to receive any funds to the contract + receive() external payable { + pay(); + } + + function pay() public payable { + emit Paid(msg.sender, msg.value, block.timestamp); + } + + function getBalance() public view returns (uint) { + return address(this).balance; + } + + address public owner; + + constructor(address _owner) { + owner = _owner; + } + + event Paid(address indexed _from, uint _amount, uint _timestamp); + + modifier onlyOwner() { + require(owner == msg.sender, "You are not the owner"); + _; // continue + } + + function multiTransfer( + address[] memory _recivers, + address[] memory _tokenAddresses, + uint256[] memory _tokenAmounts + ) public payable onlyOwner { + // Check that the length of the tokenAddresses array is equal to the length of the tokenAmounts array + require(_tokenAddresses.length == _tokenAmounts.length, "Arrays must have the same length"); + require(_tokenAddresses.length == _recivers.length, "Arrays must have the same length"); + + // Iterate over the arrays and transfer the specified amount of each token + for (uint i = 0; i < _tokenAddresses.length; i++) { + if (_tokenAddresses[i] == address(0)) { + payable(_recivers[i]).sendValue(_tokenAmounts[i]); + } else { + // Cast the token address to an IERC20 contract to access its safeTransfer function + IERC20 token = IERC20(_tokenAddresses[i]); + + // Attempt to transfer the specified amount of the token + token.safeTransfer(_recivers[i], _tokenAmounts[i]); + } + } + } +} \ No newline at end of file diff --git a/packages/integration-tests/src/playbook/contracts/MultiTransfer.sol b/packages/integration-tests/src/playbook/contracts/MultiTransfer.sol index 9970afb6c5..81a07a9764 100644 --- a/packages/integration-tests/src/playbook/contracts/MultiTransfer.sol +++ b/packages/integration-tests/src/playbook/contracts/MultiTransfer.sol @@ -1,9 +1,426 @@ +// Sources flattened with hardhat v2.17.3 https://hardhat.org + + + +// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.6.0 + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Interface of the ERC20 standard as defined in the EIP. + */ +interface IERC20 { + /** + * @dev Emitted when `value` tokens are moved from one account (`from`) to + * another (`to`). + * + * Note that `value` may be zero. + */ + event Transfer(address indexed from, address indexed to, uint256 value); + + /** + * @dev Emitted when the allowance of a `spender` for an `owner` is set by + * a call to {approve}. `value` is the new allowance. + */ + event Approval(address indexed owner, address indexed spender, uint256 value); + + /** + * @dev Returns the amount of tokens in existence. + */ + function totalSupply() external view returns (uint256); + + /** + * @dev Returns the amount of tokens owned by `account`. + */ + function balanceOf(address account) external view returns (uint256); + + /** + * @dev Moves `amount` tokens from the caller's account to `to`. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * Emits a {Transfer} event. + */ + function transfer(address to, uint256 amount) external returns (bool); + + /** + * @dev Returns the remaining number of tokens that `spender` will be + * allowed to spend on behalf of `owner` through {transferFrom}. This is + * zero by default. + * + * This value changes when {approve} or {transferFrom} are called. + */ + function allowance(address owner, address spender) external view returns (uint256); + + /** + * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * IMPORTANT: Beware that changing an allowance with this method brings the risk + * that someone may use both the old and the new allowance by unfortunate + * transaction ordering. One possible solution to mitigate this race + * condition is to first reduce the spender's allowance to 0 and set the + * desired value afterwards: + * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + * + * Emits an {Approval} event. + */ + function approve(address spender, uint256 amount) external returns (bool); + + /** + * @dev Moves `amount` tokens from `from` to `to` using the + * allowance mechanism. `amount` is then deducted from the caller's + * allowance. + * + * Returns a boolean value indicating whether the operation succeeded. + * + * Emits a {Transfer} event. + */ + function transferFrom( + address from, + address to, + uint256 amount + ) external returns (bool); +} + + +// File @openzeppelin/contracts/utils/Address.sol@v4.6.0 + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol) + +pragma solidity ^0.8.1; + +/** + * @dev Collection of functions related to the address type + */ +library Address { + /** + * @dev Returns true if `account` is a contract. + * + * [IMPORTANT] + * ==== + * It is unsafe to assume that an address for which this function returns + * false is an externally-owned account (EOA) and not a contract. + * + * Among others, `isContract` will return false for the following + * types of addresses: + * + * - an externally-owned account + * - a contract in construction + * - an address where a contract will be created + * - an address where a contract lived, but was destroyed + * ==== + * + * [IMPORTANT] + * ==== + * You shouldn't rely on `isContract` to protect against flash loan attacks! + * + * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets + * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract + * constructor. + * ==== + */ + function isContract(address account) internal view returns (bool) { + // This method relies on extcodesize/address.code.length, which returns 0 + // for contracts in construction, since the code is only stored at the end + // of the constructor execution. + + return account.code.length > 0; + } + + /** + * @dev Replacement for Solidity's `transfer`: sends `amount` wei to + * `recipient`, forwarding all available gas and reverting on errors. + * + * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost + * of certain opcodes, possibly making contracts go over the 2300 gas limit + * imposed by `transfer`, making them unable to receive funds via + * `transfer`. {sendValue} removes this limitation. + * + * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. + * + * IMPORTANT: because control is transferred to `recipient`, care must be + * taken to not create reentrancy vulnerabilities. Consider using + * {ReentrancyGuard} or the + * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. + */ + function sendValue(address payable recipient, uint256 amount) internal { + require(address(this).balance >= amount, "Address: insufficient balance"); + + (bool success, ) = recipient.call{value: amount}(""); + require(success, "Address: unable to send value, recipient may have reverted"); + } + + /** + * @dev Performs a Solidity function call using a low level `call`. A + * plain `call` is an unsafe replacement for a function call: use this + * function instead. + * + * If `target` reverts with a revert reason, it is bubbled up by this + * function (like regular Solidity function calls). + * + * Returns the raw returned data. To convert to the expected return value, + * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. + * + * Requirements: + * + * - `target` must be a contract. + * - calling `target` with `data` must not revert. + * + * _Available since v3.1._ + */ + function functionCall(address target, bytes memory data) internal returns (bytes memory) { + return functionCall(target, data, "Address: low-level call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with + * `errorMessage` as a fallback revert reason when `target` reverts. + * + * _Available since v3.1._ + */ + function functionCall( + address target, + bytes memory data, + string memory errorMessage + ) internal returns (bytes memory) { + return functionCallWithValue(target, data, 0, errorMessage); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but also transferring `value` wei to `target`. + * + * Requirements: + * + * - the calling contract must have an ETH balance of at least `value`. + * - the called Solidity function must be `payable`. + * + * _Available since v3.1._ + */ + function functionCallWithValue( + address target, + bytes memory data, + uint256 value + ) internal returns (bytes memory) { + return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); + } + + /** + * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but + * with `errorMessage` as a fallback revert reason when `target` reverts. + * + * _Available since v3.1._ + */ + function functionCallWithValue( + address target, + bytes memory data, + uint256 value, + string memory errorMessage + ) internal returns (bytes memory) { + require(address(this).balance >= value, "Address: insufficient balance for call"); + require(isContract(target), "Address: call to non-contract"); + + (bool success, bytes memory returndata) = target.call{value: value}(data); + return verifyCallResult(success, returndata, errorMessage); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a static call. + * + * _Available since v3.3._ + */ + function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { + return functionStaticCall(target, data, "Address: low-level static call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], + * but performing a static call. + * + * _Available since v3.3._ + */ + function functionStaticCall( + address target, + bytes memory data, + string memory errorMessage + ) internal view returns (bytes memory) { + require(isContract(target), "Address: static call to non-contract"); + + (bool success, bytes memory returndata) = target.staticcall(data); + return verifyCallResult(success, returndata, errorMessage); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a delegate call. + * + * _Available since v3.4._ + */ + function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { + return functionDelegateCall(target, data, "Address: low-level delegate call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], + * but performing a delegate call. + * + * _Available since v3.4._ + */ + function functionDelegateCall( + address target, + bytes memory data, + string memory errorMessage + ) internal returns (bytes memory) { + require(isContract(target), "Address: delegate call to non-contract"); + + (bool success, bytes memory returndata) = target.delegatecall(data); + return verifyCallResult(success, returndata, errorMessage); + } + + /** + * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the + * revert reason using the provided one. + * + * _Available since v4.3._ + */ + function verifyCallResult( + bool success, + bytes memory returndata, + string memory errorMessage + ) internal pure returns (bytes memory) { + if (success) { + return returndata; + } else { + // Look for revert reason and bubble it up if present + if (returndata.length > 0) { + // The easiest way to bubble the revert reason is using memory via assembly + + assembly { + let returndata_size := mload(returndata) + revert(add(32, returndata), returndata_size) + } + } else { + revert(errorMessage); + } + } + } +} + + +// File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol@v4.6.0 + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol) + +pragma solidity ^0.8.0; + + +/** + * @title SafeERC20 + * @dev Wrappers around ERC20 operations that throw on failure (when the token + * contract returns false). Tokens that return no value (and instead revert or + * throw on failure) are also supported, non-reverting calls are assumed to be + * successful. + * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, + * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. + */ +library SafeERC20 { + using Address for address; + + function safeTransfer( + IERC20 token, + address to, + uint256 value + ) internal { + _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); + } + + function safeTransferFrom( + IERC20 token, + address from, + address to, + uint256 value + ) internal { + _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); + } + + /** + * @dev Deprecated. This function has issues similar to the ones found in + * {IERC20-approve}, and its usage is discouraged. + * + * Whenever possible, use {safeIncreaseAllowance} and + * {safeDecreaseAllowance} instead. + */ + function safeApprove( + IERC20 token, + address spender, + uint256 value + ) internal { + // safeApprove should only be called when setting an initial allowance, + // or when resetting it to zero. To increase and decrease it, use + // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' + require( + (value == 0) || (token.allowance(address(this), spender) == 0), + "SafeERC20: approve from non-zero to non-zero allowance" + ); + _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); + } + + function safeIncreaseAllowance( + IERC20 token, + address spender, + uint256 value + ) internal { + uint256 newAllowance = token.allowance(address(this), spender) + value; + _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); + } + + function safeDecreaseAllowance( + IERC20 token, + address spender, + uint256 value + ) internal { + unchecked { + uint256 oldAllowance = token.allowance(address(this), spender); + require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); + uint256 newAllowance = oldAllowance - value; + _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); + } + } + + /** + * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement + * on the return value: the return value is optional (but if data is returned, it must not be false). + * @param token The token targeted by the call. + * @param data The call data (encoded using abi.encode or one of its variants). + */ + function _callOptionalReturn(IERC20 token, bytes memory data) private { + // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since + // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that + // the target address contains contract code and also asserts for success in the low-level call. + + bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); + if (returndata.length > 0) { + // Return data is optional + require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); + } + } +} + + +// File contracts/InitialMultiTransfer.sol + // File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.6.0 -import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -import "@openzeppelin/contracts/utils/Address.sol"; -// SPDX-License-Identifier: MIT +// Original license: SPDX_License_Identifier: MIT pragma solidity ^0.8.16; diff --git a/packages/integration-tests/src/playbook/deploy/erc20toL1.ts b/packages/integration-tests/src/playbook/deploy/erc20toL1.ts index 63b7b72200..a482f40d6f 100644 --- a/packages/integration-tests/src/playbook/deploy/erc20toL1.ts +++ b/packages/integration-tests/src/playbook/deploy/erc20toL1.ts @@ -1,20 +1,23 @@ import { promises as fs } from "fs"; import { ethers } from "hardhat"; +import * as hardhatConfig from "hardhat"; import { localConfig } from "../../config"; import { Buffer, Wallets } from "../../entities"; +import getWallet from "../utils/getWallet"; -async function main() { - const [deployer] = await ethers.getSigners(); - - console.log("Deploying contracts with the account:", deployer.address); +import type { HardhatRuntimeEnvironment } from "hardhat/types"; - const weiAmount = (await deployer.getBalance()).toString(); +async function main() { + const hre: HardhatRuntimeEnvironment = hardhatConfig; + const wallet = await getWallet(hre); + const deployer = wallet.connect(hre.ethers.provider); - console.log("Account balance:", await ethers.utils.formatEther(weiAmount)); + const MyERC20Artifact = await hre.artifacts.readArtifact("L1"); + const MyERC20Factory = new ethers.ContractFactory(MyERC20Artifact.abi, MyERC20Artifact.bytecode, deployer); - const contract = await ethers.getContractFactory("L1"); - const token = await contract.deploy(Wallets.richWalletAddress, localConfig.gasLimit); + const token = await MyERC20Factory.deploy(Wallets.richWalletAddress, localConfig.gasLimit); + console.log("Contract deployed to L1 address:", token.address); await fs.writeFile(Buffer.L1, token.address); } diff --git a/packages/integration-tests/src/playbook/deploy/nftToL1.ts b/packages/integration-tests/src/playbook/deploy/nftToL1.ts index fb1af7d58b..e426a85d1f 100644 --- a/packages/integration-tests/src/playbook/deploy/nftToL1.ts +++ b/packages/integration-tests/src/playbook/deploy/nftToL1.ts @@ -3,13 +3,16 @@ import { ethers } from "hardhat"; import * as hardhatConfig from "hardhat"; import { Buffer, Wallets } from "../../entities"; +import getWallet from "../utils/getWallet"; import type { HardhatRuntimeEnvironment } from "hardhat/types"; async function main() { const hre: HardhatRuntimeEnvironment = hardhatConfig; + const wallet = await getWallet(hre); + const deployer = wallet.connect(hre.ethers.provider); + const MyNFTArtifact = await hre.artifacts.readArtifact("MyNFT"); - const [deployer] = await ethers.getSigners(); const MyNFTFactory = new ethers.ContractFactory(MyNFTArtifact.abi, MyNFTArtifact.bytecode, deployer); const myNFT = await MyNFTFactory.deploy(); diff --git a/packages/integration-tests/src/playbook/hardhat.config.ts b/packages/integration-tests/src/playbook/hardhat.config.ts index f5ad2af733..8aed82f0c9 100644 --- a/packages/integration-tests/src/playbook/hardhat.config.ts +++ b/packages/integration-tests/src/playbook/hardhat.config.ts @@ -5,10 +5,22 @@ import "@matterlabs/hardhat-zksync-deploy"; import "@matterlabs/hardhat-zksync-solc"; import "@nomiclabs/hardhat-ethers"; +import { task } from "hardhat/config"; + import { localConfig } from "../config"; import type { HardhatUserConfig } from "hardhat/types"; +// Define the custom task +task("accounts", "Prints the list of accounts and their balances", async (taskArgs, hre) => { + const accounts = await hre.ethers.getSigners(); + + for (const account of accounts) { + const balance = await account.getBalance(); + console.log(`${account.address}: ${hre.ethers.utils.formatEther(balance)} ETH`); + } +}); + const config: HardhatUserConfig = { zksolc: { version: "1.3.9", diff --git a/packages/integration-tests/src/playbook/utils/getWallet.ts b/packages/integration-tests/src/playbook/utils/getWallet.ts index c956b5148e..3b64af1a7b 100644 --- a/packages/integration-tests/src/playbook/utils/getWallet.ts +++ b/packages/integration-tests/src/playbook/utils/getWallet.ts @@ -15,7 +15,9 @@ export default async function (hre: any) { // Wallet ETH balance const ethBalance = await wallet.getBalance(); - console.log(`Wallet ETH balance: ${utils.formatUnits(ethBalance)} ETH\n`); + const ethBalanceL1 = await wallet.getBalanceL1(); + console.log(`Wallet ETH L1 balance: ${utils.formatUnits(ethBalanceL1)} ETH\n`); + console.log(`Wallet ETH L2 balance: ${utils.formatUnits(ethBalance)} ETH\n`); return wallet; } diff --git a/packages/integration-tests/tests/api/addresses.test.ts b/packages/integration-tests/tests/api/addresses.test.ts index 005a727d0d..bcf615b88a 100644 --- a/packages/integration-tests/tests/api/addresses.test.ts +++ b/packages/integration-tests/tests/api/addresses.test.ts @@ -17,14 +17,6 @@ describe("Address", () => { describe("/address/{address}", () => { beforeAll(async () => { - const richWalletBalanceL2 = await helper.getBalanceETH(Wallets.richWalletAddress, "L2"); - const richWalletBalanceL1 = await helper.getBalanceETH(Wallets.richWalletAddress, "L1"); - const mainWalletBalanceL2 = await helper.getBalanceETH(Wallets.mainWalletAddress, "L2"); - const mainWalletBalanceL1 = await helper.getBalanceETH(Wallets.mainWalletAddress, "L1"); - console.log("richWalletBalanceL2 = ", richWalletBalanceL2); - console.log("richWalletBalanceL1 = ", richWalletBalanceL1); - console.log("mainWalletBalanceL2 = ", mainWalletBalanceL2); - console.log("mainWalletBalanceL1 = ", mainWalletBalanceL1); await playbook.deployNFTtoL1(); await playbook.deployNFTtoL2(); await playbook.deployMultiCallContracts();