[Solidity] Contract, Visibility와 Getter

Contract

• 객체 지향 언어의 클래스와 유사

Creating Contracts

• contract가 생성되면 생성자(constructor키워드와 선언된 함수)가 한 번 실행됨
• constructor은 선택 사항 -> default constructor
• constructor은 하나만 가능(오버로드가 지원되지 않음)
• constructor가 실행된 후, contract의 최종 코드가 블록체인에 저장됨

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.9.0;


contract OwnedToken {
    TokenCreator creator;
    address owner;
    bytes32 name;

    // 생성자
    constructor(bytes32 _name) {
        owner = msg.sender;

        creator = TokenCreator(msg.sender);
        name = _name;
    }

    function changeName(bytes32 newName) public {
        if (msg.sender == address(creator))
            name = newName;
    }

    function transfer(address newOwner) public {
        if (msg.sender != owner) return;

        if (creator.isTokenTransferOK(owner, newOwner))
            owner = newOwner;
    }
}

// constructor가 있지 않음
// default constructor
contract TokenCreator {
    function createToken(bytes32 name)
        public
        returns (OwnedToken tokenAddress)
    {새
        return new OwnedToken(name);
    }

    function changeName(OwnedToken tokenAddress, bytes32 name) public {
        tokenAddress.changeName(name);
    }

    function isTokenTransferOK(address currentOwner, address newOwner)
        public
        pure
        returns (bool ok)
    {
        return keccak256(abi.encodePacked(currentOwner, newOwner))[0] == 0x7f;
    }
}

Visibility and Getters

Solidity의 함수 호출 종류

• 내부 호출: 실제 EVM 호출을 생성하지 않음
• 외부 호출: 내부 호출을 실행

Visibility 종류

	Fuction	State Variable	note
external	O	X	external function: 다른 contract나 transaction을 통해 호출 가능 external function f는 this.f()를 통해 호출(f()는 동작하지 않음
public	O	O	public function: 내부적으로 호출하거나 메시지를 통해서 호출 가능 public state variable: 자동적으로 getter 함수가 생성됨
internal	O	O	State Variable의 기본 가시성 수준. 현재 contract나 파생된 contract에서 접근 가능.
private	O	O	정의된 contract에서만 가시적. 파생 클래스에서는 비가시적.

visibility 지정자 위치

• 상태 변수의 타입 뒤
• 매개변수 리스트와 리턴 매개변수 리스트 사이

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract C {  
function f(uint a) private pure returns (uint b) { return a + 1; } // 매개변수 리스트와 리턴 매개변수 리스트 사이  
function setData(uint a) internal { data = a; } // 매개변수 리스트와 리턴 매개변수 리스트 사이  
uint public data; // 상태 변수 타입 뒤  
}  

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.8.0;

contract C {
    uint private data;

    function f(uint a) private pure returns(uint b) { return a + 1; }
    function setData(uint a) public { data = a; }
    function getData() public view returns(uint) { return data; }
    function compute(uint a, uint b) internal pure returns (uint) { return a + b; }
}

// This will not compile
contract D {
    function readData() public {
        C c = new C();
        uint local = c.f(7); // error: member `f` is not visible -> f는 private
        c.setData(3);
        local = c.getData();
        local = c.compute(3, 5); // error: member `compute` is not visible -> compute는 internal이기 때문에 contract C나 혹은 contract C에서 파생된 contract에서만 접근 가능
    }
}

contract E is C {
    function g() public {
        C c = new C();
        uint val = compute(3, 5); // access to internal member (from derived to parent contract) -> E는 derived contract이기 때문에 접근 가능
    }
}

Getter Functions

• public state variable에 대해 컴파일러가 자동으로 생성하는 함수

  // SPDX-License-Identifier: GPL-3.0
  pragma solidity >=0.4.16 <0.8.0;
  

contract C {
uint public data = 42;
}

contract Caller {
C c = new C();
function f() public view returns (uint) {
return c.data(); // data(): return state variable "data"
}
}

- getter function은 external 수준으로 가시성을 가짐
    - this.data(): 외부 접근
    - data(): 내부 접근
``` solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract C {
    uint public data;
    function x() public returns (uint) {
        data = 3; // internal access
        return this.data(); // external access
    }
}

• public state variable인 array 타입은 getter function으로 배열의 요소에 접근 가능
  • 전체 array를 리턴할 때 높은 gas 비용을 방지

    // SPDX-License-Identifier: GPL-3.0
    pragma solidity >=0.4.16 <0.8.0;
    

contract arrayExample {
// public state variable
uint[] public myArray;

// 컴파일러에 의해 자동으로 생성되는 getter 
/*
function myArray(uint i) public view returns (uint) {
    return myArray[i];
}
*/

// 전체 array를 리턴하는 function
function getArray() public view returns (uint[] memory) {
    return myArray;
}

}

```solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.8.0;

contract Complex {
    struct Data {
        uint a;
        bytes3 b;
        mapping (uint => uint) map;
    }
    mapping (uint => mapping(bool => Data[])) public data; // ??
}

위의 코드는 아래와 같은 funtion을 생성한다.

function data(uint arg1, bool arg2, uint arg3) public returns (uint a, bytes3 b) {
    a = data[arg1][arg2][arg3].a;
    b = data[arg1][arg2][arg3].b;
}