miner.start(threadnum) 로 명령어 사용가능하다. 여기에서 thread_num은 채굴시 사용하는 쓰레드 수이다. 우선 1로 설정
> miner.start(1)
null or true
> miner.mining //마이닝 되고 있는 지 체크
true
> eth.hashreate
1086190 or 0
> eth.blockNumber
61
그리고 miner.stop 을 해보자.
> miner.stop()
//계좌 확인
> eth.getBalance(eth.coinbase)
125000000000000000000
> eth.getBalance(eth.accounts[1]) //현재 1로 설정되어 있는 상태입니다.
125000000000000000000
> eth.getBalance(eth.accounts[0])
95000000000000000000
0이 엄청 많아 보이지만 최소 단위인 wei 로 보여서 그렇다. 10^18승이 1이더이다. 그럼 이더로 변환하면
> web3.fromWei(eth.getBalance(eth.accounts[1]),"ether")
125 // 이더로 변환
다시 한번 블록 갯수 체크해본다.
> eth.blockNumber
44
블록당 보상금액이 5ether이다. 그래서 계정 2개 보상 금액 합치면 220 ( 125 + 95 ) 이더이다. 즉 220 = 5 * 44 로 맞아떨어진다.
pragma solidity ^0.4.17;
//다양한 테스팅 도구 제공import"truffle/Assert.sol";
//이미 서버에 배포된 계약 주소를 가져온다. import"truffle/DeployedAddresses.sol";
//계약 소스를 가져온다. import"../contracts/Adoption.sol";
contract TestAdoption {
//Adoption 초기화Adoption adoption = Adoption(DeployedAddresses.Adoption());
//Pet에 Adopt를 할수 있는지 테스트
function testUserCanAdoptPet() public {
//8번 아이디를 adopt 함수 실행
uint returnedId = adoption.adopt(8);
uint expected =8;
//값이 제대로 가져오는 지 체크Assert.equal(returnedId, expected, "Adoption of pet ID 8 should be recoreded");
}
//아이디를 통해 Adopter 주소를 가져오는 걸 테스팅
function testGetAdopterAddressByPetId() public {
//트랙잭션을 할 예정이므로 예상 값을 this로 설정 가능하다. (펫 구매한 사람 주소)
address expected =this;
//adopters 변수 설정되면 public getter 가 되므로 거기 위치에 8의 값을 가져와서 테스팅해본다.
address adopter = adoption.adopters(8);
//값 맞게 들어오는지 체크Assert.equal(adopter, expected, "Owner of pet Id 8 should be recored");
}
function testGetAdopterAddressByPetIdInArray() public {
//트랙잭션을 할 예정이므로 예상 값을 this로 설정 가능하다. (펫 구매한 사람 주소)
address expected =this;
//storeage, memory 를 설정해서 실제 물리적으로 저장 할 것인지 내부에서 저장할 건지 정한다. //adoption 클래스에서 adopter 배열목록을 가져온다.
address[16] memory adopters = adoption.getAdopters();
//가져온 adopter의 8번째가 맞는지 체크Assert.equal(adopters[8], expected, "Owner of pet ID 8 should be recorded.");
}
}
그리고 웹쪽 프론트에서 이 계약 함수들을 사용하는 내용이다. App.js 에서 볼 수 있다.
주석을 달아봄으로써 해당 기능을 알아볼 예정이다.
App = {
web3Provider:null,
contracts: {},
//초기화init:function() {
//펫 배열을 가져와서 리스트를 만든다. $.getJSON("../pets.json", function(data) {
var petsRow =$("#petsRow");
var petTemplate =$("#petTemplate");
for (i =0; i <data.length; i++) {
petTemplate.find(".panel-title").text(data[i].name);
petTemplate.find("img").attr("src", data[i].picture);
petTemplate.find(".pet-breed").text(data[i].breed);
petTemplate.find(".pet-age").text(data[i].age);
petTemplate.find(".pet-location").text(data[i].location);
petTemplate.find(".btn-adopt").attr("data-id", data[i].id);
petsRow.append(petTemplate.html());
}
});
//지갑설정 함수를 실행한다. returnApp.initWeb3();
},
initWeb3:function() {
// Is there an injected web3 instance?if (typeof web3 !=="undefined") {
//Metamask 가 실행시 현 지갑을 리턴한다. App.web3Provider=web3.currentProvider;
} else {
//만약 지정된 지갑이 없는 경우 미리 설정된 Ganeche 지갑을 리턴한다. App.web3Provider=newWeb3.providers.HttpProvider(
"http://localhost:7545"
);
}
web3 =newWeb3(App.web3Provider);
returnApp.initContract();
},
//계약 초기화initContract:function() {
/* Adoption.JSON 형태 { "contractName": "Adoption", "abi": [ { "constant": true, "inputs": [ { "name": "", "type": "uint256" } ], "name": "adopters", ...............*///Adoption 은 컴파일 시 나온 ABI JSON이다 여기에 기본 함수들이 표시가 된다. //웹에서는 이 ABI JSON을 보고 실행을 할 수 있다.$.getJSON("Adoption.json", function(data) {
// Get the necessary contract artifact file and instantiate it with truffle-contractvar AdoptionArtifact = data;
//미리 제공된 truffleContract 를 통해 Adoption 인스턴스 생성App.contracts.Adoption=TruffleContract(AdoptionArtifact);
//지갑 설정App.contracts.Adoption.setProvider(App.web3Provider);
//// 이미 채택된 애완 동물이 있는 경우 함수를 호출해서 데이터 확인 후 업데이트 할수 있도록 한다. returnApp.markAdopted();
});
returnApp.bindEvents();
},
//이벤트 바인딩bindEvents:function() {
$(document).on("click", ".btn-adopt", App.handleAdopt);
},
//채택된 아이템이 있는 경우 버튼을 success 로 변경markAdopted:function(adopters, account) {
var adoptionInstance;
App.contracts.Adoption.deployed()
.then(function(instance) {
adoptionInstance = instance;
//전체 adopte 배열 주소를 리턴한다. returnadoptionInstance.getAdopters.call();
})
.then(function(adopters) {
//for 문 돌면서 adopte 만큼 버튼을 success 로 바꾸고 비활성화를 시킨다. for (i =0; i <adopters.length; i++) {
if (adopters[i] !=="0x0000000000000000000000000000000000000000") {
$(".panel-pet")
.eq(i)
.find("button")
.text("Success")
.attr("disabled", true);
}
}
})
.catch(function(err) {
console.log(err.message);
});
},
//Adopt 버튼 클릭시 adopt 함수 실행하는 함수이다. (트랙잭션이 발생된다.)handleAdopt:function(event) {
//기본 이벤트 블럭함event.preventDefault();
//펫 아이디를 id 를 통해 쿼리해옴var petId =parseInt($(event.target).data("id"));
var adoptionInstance;
//지갑상에 주소를 가져온다. web3.eth.getAccounts(function(error, accounts) {
if (error) {
console.log(error);
}
//처음 주소를 가져온다. var account = accounts[0];
App.contracts.Adoption.deployed()
.then(function(instance) {
adoptionInstance = instance;
//petId, account를 넣어서 adopt 함수를 실행한다. returnadoptionInstance.adopt(petId, { from: account });
})
.then(function(result) {
//완료 된 후 success 버튼으로 변경...잘 안됨..returnApp.markAdopted();
})
.catch(function(err) {
console.log(err.message);
});
});
}
};
$(function() {
$(window).load(function() {
//초기화App.init();
});
});
Truffle을 이용해서 손쉽게 테스팅 가능하며 배포도 쉽게 가능한 걸 볼수 있다. 잘 배워놓으면 도움이 많이 된다고 본다.
var SimpleStorage =artifacts.require("SimpleStorage");
contract("SimpleStorage", function(accounts) {
it("should value is 0", function() {
SimpleStorage.deployed()
.then(function(instance) {
returninstance.get.call();
})
.then(function(value) {
assert.equal(value, 0, "value is 0");
})
.catch(e=> {
console.log(e);
});
});
it("should value is 4 when i put the 4 about value", async () => {
try {
let instance =awaitSimpleStorage.deployed();
awaitinstance.set(4); //4를 넣어본다.let instance2 =awaitSimpleStorage.deployed();
let value =awaitinstance2.get.call();
assert.equal(value, 4, "value is 4"); // 그리고 결과값이 4로 나오는 지 확인해본다.
} catch (e) {
console.log(e);
}
});
});
콘솔에서 바로 테스팅도 가능하다.
테스팅전에 배포환경을 초기를 해야한다.
> migrate --reset
> test
> truffle develope
SimpleStorage.deployed().then(function(instance){return instance.get.call();}).then(function(value){return value.toNumber()});
> 0
SimpleStorage.deployed().then(function(instance){return instance.set(4);});
SimpleStorage.deployed().then(function(instance){return instance.get.call();}).then(function(value){return value.toNumber()});
> 4 //4로 나오는 걸 확인
Error: VM Exception while processing transaction: invalid opcode //0이 아니므로 오류 발생
at XMLHttpRequest._onHttpResponseEnd (C:\Users\tommy\AppData\Roaming\npm\node_modules\truffle\build\webpack:\~\xhr2\lib\xhr2.js:509:1)
at XMLHttpRequest._setReadyState (C:\Users\tommy\AppData\Roaming\npm\node_modules\truffle\build\webpack:\~\xhr2\lib\xhr2.js:354:1)
at XMLHttpRequestEventTarget.dispatchEvent (C:\Users\tommy\AppData\Roaming\npm\node_modules\truffle\build\webpack:\~\xhr2\lib\xhr2.js:64:1)
at XMLHttpRequest.request.onreadystatechange (C:\Users\tommy\AppData\Roaming\npm\node_modules\truffle\build\webpack:\~\web3\lib\web3\httpprovider.js:128:1)
at C:\Users\tommy\AppData\Roaming\npm\node_modules\truffle\build\webpack:\~\truffle-provider\wrapper.js:134:1
at C:\Users\tommy\AppData\Roaming\npm\node_modules\truffle\build\webpack:\~\web3\lib\web3\requestmanager.js:86:1
at Object.InvalidResponse (C:\Users\tommy\AppData\Roaming\npm\node_modules\truffle\build\webpack:\~\web3\lib\web3\errors.js:38:1)
그리고 다시 2번째 콘솔로 가서 로그를 확인해본다.
Connected to existing Truffle Develop session at http://127.0.0.1:9545/
..............
develop:testrpc eth_sendTransaction +2s
develop:testrpc +17ms
develop:testrpc Transaction: 0x2cc0d39fc0bec51835df91343e64577b34ae335f7d998143349d5ab8b3d63181 +1ms //이부분이 중요하다.
develop:testrpc Gas usage: 6721975 +0ms
develop:testrpc Block Number: 11 +0ms
develop:testrpc Block Time: Sat Mar 31 2018 09:56:57 GMT+0900 (대한민국 표준시) +1ms
develop:testrpc Runtime Error: invalid opcode +0ms
develop:testrpc +1ms
레벨이 현재 5개로 나누어 (계속 추가될 예정) 지며 각각의 레벨과 함께 게임도 같이 만들어 나가는 재미도 있다.
이 글은 여기 튜터리얼에 나온 레벨별로 요약을 해보았다. 종종 훝어 보기 편하게..^^
레벨 1
배열
배열에는 정적배열과 동적배열 두 종류가 있다.
unit[2] fixedArray; //2개의 원소를 담을 수 있는 고정길이 배열
string[5] stringArray; //또다른 고정 배열으로 5개의 스트링을 담을 수 있다.
unit[] dynamicArray; //동적배열은 고정된 크기가 없으며 계속 크기가 커질 수 있다.
구조체 배열을 생성할 수 있다.
Person[] people://이는 동적 배열로 원소를 계속 추가 가능함
Public으로 배열을 선언 가능하다. 이 경우는 자동으로 getter함수가 추가된다.
Person[] public people //public이 중간에 붙는 걸 유의하자
배열에 추가를 하는 경우
Person satoshi = Person(172, "Satoshi");
people.push(satoshi) //이런식으로 추가 가능하다.
함수 선언은 다음과 같다.
function eat(string _name, uint _amount) {
//TODO
}
eat('hambuger',1000); //함수의 실행
private으로도 생성을 할 수 있다.
function addToArray(uint _number) private {
numbers.push(_number)
}
반환값 반환하는 경우
string greeting = "what's up dog"
function sayHello() public returns (string) { //string 타입으로 리턴합니다.
return greeting;
}
함수제어자의 경우 view와 pure를 가지고 있다.
view의 경우 함수가 데이터를 보기만 하고 변경하지 않는 다는 뜻이다.
pure는 어떤 데이터도 접근하지 않는 것을 의미한다. 앱에서 읽지도 않고, 반환값이 함수에 전달된 인자값에 따라서 달라진다.
솔리디티 컴파일러는 이러한 부분에 대해서 무엇을 쓰면 좋을지 경고를 표시해준다.
functionsayHello() public view returns (string) {
}
function_multiply(uinta, uintb) private pure returns (uint) {
return a * b;
}
랜덤문자 생성
솔리디티에서 랜덤 발생하는 방법은 SHA3의 한 종류인 keccak256을 이용하면 된다.
uint a = 5;
uint b = 6;
// a * b가 uint8이 아닌 uint를 반환하기 때문에 에러메세지가 나옴
uint8 c = a * b
// b를 unit8 으로 형변환해서 코드가 제대로 동작하기 위해서...
uint8 c = a * uint8(b);
이벤트
이벤트는 계약이 블록체인 상에서 어떠한 이벤트 발생시 의사소통 하는 방법을 말한다.
계약은 특정이벤트가 발생되는지 리스닝하는 걸 뜻한다.
event IntegersAdded(uint x, uint y, uint result);
function add(uint _x, uint _y) public {
uint result = _x + _y;
//이벤트를 실행하여 앱에게 add 함수가 실행되었음을 알린다.
IntegersAdded(_x, _y, result);
return result;
}
//////////////// 호출은
MyContract.IntegerAdded(function(error,result){
//결과와 관련된 행동을 취한다.
});
레벨2
Address
이더리움 블록체인은 은행 계좌와 같은 계정들로 이루어져있음
예를 들어
0x0cE446255506E92DF41614C46F1d6df9Cc969183
이런 주소들을 이용해서 상호간에 이더등을 주고 받을수 있다.
주소는 특정 유저 ( 또는 스마트 컨트렉트)가 소유한다
Mapping
(key, Value) 형식으로 되어 있음
mapping (address => uint) public accountBalance; //유저의 계좌 잔액을 보유 하는 uint 지정가능
mapping (uint => string) userIdToName; //key는 uint 이고 값은 string 이다.
Msg.sender
솔리디티에서 함수 실행은 항상 호출을 해야지 실행이 되는 구조를 가지고 있다. 그래서 누군가가 항상 있다는 게 성립된다.
그래서 실행하는 계정이 msg.sender 로 정의된다.
위에 배운 mapping을 이용해서 msg.sender를 어떻게 이용하는지 살펴보자.
mapping (address=> uint) favoriteNumber;
functionsetMyNumber(uint_myNumber) public {
favoriteNumber[msg.sender] = _myNumber;
}
functiongetMyNumber() public view returns (uint) {
return favoriteNumber[msg.sender];
}
Require
특정 조건이 아닐 경우 에러 메시지를 발생하고 실행을 멈추는 기능을 말한다.
functioncheckName(string_name) public returns (string) {
require(keccak256(_name) ==keccak256("tommy"));
return"toooooomy!!";
}
상속
하나의 긴 스마트 계약보다는 나누어서 여러개의 스마트 계약으로 만들 수 있다.
아래 계약은 Animal이 있는 함수를 상속받고 있는 Dog가 함수를 그대로 사용하고 있다는 것이다.
contract Animal {
function eat() public returns (string) {
return "eat";
}
}
contract Dog is Animal {
function eatAll() public returns (string) {
return eat();
}
}
Import
여러개의 솔리디티 파일(.sol) 을 가져와서 사용할 수 있다.
import'./testContract1.sol';
contract testContract2 is testContract1 {
}
솔리디티는 public, private, internal, external등 4가지의 제어자를 제공한다.
internal의 경우 함수가 정의된 컨트렉트를 상소하는 컨트렉트에서 접근 가능
external은 함수가 컨트렉트 밖에서만 호출될 수 있다. 즉 같은 컨트렉트안에서 해당 함수를 호출을 제한한다.
internal와 private의 경우 성격이 비슷하며
external은 public 과 성격이 비슷하다고 볼 수 있다.
다른 컨트렉트와 상호작용
이미 올라가져 있는 컨트렉트를 인터페이스로 가져와서 사용도 가능하다.
pragma solidity ^0.4.17;
contract LuckyNumber {
mapping(address => uint) numbers;
function setNum(uint _num) public {
numbers[msg.sender] = _num;
}
function getNum(address _myAddress) public view returns (uint) {
return numbers[_myAddress];
}
}
위와 같은 계약이 이미 올라가 있다고 가정해보자.
그럼 인터페이스를 만들고
contract NumberInterface {
//위 계약의 getNum 를 호출한다. functiongetNum(address_myAddress) public view returns (uint); //껍데기만 정의한다.
}
이 인터페이스를 선언하고 다른 컨트렉트에서 사용하면 된다.
contract MyContract {
address addr =0xabcdef..... //이더상의 계약 주소
NumberInterface numberContract =NumberInterface(addr);
//생성한다.functionsomeFunction() public {
//이제 getNum을 호출한다.
uint num =numberContract.getNum(msg.sender);
//이제 LuckyNumber 상의 getNum을 호출해서 사용할 수 있게 한다.
}
}
functioneatBLT(stringsandwich) public {
//스트링(문자)간의 동일 여부를 판단하기 위해선 keccak256 을 사용해서 해시값 비교를 해야한다는 점 유의if(keccak(sandwich) ==keccak256("BLT")){
eat();
}
}
솔리디티에서는 사용자들이 자네가 만든 DApp의 함수를 실행할 때마다_가스_라고 불리는 화폐를 지불해야 하네. 사용자는 이더(ETH, 이더리움의 화폐)를 이용해서 가스를 사기 때문에, 자네의 DApp 함수를 실행하려면 사용자들은 ETH를 소모해야만 하네.
함수를 실행하는 데에 얼마나 많은 가스가 필요한지는 그 함수의 로직(논리 구조)이 얼마나 복잡한지에 따라 달라지네. 각각의 연산은 소모되는_가스 비용(gas cost)이 있고, 그 연산을 수행하는 데에 소모되는 컴퓨팅 자원의 양이 이 비용을 결정하네. 예를 들어, storage에 값을 쓰는 것은 두 개의 정수를 더하는 것보다 훨씬 비용이 높네. 자네 함수의 전체가스 비용_은 그 함수를 구성하는 개별 연산들의 가스 비용을 모두 합친 것과 같네.
함수를 실행하는 것은 자네의 사용자들에게 실제 돈을 쓰게 하기 때문에, 이더리움에서 코드 최적화는 다른 프로그래밍 언더들에 비해 훨씬 더 중요하네. 만약 자네의 코드가 엉망이라면, 사용자들은 자네의 함수를 실행하기 위해 일종의 할증료를 더 내야 할 걸세. 그리고 수천 명의 사용자가 이런 불필요한 비용을 낸다면 할증료가 수십 억 원까지 쌓일 수 있지.
가스는 왜 필요한가? {#-}
이더리움은 크고 느린, 하지만 굉장히 안전한 컴퓨터와 같다고 할 수 있네. 자네가 어떤 함수를 실행할 때, 네트워크상의 모든 개별 노드가 함수의 출력값을 검증하기 위해 그 함수를 실행해야 하지. 모든 함수의 실행을 검증하는 수천 개의 노드가 바로 이더리움을 분산화하고, 데이터를 보존하며 누군가 검열할 수 없도록 하는 요소이지.
이더리움을 만든 사람들은 누군가가 무한 반복문을 써서 네트워크를 방해하거나, 자원 소모가 큰 연산을 써서 네트워크 자원을 모두 사용하지 못하도록 만들길 원했다네. 그래서 그들은 연산 처리에 비용이 들도록 만들었고, 사용자들은 저장 공간 뿐만 아니라 연산 사용 시간에 따라서도 비용을 지불해야 한다네.
참고: 사이드체인에서는 반드시 이렇지는 않다네. 크립토좀비를 만든 사람들이 Loom Network에서 만들고 있는 것들이 좋은 예시가 되겠군. 이더리움 메인넷에서 월드 오브 워크래프트 같은 게임을 직접적으로 돌리는 것은 절대 말이 되지 않을 걸세. 가스 비용이 엄청나게 높을 것이기 때문이지. 하지만 다른 합의 알고리즘을 가진 사이드체인에서는 가능할 수 있지. 우린 다음에 나올 레슨에서 DApp을 사이드체인에 올릴지, 이더리움 메인넷에 올릴지 판단하는 방법들에 대해 더 얘기할 걸세.
uInt 팁
솔리디티 안에서 uint8, uint16, uint32 등의 타입을 지정하는 건 별로 의미가 없다. 이유는 생성때부터 256비트의 저장공간을 잡아놓기 때문이다. 즉 uint256 == uint8 과 같은 공간을 쓴다는 뜻이다.
하지만 예외 상황이 있다. 바로 struct안에서이다.
struct Normal {
uint a;
}
struct Mini {
uint32 a;
}
Normal normal = Normal(10);
Mini mini = Mini(10);
//이 2개는 같지만 가스를 소모하는 게 다르다.
struct Mini {
uint32 a;
uint32 b;
uint c;
}
struct Mini {
uint32 a;
uint c;
uint32 b;
}
//이 2개도 같아 보이지만 옆으로 바로 선언하는게(상위) 가스를 덜 소모한다.
시간 단위(Time uints)
솔리디티는 유닉스 타임을 쓰고 있다. now를 사용시 현재의 유닉스 타임스탬프를 값을 가지고 올 수 있다.
솔리디티는 또한 seconds, minutes, hours, days, weeks, years
uint lastUpdated;
function updateTimestamp() public {
lastUpdated = now //now로 설정
}
//5분이 지난 경우 true , 아닌 경우 false
function fiveMinutesHavePassed() public view returns(bool) {
return (now >= (lastUpdated + 5 minutes));
}
캐스팅
uint 256 를 uint32 으로 캐스팅시
uint32(uint256 변수) //이런식으로 캐스팅함
구조체를 인수로 전달하기
storage 구조체를 주고 받을 수 있다.
function_doStuff(Zombiestorage_zombie) internal {
// _zombie 처리
}
Public 함수 보안
함수를 public 으로 지정시 외부에서 인터페이스로 해당 함수를 호출할 수 있다는 걸 유의해야 한다.
그래서 위에 언급했던 onlyOwner를 사용을 할 수 있고 그 외 private또는 internal로 만들 수 있다.
인수를 가지는 함수 제어자
// 사용자의 나이를 저장하는 매핑
mapping ( uint => uint ) public age;
//사용자의 특정 나이 이상인지 확인 하는 제어자
modifier olderThan( uint _age, uint _userId ) {
require(age[_userId]) >= _age);
_;
}
function buyAlchoDrinks(uint _userId) public orderThan(16, _userId) {
//필요한 함수 내용들
}
View
함수가 데이터를 쓰고,수정,삭제를 하지 않고 오직 읽기만 할 경우 사용될 수 있다.
View 함수는 사용자에 의해서 외부에서 호출 시 가스를 전혀 소모하지 않는다.
즉 로컬 노드에 데이터만 조회하고 따로 어떠한 트렉젝션이 필요없다는 뜻이다.
external view //오직 읽기에만 사용가능하다.
Storage는 비싸다.
데이터의 일부를 쓰거나 바꿀때마다 블록체인에 영구적으로 기록되기 때문에 가스비가 들수 밖에 없다.
비용이 드는 문제이다.
그래서 비용을 최소화 하기 위해 필요한 경우가 아니면 storage에 데이터를 쓰지 않는 편이 좋다.
메모리에 배열 선언하기
Storage 에 쓰지 않고 배열을 만들려면 memory 키워드를 이용하면 된다.
Storage 보다 휠씬 가스비가 절약할 수 있다. 외부에서 호출하는 View 함수라는 무료이다.
function getArray() external pure returns(uint[]){
//배열의 크기는 항상 주어져야 한다. 이후에는 변경될 수 있을것이다.
uint[] memory values = new uint[](3);
values.push(1);
values.push(2);
values.push(3);
return values;
}
For 반복문 사용하기
솔리디티에서 for문은 자바스크립트와 유사하다.
functiongetEvens() pure external returns(uint[]) {
uint[] memory evens =newuint[](5);
uint counter =0;
for(uint i =0; i <=10; i++ ){
if(i %2==0){
evens[counter] = i;
counter++;
}
}
return evens;
}
이더리움에서는 자네가 컨트랙트의 함수를 실행하면_트랜잭션(transaction)으로서 네트워크의 노드 하나 혹은 여러 노드에 실행을 알리게 되네. 그 후 네트워크의 노드들은 여러 개의 트랜잭션을 모으고, "작업 증명"으로 알려진 계산이 매우 복잡한 수학적 문제를 먼저 풀기 위한 시도를 하게 되네. 그리고서 해당 트랜잭션 그룹을 그들의 작업 증명(PoW)과 함께블록_으로 네트워크에 배포하게 되지.
한 노드가 어떤 PoW를 풀면, 다른 노드들은 그 PoW를 풀려는 시도를 멈추고 해당 노드가 보낸 트랜잭션 목록이 유효한 것인지 검증하네. 유효하다면 해당 블록을 받아들이고 다음 블록을 풀기 시작하지.
이것이 우리의 난수 함수를 취약하게 만드네.
우리가 동전 던지기 컨트랙트를 사용한다고 해보지 - 앞면이 나오면 돈이 두 배가 되고, 뒷면이 나오면 모두 다 잃는 것이네. 앞뒷면을 결정할 때 위에서 본 난수 함수를 사용한다고 가정해보세. (random >= 50은 앞면,random < 50은 뒷면이네).
내가 만약 노드를 실행하고 있다면, 나는오직 나의 노드에만트랜잭션을 알리고 이것을 공유하지 않을 수 있네. 그 후 내가 이기는지 확인하기 위해 동전 던지기 함수를 실행할 수 있지 - 그리고 만약 내가 진다면, 내가 풀고 있는 다음 블록에 해당 트랜잭션을 포함하지 않는 것을 선택하지. 난 이것을 내가 결국 동전 던지기에서 이기고 다음 블록을 풀 때까지 무한대로 반복할 수 있고, 이득을 볼 수 있네.
그럼 이더리움에서는 어떻게 난수를 안전하게 만들어낼 수 있을까? {#-}
블록체인의 전체 내용은 모든 참여자에게 공개되므로, 이건 풀기 어려운 문제이고 그 해답은 이 튜토리얼에를 벗어나네. 해결 방법들에 대해 궁금하다면이 StackOverflow 글을 읽어보게. 하나의 방법은 이더리움 블록체인 외부의 난수 함수에 접근할 수 있도록_오라클_을 사용하는 것이네.
물론, 네트워크 상의 수만 개의 이더리움 노드들이 다음 블록을 풀기 위해 경쟁하고 있으니, 내가 다음 블록을 풀 확률은 매우 낮을 것이네. 위에서 말한 부당한 방법을 쓰는 것은 많은 시간과 연산 자원을 필요로 할 것이야 - 하지만 보상이 충분히 크다면(내가 천억 원을 걸 수 있다든지?), 공격할 만한 가치가 있을 것이네.
그러니 이런 난수 생성은 이더리움 상에서 안전하지는 않지만, 실제로는 난수 함수가 즉시 큰 돈이 되지 않는 한, 자네 게임의 사용자들은 게임을 공격할 만한 충분한 자원을 들이지 않을 것이네.
이 튜토리얼에서는 시연 목적으로 간단한 게임을 만들고 있고 바로 돈이 되는 게 없기 때문에, 우린 구현하기 간단한 난수 생성기를 사용하는 것으로 타협할 것이네. 이게 완전히 안전하지는 않다는 걸 알긴 하지만 말이야.
향후 레슨에서는, 우린_oracle_(이더리움 외부에서 데이터를 받아오는 안전한 방법 중 하나)을 사용해서 블록체인 밖에서 안전한 난수를 만드는 방법을 다룰 수도 있네.
Else 구문
if (zombieCoins[msg.sender] > 100000000) {
}else{
}
레벨 5
토큰
기본적으로 ERC20 토큰이 있어서 이걸 거래가 가능하다. 이더리움 토큰을 생각해보면 된다.
하지만 게임상에서 게임 수집물에 대한 토큰으로 표기하기에는 한계가 있다..
좀비하나마다 아이디를 부여해야 하기 때문이다.
그래서 ERC721 토큰을 제공한다.
참고 : ERC721 같은 표준을 사용하는 장점은 경매와 플레이어가 좀비를 거래 / 판매하는 방식을 결정하는 에스크로 로직을 계약에서 구현할 필요가 없어진다는 점입니다.
사양을 준수하면 다른 사람이 수집 가능한 ERC721 스크립트 자산의 교환 플랫폼을 만들 수 우리의 ERC721 좀비는 그 플랫폼에서 사용할 수 있습니다.
따라서 자신의 거래 로직을 전개하는 대신 토큰 규격을 사용하는 것은 분명히 장점이 있습니다.
ERC 721 토큰 규격
contract ERC721 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
토큰 계약 구현시 먼저 할껀 Import 를 해서 가져오는 것이다.
import "./erc721.sol"
//참고로 계약은 다중상속을 허용하고 있다.
contrat A is B,C {
}
function balanceOf(address _owner) public view returns (uint256 _balance);
//Address 입력시 그 계정에 balance가 얼마나 있는지 조회할 수 있다.
function ownerOf(uint256 _tokenId) public view returns (address _owner);
//해당 토큰 아이디에 address를 리턴해준다.
오버플로우
연산시 만약 uinit8 을 지정한 상태에서 8비트만 가질수 있다. 즉 최대수는 2^8 -1 = 255 이다.
하지만 만약
uint number = 255;
number++; //이 경우 오버플로우 발생함
언더플로우
오버플로우 반대로 음수로 가는 경우 발생될 수 있다.
SafeMath
이를 방지하기 위해 OpenZepplin은 SafeMath라는 라이버러리를 제공한다.
기본적으로 함수는 4개의 기능을 제공한다.
add, sub, mul, div
using SafeMath for uint256; //라이버러리를 사용하겠다고 정의
uint256 a =5;
uint256 b =a.add(3);
uint256 c =a.mul(2);
내부 소스를 들어다 보면
library SafeMath {
functionmul(uint256a, uint256b) internal pure returns (uint256) {
if (a ==0) {
return0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
functiondiv(uint256a, uint256b) 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 holdreturn c;
}
functionsub(uint256a, uint256b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
functionadd(uint256a, uint256b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library 라는 키워드 확인해볼 필요있다.
library 타입으로 지정시 다른 타입을 앞으로 끌어들일 수 있다.
using SafeMath for uint;
uint test =2;
test =test.mul(3); //인자가 2개가 필요하지만 자동으로 앞 변수(test)를 입력받게 된다..
사용법
//num++ 이 방법을 쓰지 말고
num = num.add(1); //이렇게 대체하면 됩니다.
Assert
사용법은 **require **와 비슷하다. 값이 false 일때 반환한다.
그러면 require 와 차이점은 무엇일까.
**require **실패시 가스비가 반환된다. 하지만 **assert **사용시 가스비는 반환되지 않고 false 로 끝난다.
그래서 극단적인 오류의 경우에만 사용해야 한다. 예를 들어 오버플로우나 언더 플로우등..
uint16 , uint32 상의 오버/언더 플로 해결방법
기본적으로 SafeMath 타입은 uint256 이다. 그래서 추가적으로 2개의 라이버러리를 더 가져와야 한다.
SafeMath16, SafeMath32
내부적으로 같지만 타입만 변경되었다.
주석
솔리디티에서 주석은 자바스크립트 과 동일하다.
주석은 **natspec 을 따른다. **
/// @title A contract for basic math operations
/// @author H4XF13LD MORRIS 💯💯😎💯💯
/// @notice For now, this contract just adds a multiply function
contract Math {
/// @notice Multiplies 2 numbers together
/// @param x the first uint.
/// @param y the second uint.
/// @return z the product of (x * y)
/// @dev This function does not currently check for overflows
function multiply(uint x, uint y) returns (uint z) {
// This is just a normal comment, and won't get picked up by natspec
z = x * y;
}
}
@notice 는 이 함수가 하는 일을 설명한다.
@dev 는 추가적으로 개발자에게 할 말을 적는다.
제 6장 웹 연동
Web3.js
이더리움 네트워크내에서 통신을 하기위해선 여러가지 방법이 있지만 주로 JSON-RPC를 통한다. 하지만 형태는 직접 보기가 불편한 점이 있다. 그래서 그걸 인터페이스로 쉽게 구현하는 라이버러리가 있다. Web3.js 를 뜻한다.
Web3 Provider 은 이더리움 서버를 어떤 걸로 할지 설정해준다. 자신의 네트워크로 지정해도 상관은 없다. 그리고 메인이나 테스트넷등에 접속시 쉽게 하기 위해서 Infura 라는 서비스도 제공되어 진다.
Infura 를 공급자(Provider)로 사용하는 경우 자신의 노드를 설정하고 유지할 필요없이 Ethereum 블록 체인으로 메세지를 보내고 받을 수 있다.
var web3 = new Web3(new Web3.providers.WebsocketProvider("wss://mainnet.infura.io/ws"));
DAPP의 경우 읽는 것 뿐아니라 블록체인에 Write 할 것이다. 그럼 이 사용자들이 개인 키로 트랙잭션에 서명 할 수 있는 방법이 필요하다.
그렬경우 대표적으로 인기가 많은 것은 MetaMask이다.
하지만 만약 Metamask 를 설치를 하지 않을 경우에도 오류 메세지를 보여주는 편이 좋다.
window.addEventListener('load', function() {
// Checking if Web3 has been injected by the browser (Mist/MetaMask)if (typeof web3 !=='undefined') {
// Use Mist/MetaMask's provider
web3js =newWeb3(web3.currentProvider);
} else {
// Handle the case where the user doesn't have web3. Probably // show them a message telling them to install Metamask in // order to use our app.
}
// Now you can start your app & access web3js freely:startApp()
})
Web3.js 은 두가지가 필수로 주어져야 한다.
address : 추후 스마트 계약을 배포 한 후에 주어지는 주소를 뜻한다
ABI : Application Binary Interface 를 줄인 말이며 함수들과 기타 정보들을 JSON으로 모아놓은 형태를 말한다. 배포시 얻을 수 있다.
// Instantiate myContract
var myContract = new web3js.eth.Contract(myABI, myContractAddress);
스마트 계약 연동
**Web3.js 는 작성한 스마트 계약과의 연동시 **주소와 ABI 가 필요합니다.
Address
스마트 계약 작성후 그 계약을 컴파일 한 후 이더리움에 배포를 하는 과정을 거칩니다. 배포를 하게 되면 이더리움 해당 되는 넷에 그 계약이 머물고 있는 주소를 얻을수 있다.
ABI (Application Binary Interface 응용 프로그램 바이너리 인터페이스)
배포 전 컴파일하게 되면 web3.js 가 이해할 수 있는 JSON 향태의 파일을 제공해준다. 그럼 이 걸 주소와 같이 저장해서 사용을 하면 된다.
이 2개가 준비되었다고 가정하면 Web3 에서는 인스턴스화 할 수 있다.
var myContract =newWeb3js.eth.Contract(myABI, myContractAddress);
Call & Send
자 이제 모든 준비는 다 된 상태이다. 그럼 함수들을 호출을 해보자. 함수 호출시 call과 send를 사용한다.
Call: View, Pure 함수로 주로 사용된다. 이건 로컬 노드에서 실행되기 때문에 블록체인에서 transaction 을 실행하지 않는다.
View,Pure 함수는 가스소모가 없다.
myContract.methods.myMethod(123).call()
send: 트랙잭션이 발생되며 블록체인내에서 변화가 이루어진다. View,Pure 함수를 제외하고 함수들이 send로 불리어진다.
send함수를 실행시 가스가 소모되며 만약 메타메스크를 실행한 상태라면 그 메타메스크가 열리면서 함수를 실행을 할 수 있게 된다. transaction에는 submit 도 가능하다.
myContract.methods.myMethod(123).send()
유저 계정 정보를 획득하기
MetaMask 를 통해 Web3 은 유저정보를 실시간으로 받아올 수 있다.
var userAccount =web3.eth.accounts[0]
만약 유저 계정을 바뀌는 경우라면 어떻게 되는 것일까.. 크롬에서 metamask를 켜고 유저정보를 실시간으로 변경시 그 정보를 업데이트를 해줘야 한다.
그걸 하기 위해선 매초마다 체크를 해서 업데이트를 해주면 된다.
var accountInterval =setInterval(function() {
//변경이 된 경우라면if(web3.eth.accounts[0] !== userAccount) {
userAccount =web3.eth.accounts[0];
updateInterface();
}
}, 100);
getZombieDetails(id)
.then(function(zombie) {
// Using ES6's "template literals" to inject variables into the HTML.
// Append each one to our #zombies div
$("#zombies").append(`<div class="zombie">
<ul>
<li>Name: ${zombie.name}</li>
<li>DNA: ${zombie.dna}</li>
<li>Level: ${zombie.level}</li>
<li>Wins: ${zombie.winCount}</li>
<li>Losses: ${zombie.lossCount}</li>
<li>Ready Time: ${zombie.readyTime}</li>
</ul>
</div>`);
});
Send 함수
send트랙잭션을 수행하면 from해당되는 기능을 호출하는 사람의 주소가 필요하다. (msg.sender) . 그 후에 MetaMask 가 팝업으로 나와서 submit(전송확인) 할 것인지 물어본다.
send시 거래 비용으로 가스가 든다.
send를 하는 순간 블록에 노드를 업데이트 하므로 최소 15이상의 시간이 걸릴 수 있으므로 그에 대한 UI 를 고려 해야 할 것이다. 즉 비동기 함수가 필요할 것이다.
... Solidity 코드
functioncreateRandomZombie(string_name) public {
require(ownerZombieCount[msg.sender] ==0);
uint randDna =_generateRandomDna(_name);
randDna = randDna - randDna %100;
_createZombie(_name, randDna);
}
.... 비동기로 처리 되는 부분을 눈여겨 봐야 한다.
.... Web3.js 코드
functioncreateRandomZombie(name) {
// This is going to take a while, so update the UI to let the user know// the transaction has been sent$("#txStatus").text("Creating new zombie on the blockchain. This may take a while...");
// Send the tx to our contract:returnCryptoZombies.methods.createRandomZombie(name)
.send({ from: userAccount })
.on("receipt", function(receipt) {
$("#txStatus").text("Successfully created "+ name +"!");
// Transaction was accepted into the blockchain, let's redraw the UIgetZombiesByOwner(userAccount).then(displayZombies);
})
.on("error", function(error) {
// Do something to alert the user their transaction has failed$("#txStatus").text(error);
});
}
// Use `filter` to only fire this code when `_to` equals `userAccount`
cryptoZombies.events.Transfer({ filter: { _to: userAccount } })
.on("data", function(event) {
let data = event.returnValues;
// The current user just received a zombie!
// Do something here to update the UI to show it
}).on("error", console.error);
지난 이벤트 조회
getPastEvents 를 사용하여 지난 이벤트를 조회도 가능하다. fromBlock, toBlock 로 이벤트 로그들을 살펴볼수 있다.
cryptoZombies.getPastEvents("NewZombie", { fromBlock: 0, toBlock: "latest" })
.then(function(events) {
// `events` is an array of `event` objects that we can iterate, like we did above
// This code will get us a list of every zombie that was ever created
});
Web3.js 이벤트 및 메타 마스크
현재로서는 웹소켓을 이용하여 이벤트를 구독할 수 있다. 최신 1.0 web3.js 내용이다.
아직 메타메스크는 Provider 로써 제공을 못 해주고 있다. 그래서 infura 를 사용하여 만들수 있다.
var web3Infura = new Web3(new Web3.providers.WebsocketProvider("wss://mainnet.infura.io/ws"));
var czEvents = new web3Infura.eth.Contract(cryptoZombiesABI, cryptoZombiesAddress);
