package-installer-cli 2.3.0 → 2.4.0

data/bundle-standalone/templates/web3/solidity/solidity-learning/18_imports/Contract2.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/importing-into-a-contract
+
+pragma solidity ^0.8.0;
+
+contract Contract2 {
+    function sum(uint256 a, uint256 b) public pure returns (uint256) {
+        return a + b;
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/19_contract_cleanup/Cleanup.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/contract-clean-up
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    address payable owner;
+
+    constructor() payable {
+        owner = payable(msg.sender);
+    }
+
+    function kill() public {
+        require(msg.sender == owner);
+        selfdestruct(owner);
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/20_memory_and_storage/MemoryAndStorage.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/memory-vs-storage
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    // Storage
+    string firstName;
+    string lastName;
+
+    constructor(string memory _firstName, string memory _lastName) {
+        firstName = _firstName;
+        lastName = _lastName;
+    }
+
+    function fullname() public view returns (string memory) {
+        return string(abi.encodePacked(lastName, " ", firstName));
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/21_inheritance/Inheritance.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/inheritance
+
+pragma solidity ^0.8.0;
+
+// Define an interface
+interface Regulator {
+    function checkValue(uint256 amount) external returns (bool);
+
+    function loan() external returns (bool);
+}
+
+// Implement the interface in a contract
+contract Bank is Regulator {
+    uint256 private value;
+    address private owner;
+
+    constructor(uint256 amount) {
+        value = amount;
+        owner = msg.sender;
+    }
+
+    function deposit(uint256 amount) public {
+        value += amount;
+    }
+
+    function withdraw(uint256 amount) public {
+        if (checkValue(amount)) {
+            value -= amount;
+        }
+    }
+
+    function balance() public view returns (uint256) {
+        return value;
+    }
+
+    function checkValue(uint256 amount) public view returns (bool) {
+        return amount >= value;
+    }
+
+    function loan() public view returns (bool) {
+        return value > 0;
+    }
+}
+
+// Inherit from the Bank contract
+contract MyContract is Bank(10) {
+    string private name;
+    uint256 private age;
+
+    function setName(string memory newName) public {
+        name = newName;
+    }
+
+    function getName() public view returns (string memory) {
+        return name;
+    }
+
+    function setAge(uint256 newAge) public {
+        age = newAge;
+    }
+
+    function getAge() public view returns (uint256) {
+        return age;
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/22_if_statement/if-statement.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/how-to-write-an-if-statement-in-solidity/
+
+pragma solidity ^0.8.0;
+
+contract MyContract {
+    // State variable to hold the symbol
+    string public symbol;
+
+    // Function to set the symbol based on the input number
+    function symbolNum(uint256 _symbolNum) public {
+        // If-else statement to determine the symbol
+        if (_symbolNum == 1) {
+            symbol = "BTC";
+        } else if (_symbolNum == 2) {
+            symbol = "ETH";
+        } else {
+            symbol = "CRAPCOIN";
+        }
+    }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/23_libraries/libraries.sol

@@ -0,0 +1,31 @@
+// Category: 23_libraries
+pragma solidity ^0.8.0;
+// SPDX-License-Identifier: MIT
+
+import "./safemath.sol";
+
+contract Libraries {
+    // Attach the library functions to the types
+    using SafeMath for uint256;
+    using SafeMath32 for uint32;
+
+    // Example variables
+    uint public a = 10;
+    uint public b = 20;
+
+    // Functions to demonstrate the use of library functions which add two big numbers
+    function add(uint _a, uint _b) public pure returns (uint) {
+        return _a.add(_b);
+    }
+    // Functions to demonstrate the use of library functions which add two small numbers
+    function sub(uint32 _a, uint32 _b) public pure returns (uint32) {
+        return _a.sub(_b);
+    }
+    function mul(uint32 _a, uint32 _b) public pure returns (uint32) {
+        return _a.mul(_b);
+    }
+    function div(uint32 _a, uint32 _b) public pure returns (uint32) {
+        return _a.div(_b);
+    }
+
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/23_libraries/safemath.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+/**
+ * @title SafeMath
+ * @dev Math operations with safety checks that throw on error
+ */
+library SafeMath {
+
+  /**
+  * @dev Multiplies two numbers, throws on overflow.
+  */
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    if (a == 0) {
+      return 0;
+    }
+    uint256 c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  /**
+  * @dev Integer division of two numbers, truncating the quotient.
+  */
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    // assert(b > 0); // Solidity automatically throws when dividing by 0
+    uint256 c = a / b;
+    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+    return c;
+  }
+
+  /**
+  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
+  */
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  /**
+  * @dev Adds two numbers, throws on overflow.
+  */
+  function add(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+/**
+ * @title SafeMath32
+ * @dev SafeMath library implemented for uint32
+ */
+library SafeMath32 {
+
+  function mul(uint32 a, uint32 b) internal pure returns (uint32) {
+    if (a == 0) {
+      return 0;
+    }
+    uint32 c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  function div(uint32 a, uint32 b) internal pure returns (uint32) {
+    // assert(b > 0); // Solidity automatically throws when dividing by 0
+    uint32 c = a / b;
+    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+    return c;
+  }
+
+  function sub(uint32 a, uint32 b) internal pure returns (uint32) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function add(uint32 a, uint32 b) internal pure returns (uint32) {
+    uint32 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}
+
+/**
+ * @title SafeMath16
+ * @dev SafeMath library implemented for uint16
+ */
+library SafeMath16 {
+
+  function mul(uint16 a, uint16 b) internal pure returns (uint16) {
+    if (a == 0) {
+      return 0;
+    }
+    uint16 c = a * b;
+    assert(c / a == b);
+    return c;
+  }
+
+  function div(uint16 a, uint16 b) internal pure returns (uint16) {
+    // assert(b > 0); // Solidity automatically throws when dividing by 0
+    uint16 c = a / b;
+    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+    return c;
+  }
+
+  function sub(uint16 a, uint16 b) internal pure returns (uint16) {
+    assert(b <= a);
+    return a - b;
+  }
+
+  function add(uint16 a, uint16 b) internal pure returns (uint16) {
+    uint16 c = a + b;
+    assert(c >= a);
+    return c;
+  }
+}

data/bundle-standalone/templates/web3/solidity/solidity-learning/24_interface/interface.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+//
+// https://cryptomarketpool.com/interface-in-solidity-smart-contracts/
+
+pragma solidity ^0.8.0;
+
+// Define the interface
+interface IERC20 {
+    // Methods that any contract implementing this interface must have
+    function totalSupply() external view returns (uint256);
+
+    function balanceOf(address account) external view returns (uint256);
+
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+
+    function approve(address spender, uint256 amount) external returns (bool);
+
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    // Events that any contract implementing this interface must emit
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+// Implement the interface in a contract
+contract MyContract is IERC20 {
+    // Token details
+    string public constant name = "ERC20Basic";
+    string public constant symbol = "ERC";
+    uint8 public constant decimals = 18;
+
+    // State variables
+    mapping(address => uint256) balances;
+    mapping(address => mapping(address => uint256)) allowed;
+    uint256 totalSupply_ = 10 ether;
+
+    // Constructor to assign the total supply to the contract deployer
+    constructor() {
+        balances[msg.sender] = totalSupply_;
+    }
+
+    function totalSupply() public view override returns (uint256) {
+        return totalSupply_;
+    }
+
+    function balanceOf(address tokenOwner) public view override returns (uint256) {
+        return balances[tokenOwner];
+    }
+
+    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[msg.sender]);
+        balances[msg.sender] = balances[msg.sender] - numTokens;
+        balances[receiver] = balances[receiver] + numTokens;
+        emit Transfer(msg.sender, receiver, numTokens);
+        return true;
+    }
+
+    function approve(address delegate, uint256 numTokens) public override returns (bool) {
+        allowed[msg.sender][delegate] = numTokens;
+        emit Approval(msg.sender, delegate, numTokens);
+        return true;
+    }
+
+    function allowance(address owner, address delegate) public view override returns (uint256) {
+        return allowed[owner][delegate];
+    }
+
+    function transferFrom(
+        address owner,
+        address buyer,
+        uint256 numTokens
+    ) public override returns (bool) {
+        require(numTokens <= balances[owner]);
+        require(numTokens <= allowed[owner][msg.sender]);
+
+        balances[owner] = balances[owner] - numTokens;
+        allowed[owner][msg.sender] = allowed[owner][msg.sender] + numTokens;
+        balances[buyer] = balances[buyer] + numTokens;
+        emit Transfer(owner, buyer, numTokens);
+        return true;
+    }
+}