Skip to content

Instantly share code, notes, and snippets.

@aalimsahin

aalimsahin/Secureum.sol

Last active February 16, 2022 12:44
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save aalimsahin/654fe7618295090bd24235558133d10c to your computer and use it in GitHub Desktop.
Save aalimsahin/654fe7618295090bd24235558133d10c to your computer and use it in GitHub Desktop.
Download ZIP
Secureum 201
Raw
Secureum.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// contract A {
// function foo() virtual public pure returns (string memory) {
// return "A'nin Foo'su";
// }
// function bor() virtual public pure returns (string memory) {
// return "A'nin Bor'u";
// }
// function a() virtual public pure returns (string memory) {
// return "special A";
// }
// }
// contract B {
// function foo() virtual public pure returns (string memory) {
// return "B'nin Foo'su";
// }
// function bor() virtual public pure returns (string memory) {
// return "B'nin Bor'u";
// }
// function b() virtual public pure returns (string memory) {
// return "special b";
// }
// }
// contract C is B, A{
// function foo() virtual override(A,B) public pure returns (string memory) {
// return super.foo();
// }
// function bor() virtual override(B,A) public pure returns (string memory) {
// return super.bor();
// }
// function c() virtual public pure returns (string memory) {
// return "special c";
// }
// }
// contract A {
// function foo() virtual public pure returns (string memory) {
// return "A'nin Foo'su";
// }
// function bor() virtual public pure returns (string memory) {
// return "A'nin Bor'u";
// }
// function a() virtual public pure returns (string memory) {
// return "special A";
// }
// }
// contract B is A{
// function foo() virtual override public pure returns (string memory) {
// return "B'nin Foo'su";
// }
// function bor() virtual override public pure returns (string memory) {
// return "B'nin Bor'u";
// }
// function b() virtual public pure returns (string memory) {
// return "special b";
// }
// }
// contract C is B {
// // function foo() virtual override public pure returns (string memory) {
// // return super.foo();
// // }
// // function bor() virtual override public pure returns (string memory) {
// // return super.bor();
// // }
// function c() virtual public pure returns (string memory) {
// return "special c";
// }
// }
// Tüm kontratlar tek bir kontrat gibi derlenir.
// Abstract Contract
//Herhangi bir fonksiyonun hali hazırda implement edilmediği durumlarda kullanılır.
// abstract contract A {
// function foo() public virtual pure returns(string memory) {}
// }
// contract B is A {
// function foo() public virtual override pure returns(string memory) {
// return "B";
// }
// }
// Interface
// interface Token {
// // Baska bir interface'den miras alabilir
// // Bütün fonksiyonlar external olmak zorundadır.
// // constructor, modifier, state variables tanımlanmaz.
// // ABI olarak düşünebiliriz.
// enum TokenType { Fungible, NonFungible }
// struct Coin { string obverse; string reverse; }
// function transfer(address recipient, uint amount) external;
// }
// contract Counter {
// uint public count;
// function increment() external {
// count += 1;
// }
// }
// interface ICounter {
// function count() external view returns (uint);
// function increment() external;
// }
// contract MyContract {
// function incrementCounter(address _counter) external {
// ICounter(_counter).increment();
// }
// function getCount(address _counter) external view returns (uint) {
// return ICounter(_counter).count();
// }
// }
// Library
// Belirli bir adrese yalnızca bir kez dağıtılırlar ve kodları DELEGATECALL işlem kodu kullanılarak yeniden kullanılır.
// Eğer library içerisindeki tüm fonksiyonlar internal ise DelegateCall' ile değil normal fonksiyon gibi çağrı yapılır.
// Library'i kontrat ile deploy edilir.
// Eğer tüm fonksiyonlar internal değil ise library de deploy edilir ve fonksiyonları delegatecall ile çağrılır.
// for more: https://medium.com/coinmonks/all-you-should-know-about-libraries-in-solidity-dd8bc953eae7
// import LibraryName from “./library-file.sol”;
// library Human {
// struct Person {
// uint age;
// }
// function birthday(Person storage _person) public {
// _person.age += 1;
// }
// function showAge(Person storage _person) public view returns(uint) {
// return _person.age;
// }
// }
// contract HumanContract {
// mapping(uint => Human.Person) people;
// function newYear() public {
// Human.birthday(people[0]);
// }
// function show() public view returns(uint) {
// return Human.showAge(people[0]);
// }
// }
// library Search {
// function indexOf(uint[] memory list, uint data) public pure returns(uint) {
// for (uint i = 0; i < list.length; i++) {
// if (list[i] == data) {
// return i;
// }
// }
// return list.length;
// }
// }
// contract Library {
// using Math for uint;
// using Search for uint[];
// function trial1(uint[] memory x, uint y) public pure returns(uint) {
// return x.indexOf(y); // Search.indexOf(x,y) Math.plus(x,y);
// }
// }
// 105
// contract A {
// function foo() virtual public pure returns (string memory) {
// return "A'nin Foo'su";
// }
// function bor() virtual public pure returns (string memory) {
// return "A'nin Bor'u";
// }
// }
// contract B is A{
// function foo() virtual override public pure returns (string memory) {
// return "B'nin Foo'su";
// }
// function bor() virtual override public pure returns (string memory) {
// return "B'nin Bor'u";
// }
// }
// contract C is B {
// function foo() virtual override public pure returns (string memory) {
// return A.foo();
// }
// function bor() virtual override public pure returns (string memory) {
// return super.bor();
// }
// }
// 106
// contract A {
// string public name = "Contract A";
// function getName() public view returns (string memory) {
// return name;
// }
// }
// // Shadowing is disallowed in Solidity 0.6
// // This will not compile
// // contract B is A {
// // string public name = "Contract B";
// // }
// contract C is A {
// // This is the correct way to override inherited state variables.
// constructor() {
// name = "Contract C";
// }
// // C.getName returns "Contract C"
// }
// 107
// external to public
// contract A {
// function foo() virtual external pure returns (string memory) {
// return "A'nin Foo'su";
// }
// }
// contract B is A{
// function foo() virtual override public pure returns (string memory) {
// return "B'nin Foo'su";
// }
// }
// view to pure
// contract A {
// uint public x = 7;
// function foo() virtual public returns(uint) {
// return x;
// }
// }
// contract B is A{
// function foo() virtual override pure public returns(uint) {
// return 9;
// }
// }
// 109
//?
// 110
// contract A {
// uint public x;
// address owner;
// constructor() {
// owner = msg.sender;
// }
// function inc() virtual onlyOwner public {
// x += 1;
// }
// modifier onlyOwner virtual {
// require(msg.sender == owner, "not owner");
// _;
// }
// }
// contract B is A {
// modifier onlyOwner override {
// require(msg.sender == owner, "not owner");
// require(x < 10,"enough");
// _;
// }
// }
// 111
// contract A {
// uint public a;
// constructor(uint _a) {
// a = _a;
// }
// }
// contract B {
// uint public b;
// constructor(uint _b) {
// b = _b;
// }
// }
// contract C is A, B {
// uint public c;
// constructor(uint _c, uint _b, uint _a) A(_a) B(_b) {
// c = _c;
// }
// }
// contract C is A(1), B(2) {
// uint public c;
// constructor(uint _c ) {
// c = _c;
// }
// }
contract A {
uint public a;
constructor(uint _a) {
a = _a;
}
}
contract B is A {
uint public b;
constructor(uint _b, uint _a) A(_a) {
b = _b;
}
}
contract C is B {
uint public c;
constructor(uint _c, uint _b, uint _a) B(_b, _a) {
c = _c;
}
}
// 112
// Inheritance sebebiyle isimlendirme hataları
// 1) a function and a modifier
// 2) a function and an event
// 3) an event and a modifier
// 1) a function and a modifier
// contract A {
// uint public a;
// constructor(uint _a) {
// a = _a;
// }
// function inc() aModifier public {
// a += 1;
// }
// modifier aModifier {
// require(a>10,"its enoung");
// _;
// }
// }
// contract B is A(2){
// uint public b;
// constructor(uint _b) {
// b = _b;
// }
// function aModifier() public {
// b += 1;
// }
// }
// 2) a function and an event
// contract A {
// uint public a;
// constructor(uint _a) {
// a = _a;
// }
// function inc() public {
// a += 1;
// emit aEvent(a);
// }
// event aEvent(uint _a);
// }
// contract B is A(2){
// uint public b;
// constructor(uint _b) {
// b = _b;
// }
// function aEvent() public {
// b += 1;
// }
// }
// 3) an event and a modifier
// contract A {
// uint public a;
// constructor(uint _a) {
// a = _a;
// }
// function inc() aModifier public {
// a += 1;
// }
// modifier aModifier {
// require(a>10,"its enoung");
// _;
// }
// }
// contract B is A(2){
// uint public b;
// constructor(uint _b) {
// b = _b;
// }
// function inc2() public {
// b += 1;
// emit aModifierr(b);
// }
// event aModifier(uint result);
// }
// 113
// Library'nin Contract'lardan farkı
// 1- state variables tutamazlar
// 2- Miras alamazlar
// 3- Ether alamazlar
// 4- Yok edilemezler
// 5- State değişkeni direk verilmez ise ulaşamazlar
// 6- State variables da bir değişiklik yoksa DelegateCall çağrılmadan library elemanlarına ulaşabiliriz.
// 6: library deploy etme noktasında iki senaryo var:
// 6a-Yalnızca internal functions: EVM libraryi yalnızca sözleşmeye gömer. Bir işlevi çağırmak için delegatecall yerine normal methodcall kullanır. Bu senaryoda kitaplığı ayrı olarak dağıtmaya gerek yoktur.
// 6b- Bir library public veya external işlevler içeriyorsa, kitaplığın dağıtılması gerekir. library konuşlandırılması, blok zincirinde benzersiz bir adres üretecektir. Bu adres ile iletişim kurulur
// 114
// ?
// 115
// Dinamic Array ve Mappingler dışında veriler ortak slotlarda depolanabilir.
// struct x {
// uint256 a; // 1
// uint128 b; // 2
// uint64 c; // 2
// uint64 d; // 2
// }
// 116
// 32 bytes yerimiz var
// Dizilim kuralları:
// - hizalanmış olarak depolanır ?
// - verilerimiz gerekli olan yer kadar yer kaplar
// - yer kalmaz ise bir sonraki slota geçilir
// 117 ?
// struct ve array şu kurallara göre her zaman yeni bir slot başlatır
// - struct ve arrayi takip eden veriler her zaman yeni slot oluşturur
// - struct ve arrayin verileri sanki tek tek bir değermiş gibi depolanır
// 118
// https://en.wikipedia.org/wiki/C3_linearization#:~:text=The%20C3%20superclass%20linearization%20of,order%20of%20direct%20parent%20classes.
// 119
// first 120 then here
// contract A { // 188235
// uint256 public a = 1; // 23471
// uint128 public b = 2;
// uint128 public c = 3; // 23607
// }
// contract B { // 209625
// uint128 public a = 1;
// uint256 public b = 2;
// uint128 public c = 3; //23557
// }
// 120
//When using elements that are smaller than 32 bytes,
//your contract’s gas usage may be higher.
//This is because the EVM operates on 32 bytes at a time.
//Therefore, if the element is smaller than that,
//the EVM must use more operations in order to reduce
//the size of the element from 32 bytes to the desired size.
// contract A { // 89240
// uint256 a = 10;
// }
// contract B { // 90109
// uint128 a = 10;
// }
// contract A { // 113532
// uint256 a = 10;
// uint128 b = 13;
// uint128 c = 12;
// }
// contract B { // 135366
// uint128 a = 12;
// uint256 b = 10;
// uint128 c = 13;
// }
// contract A { // 115021
// struct X {
// uint256 a;
// uint128 b;
// uint128 c;
// }
// X x = X(1,2,3);
// }
// contract B { // 136847
// struct X {
// uint128 a;
// uint256 b;
// uint128 c;
// }
// X x = X(1,2,3);
// }
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment