samigabor / expert-solidity-bootcamp-ctf Goto Github PK

{
  "optimizer": {
    "enabled": true,
    "runs": 10000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

forge create \
  --rpc-url $RPC_URL_SEPOLIA \
  --optimizer-runs 10000 \
  --private-key $PRIVATE_KEY \
  src/level.sol:LevelTemplate

forge verify-contract \
  --chain-id 11155111 \
  --watch \
  --etherscan-api-key $ETHERSCAN_API_KEY \
  --optimizer-runs 10000 \
  <contract-address> \
  src/level.sol:LevelTemplate

For each level you will be asked to write a smart contract based on the given interface. You are free to write the solution as you see fit as long as your contract adheres to the contract interface. In practice this means, for most levels, you will be given an empty function and asked to write the logic. Once you have written your solution you will need to deploy the contract and submit the address to receive a score.

This level is really simple. Use the interface below to write a smart contract. Your contract should contain a function called solution that returns a uint8. In this case the function body logic is very simply as the answer is always 42.

interface Isolution {
  function solution() external pure returns (uint8);
}

Write a function that adds two matrices returns the result. To keep things simple the array sizes will be fixed sizes of 2x3 (uint256[2][3]). Take a look at Wikipedia if you need help understanding matrix addition. Your solution should implement the following interface:

interface Isolution1 {
  function solution(uint256[2][3] calldata x, uint256[2][3] calldata y) external pure returns (uint256[2][3] memory);
}

Write a function that sorts an array in ascending order and returns the result. The array will be a fixed of 10 but the contents random. Your solution should implement the following interface:

interface Isolution2 {
  function solution(uint256[10] calldata unsortedArray) external returns (uint256[10] memory sortedArray);
}

Using the Isolution3 interface write a function that unpacks our data that was packed using abi.encodePacked(a, b, c). Where a is type uint16, b is type bool and c is type bytes6.

interface Isolution3 {
  function solution(bytes memory packed) external returns (uint16 a, bool b, bytes6 c);
}

Using the Isolution4 interface write a function that takes a uint256 value and returns the greatest power of 2, (2 ^ n) that is less than or equal to the input value. The input value is a number between 2^0 and 2^256 -1

// stdin: 1                     stdout: 1 or 2**0
// stdin: 10                    stdout: 8 or 2**3
// stdin: 21                    stdout: 16 or 2**4
// stdin: 2048                  stdout: 2048 or 2**11
// stdin: 9223372036854775808   stdout: 9223372036854775808 or 2**63
// stdin: 0xffffffff            stdout: 2147483648 or 0x80000000 or 2**31
interface Isolution {
  function solution(uint256 number) external pure returns (uint256);
}

Using the Isolution5 interface calculate the average of two values int256 a and int256 b. You will need to write an overflow-free method that will round up the average of (a + b) / 2. Keep in mind that we are rounding up (ceil) and NOT rounding down (floor). Floor = rounding towards zero while Ceil = rounding away from zero see examples on wikipedia

interface Isolution5 {
    function solution(int256 a, int256 b) external pure returns (int256);
}