সলিডিটি চিটশিট

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
 
contract MyContract {
    // কোড এখানে
}

uint256 public count = 100;
address public owner = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
string public greeting = "হ্যালো!";

function functionName(uint param) public returns (uint) {
    return param * 2;
}

contract Example {
    address public owner;
 
    constructor() {
        owner = msg.sender;
    }
 
    receive() external payable {}
}

modifier onlyOwner() {
    require(msg.sender == owner, "শুধু মালিক!");
    _;
}
 
function restricted() public onlyOwner {
    // কোড
}

uint[] public numbers;
 
function addNumber(uint _num) public {
    numbers.push(_num);
}
 
function getNumber(uint index) public view returns (uint) {
    return numbers[index];
}

mapping(address => uint) public balances;
 
function updateBalance(uint _amount) public {
    balances[msg.sender] = _amount;
}
 
function getBalance(address _addr) public view returns (uint) {
    return balances[_addr];
}

struct User {
    string name;
    uint age;
    address addr;
}
 
User[] public users;
 
function addUser(string memory _name, uint _age) public {
    users.push(User(_name, _age, msg.sender));
}

enum Status { Pending, Approved, Rejected }
 
Status public currentStatus;
 
function setStatus(Status _status) public {
    currentStatus = _status;
}

event Transfer(address indexed from, address indexed to, uint amount);
 
function transfer(address _to, uint _amount) public {
    emit Transfer(msg.sender, _to, _amount);
}

uint public price = 1 ether; // 10^18 wei
 
function sendEther() public payable {
    require(msg.value >= price, "অপর্যাপ্ত ইথার!");
}

contract Parent {
    uint public value = 10;
 
    function getValue() public virtual returns (uint) {
        return value;
    }
}
 
contract Child is Parent {
    function getValue() public override returns (uint) {
        return value * 2;
    }
}

interface IExternal {
    function getData() external returns (uint);
}
 
contract Caller {
    function callExternal(address _contract) public returns (uint) {
        IExternal ext = IExternal(_contract);
        return ext.getData();
    }
}

bool private locked;
 
modifier nonReentrant() {
    require(!locked, "Reentrancy নিষিদ্ধ!");
    locked = true;
    _;
    locked = false;
}
 
function withdraw() public nonReentrant {
    payable(msg.sender).transfer(address(this).balance);
}

function safeWithdraw(uint _amount) public {
    require(balances[msg.sender] >= _amount, "অপর্যাপ্ত ব্যালেন্স!");
    balances[msg.sender] -= _amount; // ইফেক্ট
    payable(msg.sender).transfer(_amount); // ইন্টারঅ্যাকশন
}

library Math {
    function add(uint a, uint b) internal pure returns (uint) {
        return a + b;
    }
}
 
contract MyContract {
    using Math for uint;
 
    function sum(uint x, uint y) public pure returns (uint) {
        return x.add(y);
    }
}

const { expect } = require("chai");
 
describe("MyContract", function () {
  it("should set owner", async function () {
    const MyContract = await ethers.getContractFactory("MyContract");
    const contract = await MyContract.deploy();
    await contract.deployed();
    expect(await contract.owner()).to.equal(await ethers.provider.getSigner(0).getAddress());
  });
});

require(x > 0, "শূন্যের বেশি হতে হবে!");

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
 
contract CrowdFunding {
    address public owner;
    uint public goal;
    uint public totalRaised;
    mapping(address => uint) public contributions;
    bool public fundingActive;
 
    event Contribution(address indexed contributor, uint amount);
    event GoalReached(uint totalRaised);
 
    modifier onlyOwner() {
        require(msg.sender == owner, "শুধু মালিক!");
        _;
    }
 
    constructor(uint _goal) {
        owner = msg.sender;
        goal = _goal;
        fundingActive = true;
    }
 
    function contribute() public payable {
        require(fundingActive, "ফান্ডিং বন্ধ!");
        require(msg.value > 0, "অপর্যাপ্ত ইথার!");
 
        contributions[msg.sender] += msg.value;
        totalRaised += msg.value;
 
        emit Contribution(msg.sender, msg.value);
 
        if (totalRaised >= goal) {
            fundingActive = false;
            emit GoalReached(totalRaised);
        }
    }
 
    function withdraw() public onlyOwner {
        require(!fundingActive, "ফান্ডিং চলছে!");
        payable(owner).transfer(address(this).balance);
    }
 
    function getBalance() public view returns (uint) {
        return address(this).balance;
    }
 
    receive() external payable {
        contribute();
    }
}

contract MultiSigWallet {
    address[] public owners;
    uint public required;
    mapping(address => bool) public isOwner;
 
    constructor(address[] memory _owners, uint _required) {
        require(_owners.length >= _required, "অপর্যাপ্ত মালিক!");
        owners = _owners;
        required = _required;
        for (uint i = 0; i < _owners.length; i++) {
            isOwner[_owners[i]] = true;
        }
    }
}

contract MyToken {
    string public name = "MyToken";
    string public symbol = "MTK";
    uint8 public decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
 
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
 
    constructor(uint256 _initialSupply) {
        totalSupply = _initialSupply * 10 ** decimals;
        balanceOf[msg.sender] = totalSupply;
    }
 
    function transfer(address _to, uint256 _value) public returns (bool) {
        require(balanceOf[msg.sender] >= _value, "অপর্যাপ্ত ব্যালেন্স!");
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;
        emit Transfer(msg.sender, _to, _value);
        return true;
    }
 
    function approve(address _spender, uint256 _value) public returns (bool) {
        allowance[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }
 
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
        require(balanceOf[_from] >= _value, "অপর্যাপ্ত ব্যালেন্স!");
        require(allowance[_from][msg.sender] >= _value, "অনুমতি নেই!");
        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        allowance[_from][msg.sender] -= _value;
        emit Transfer(_from, _to, _value);
        return true;
    }
}

/// @notice এই ফাংশন ব্যালেন্স চেক করে
/// @param _addr ইউজারের ঠিকানা
/// @return ব্যালেন্স
function getBalance(address _addr) public view returns (uint) {
    return balances[_addr];
}