HYUN’s

Lottery DApp 개발 Lottery React웹 프론트[3]

2020-04-23T00:00:00+00:00

web3js - filter

filter : 스마트 컨트랙트의 event들의 log들을 가져오고 사용하는 것. 스마트컨트랙트 밖에서 이벤트 log를 캐치하기 위해 필요하다.

getBetEvents 라는 함수를 작성해보자

getBetEvents = async() =>{
     const records = [];
     let events = await this.loteryContract.getPastEvents('BET', {fromBlock:0, toBlock:'latest'});
     console.log(events);
   }

0번 블록부터 최신 블록까지 빼오는 함수이다. 이 함수를 사용하기 위해 componentDidMount에 추가해준다.

  componentDidMount = async () => {
    await this.initWeb3();
    await this.getBetEvents();
    }   

내가 bet한 만큼 배열이 생긴다.

위 로그들을 살펴보자.

address 는 lotery컨트랙트 주소를 나타낸다
id 는 log의 id인데 다 다르다.
returnValues는 raw를 해석한 것이다.
amount에는 베팅한 금액 0.005eth가 들어있다.
bettor에는 베팅한 주소가 들어있다.
challenges에는 내가 베팅한 해쉬값이 들어가게 된다.

마지막에 추가한 ‘0xcd’를 보면

bettor에 메타마스크 주소가 들어간 것을 확인할 수 있다.

Lottery DApp 개발 Lottery React웹 프론트[2]

2020-04-21T00:00:00+00:00

web3js - send & call

call - 스마트 컨트랙트에서 상태를 변화시키지 않는, 값만 읽어오는 액션 send - 스마트 컨트랙트의 값을 변화시키는, 상호작용하는 액션

lotery 컨트랙트와 연동 & call() 사용

lotery의 컨트랙트 주소를 복사해서 App.js에 넣어준다. lotery.json에서 abi를 가져와 변수에 넣어준다.

componentDidMount = async () => {
let loteryAddress = '0x764CD7AE528bcC7Ac2673A8AA5891320f57C87Ac';
let loteryABI = [ { "inputs": [], "payable": false, "stateMutability": "nonpayable", "type": "constructor" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint256", "name": "index", "type": "uint256" }, { "indexed": false, "internalType": "address", "name": "bettor", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }, { "indexed": false, "internalType": "bytes1", "name": "challenges", "type": "bytes1" }, { "indexed": false, "internalType": "uint256", "name": "answerBlockNumber", "type": "uint256" } ], "name": "BET", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint256", "name": "index", "type": "uint256" }, { "indexed": false, "internalType": "address", "name": "bettor", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }, { "indexed": false, "internalType": "bytes1", "name": "challenges", "type": "bytes1" }, { "indexed": false, "internalType": "bytes1", "name": "answer", "type": "bytes1" }, { "indexed": false, "internalType": "uint256", "name": "answerBlockNumber", "type": "uint256" } ], "name": "DRAW", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint256", "name": "index", "type": "uint256" }, { "indexed": false, "internalType": "address", "name": "bettor", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }, { "indexed": false, "internalType": "bytes1", "name": "challenges", "type": "bytes1" }, { "indexed": false, "internalType": "bytes1", "name": "answer", "type": "bytes1" }, { "indexed": false, "internalType": "uint256", "name": "answerBlockNumber", "type": "uint256" } ], "name": "FAIL", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint256", "name": "index", "type": "uint256" }, { "indexed": false, "internalType": "address", "name": "bettor", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }, { "indexed": false, "internalType": "bytes1", "name": "challenges", "type": "bytes1" }, { "indexed": false, "internalType": "uint256", "name": "answerBlockNumber", "type": "uint256" } ], "name": "REFUND", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint256", "name": "index", "type": "uint256" }, { "indexed": false, "internalType": "address", "name": "bettor", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }, { "indexed": false, "internalType": "bytes1", "name": "challenges", "type": "bytes1" }, { "indexed": false, "internalType": "bytes1", "name": "answer", "type": "bytes1" }, { "indexed": false, "internalType": "uint256", "name": "answerBlockNumber", "type": "uint256" } ], "name": "WIN", "type": "event" }, { "constant": true, "inputs": [], "name": "answerForTest", "outputs": [ { "internalType": "bytes32", "name": "", "type": "bytes32" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [], "name": "owner", "outputs": [ { "internalType": "address payable", "name": "", "type": "address" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [], "name": "getPot", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [ { "internalType": "uint256", "name": "index", "type": "uint256" } ], "name": "getBetInfo", "outputs": [ { "internalType": "uint256", "name": "answerBlockNumber", "type": "uint256" }, { "internalType": "address", "name": "bettor", "type": "address" }, { "internalType": "bytes1", "name": "challenges", "type": "bytes1" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": false, "inputs": [ { "internalType": "bytes1", "name": "challenges", "type": "bytes1" } ], "name": "betAndDistribute", "outputs": [ { "internalType": "bool", "name": "result", "type": "bool" } ], "payable": true, "stateMutability": "payable", "type": "function" }, { "constant": false, "inputs": [ { "internalType": "bytes1", "name": "challenges", "type": "bytes1" } ], "name": "bet", "outputs": [ { "internalType": "bool", "name": "result", "type": "bool" } ], "payable": true, "stateMutability": "payable", "type": "function" }, { "constant": false, "inputs": [], "name": "distribute", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "internalType": "bytes32", "name": "answer", "type": "bytes32" } ], "name": "setAnswerForTest", "outputs": [ { "internalType": "bool", "name": "result", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": true, "inputs": [ { "internalType": "bytes1", "name": "challenges", "type": "bytes1" }, { "internalType": "bytes32", "name": "answer", "type": "bytes32" } ], "name": "isMatch", "outputs": [ { "internalType": "enum Lotery.BettingResult", "name": "", "type": "uint8" } ], "payable": false, "stateMutability": "pure", "type": "function" } ];

initWeb3 안에

   let accounts = await this.web3.eth.getAccounts();
   this.accounts = accounts[0];

   this.loteryContract = new this.web3.eth.Contract(loteryABI, loteryAddress);
   
   let pot = this.loteryContract.methods.getPot().call();
   console.log(pot);
   let owner = this.loteryContract.methods.owner().call();
   console.log(owner);

Contract는 꼭 대문자!! 현재 pot머니 값과 owner 주소를 출력해주면

현재 pot머니는 0이고 주소는 가나슈의 0번째 주소로 맞게 잘 나온것을 확인할 수 있다.

send() 사용

껐다가 다시 시작해서 새로운 lotery 컨트랙트 주소를 넣어준다. 새롭게 다시 시작했을 때 새로운 것을 넣어주지 않으며 연결오류가 난다.

let loteryAddress = ‘0x249B91F4b74846790b1F301EB73BA8482162A85f’;

Lotery.deployed().then(function(instance){lt = instance})

web3.eth.getAccounts()

인덱스 0 번째 주소를 넣어주고 새롭게 10 eth를 메타마스크 주소에 보내준다.

let ac1=’0x7901d3c08a66315ADB075B36DE2f111E77A5fC78’

web3.eth.sendTransaction({from:ac1,to:’0x5A2200731664fd6d5521C776832F576E61781C02’,value:10000000000000000000})

새로운 변수에 0번째 인덱스 주소를 넣어주고

let bettor = ‘0x7901d3c08a66315ADB075B36DE2f111E77A5fC78’

lt.betAndDistribute(‘0xab’,{from:bettor, value:5000000000000000,gas:300000})

이것을 계속반복 하다보면 어느순간 fail이 뜨게된다.

총 3번 성공하고 9번 fail하였다. 그러므로 pot에는 0.005eth * 9번의 이더가 들어가있어야 한다.

send함수를 사용해 직접 베팅을 해보자!

bet = async() => {

  //nonce = 특정 어드레스가 그동안 몇개의 트랜잭션을 만들었는지에 대한 것 , 트랜잭션 리플레이방지와 마음대로 사용 금지시킴
  //메타마스크가 자체로 nonce를 가져와져서 안써도 되지만 원래는 꼭 써야함
  let nonce = await this.web3.eth.getTransactionCount(this.accounts);
  this.loteryContract.methods.betAndDistribute('0xcd').send({from:this.accounts, value:5000000000000000, gas:300000});

 }

getBetInfo 함수를 사용하여 어디에 베팅한 정보다 들어있는지 확인한다. 10 - 12 까지 ‘0xab’베팅 정보가 들어있고 13에 ‘0xcd’가 들어있다.

Lottery DApp 개발 - Lottery React 웹 프론트[1]

2020-04-20T00:00:00+00:00

React js 환경 설정

React 를 실행하기 위해

npm -g install create-react-app

설치해 준 후 lotery-react-web폴더를 만들어 준다.

create-react-app lotery-react-web

yarn을 사용해 주기 위해 설치해준다.

npm install –global yarn

그 후 yarn에 web3를 추가해준다.

cd lotery-react-web yarn add web3

yarn start 하면 웹페이지가 열린다.

lotery-react-web의 scr에 있는 App.js를 수정해 우리의 가나슈와 메타마스크를 연동시켜보자.
metamask web3 라고 구글링해서 코드를 긁어서 넣어준다.

import Web3 from ‘web3’;

그래도 긁어서 넣어주면 오류가 발생한다.

최대한 오류를 고쳐주면 밑과 같은 코드가 된다.

    if (window.ethereum) {
      console.log('recent mode');
      this.web3 = new Web3(window.ethereum);
      try {
          // Request account access if needed
          await window.ethereum.enable();
          // Acccounts now exposed
          //this.eth.sendTransaction({/* ... */});
      } catch (error) {
          // User denied account access...
          console.log('user denied account access error: ' + error);
      }
  }
   // Legacy dapp browsers...
    else if (window.web3) {
     console.log('legacy mode');
       this.web3 = new Web3(window.web3.currentProvider);
       // Acccounts always exposed
        //web3.eth.sendTransaction({/* ... */});
   }
    // Non-dapp browsers...
    else {
     console.log('Non-Ethereum browser detected. You should consider trying MetaMask!');
   }

하지만 오류가 발생한다.

강의에서 보는 App.js와 초기 코드는

class App extends Component

인데 이 대로 코드를 작성하면 component가 정의되지 않았다는 에러가 떴다.
다시 에러를 수정 전체 코드는

import React from 'react';
import logo from './logo.svg';
import './App.css';
import Web3 from 'web3';

function App() {
  componentDidMount = async () => {
    await this.initWeb3();
  }
  initWeb3 = async () => {
    if (window.ethereum) {
      console.log('recent mode');
      this.web3 = new Web3(window.ethereum);
      try {
          // Request account access if needed
          await window.ethereum.enable();
          // Acccounts now exposed
          //this.eth.sendTransaction({/* ... */});
      } catch (error) {
          // User denied account access...
          console.log('user denied account access error: ' + error);
      }
  }
   // Legacy dapp browsers...
    else if (window.web3) {
     console.log('legacy mode');
       this.web3 = new Web3(window.web3.currentProvider);
       // Acccounts always exposed
        //web3.eth.sendTransaction({/* ... */});
   }
    // Non-dapp browsers...
    else {
     console.log('Non-Ethereum browser detected. You should consider trying MetaMask!');
   }
 }
  return (
    <div className="App">
      <header className="App-header">
        <img src={logo} className="App-logo" alt="logo" />
        <p>
          Edit <code>src/App.js</code> and save to reload.
        </p>
        <a
          className="App-link"
          href="https://reactjs.org"
          target="_blank"
          rel="noopener noreferrer"
        >
          Learn React
        </a>
      </header>
    </div>
  );
}

export default App;

또 다시 오류
그래서 강의에 나온 그대로 코드를 따라 써보았다. import부분과 class를 바꿔주었다.

import React, { Component } from 'react';
import logo from './logo.svg';
import './App.css';
import Web3 from 'web3';

class  App extends Component {

  componentDidMount = async () => {
    await this.initWeb3();
  }
  initWeb3 = async () => {
    if (window.ethereum) {
      console.log('recent mode');
      this.web3 = new Web3(window.ethereum);
      try {
          // Request account access if needed
          await window.ethereum.enable();
          // Acccounts now exposed
          //this.eth.sendTransaction({/* ... */});
      } catch (error) {
          // User denied account access...
          console.log('user denied account access error: ' + error);
      }
  }
   // Legacy dapp browsers...
    else if (window.web3) {
     console.log('legacy mode');
       this.web3 = new Web3(window.web3.currentProvider);
       // Acccounts always exposed
        //web3.eth.sendTransaction({/* ... */});
   }
    // Non-dapp browsers...
    else {
     console.log('Non-Ethereum browser detected. You should consider trying MetaMask!');
   }
 }
 render(){
  return (
    <div className="App">
      <header className="App-header">
        <img src={logo} className="App-logo" alt="logo" />
        <p>
          Edit <code>src/App.js</code> and save to reload.
        </p>
        <a
          className="App-link"
          href="https://reactjs.org"
          target="_blank"
          rel="noopener noreferrer"
        >
          Learn React
        </a>
      </header>
    </div>
  );
 }
}

export default App;

내 메타마스크와 React연동 성공!

##연동 테스트 이젠 실제로 사용할 수 있는지 테스트해보자

componentDidMount = async () => {
    await this.initWeb3();
    console.log(this.web3);
    let accounts = await this.web3.eth.getAccounts();
    console.log(accounts);
  }

이 부분을 수정해주면

web3와 메타마스크에서 현재 선택한 account를 출력해준다.

가나슈와 연동을 하기 위해서는 메타마스크 네트워크를 가나슈 호스트인 8545로 바꿔준다.

0 ETH인 것을 확인했으니 한번 10 eth를 넣어보자.

truffle console로 들어 가준 후 변수화 해준다.

Lotery.deployed().then(function(instance){lt=instance})

가나슈 acoount중에서 하나를 뽑아내고 변수 ac1에 넣어준다.

web3.eth.getAccounts() let ac1 = ‘0x7901d3c08a66315ADB075B36DE2f111E77A5fC78

ac1에서 메타마스크로 에더를 보낸다.

web3.eth.sendTransaction({from:ac1, to:’0x5A2200731664fd6d5521C776832F576E61781C02’, value:10000000000000000000})

status가 true로 뜨는 것을 확인했으니 돈이 보내진 것을 확인할 수 있다.

account가 list로 받아오므로 getBalance함수 안에 accounts[0]을 넣어준다.

componentDidMount = async () => {
    await this.initWeb3();
    console.log(this.web3);
    let accounts = await this.web3.eth.getAccounts();
    console.log(accounts);
    let balance = await this.web3.eth.getBalance(accounts[0]);
    console.log(balance);
  }

Lottery DApp 개발 - Lottery contract 개발[5]

2020-04-19T00:00:00+00:00

Distribute 함수설계 & 테스트

Distribute 함수설계

수수료를 계산해 특정 주소와 owner에게 전하는 함수이다. 여기서는 간단하게 수수료를 0으로 지정하였다.

function transferAfterPayingFee(address payable addr, uint256 amount) internal returns(uint256) {
        uint256 fee = 0;
        uint256 amountWithoutFee = amount - fee;

        //transfer to addr
        addr.transfer(amountWithoutFee);
        //transfer to owner
        owner.transfer(fee);

        return amountWithoutFee;
    }

정답을 가져오는 함수를 만들어준다. mode가 트루일 경우에는 블록해쉬값을 리턴할 것이고 false일 경우 우리가 커스텀한 answer를 리턴한다.

bool private mode = false; //false = use answer for test, true = use real block hash

bytes32 public answerForTest;

만들어 준 후

function getAnswerBlockHash(uint256 answerBlockNumber) internal view returns(bytes32 answer){
        return mode ? blockhash(answerBlockNumber) : answerForTest;
    }

정답을 지정하는 settor도 만들어 준다.

function setAnswerForTest(bytes32 answer) public returns (bool result){
        require(msg.sender == owner, "only owner can set the answer for test mode");
        answerForTest = answer;
        return true;
    }

     /**
     * @dev 베팅결과값을 확인하고 팟머니를 분배한다.
     * 정답 실패 : 팟머니 축적, 정답 맞춤 : 팟머니 획득, 한글자 맞춤 또는 정답확인불가 : 베팅금액만 획득
     */
    function distribute() public {
        // head 부터 tail 까지 도는 loop
        uint256 cur;
        uint256 transferAmount;
        BetInfo memory b;
        BlockStatus currentBlockStatus;
        BettingResult currentBettingResult; //결과값

        for(cur = _head; cur < _tail; cur++){
            b = _bets[cur];
            currentBlockStatus = getBlockStatus(b.answerBlockNumber);

            if(currentBlockStatus == BlockStatus.Checkable){
                bytes32 answerBlockHash = getAnswerBlockHash(b.answerBlockNumber);
                //blockhash가 랜덤 값으로 나와서 테스트하기 좋지 않음
                currentBettingResult = isMatch(b.challenges, getAnswerBlockHash(b.answerBlockNumber));
                //win bettor gets pot
                if(currentBettingResult == BettingResult.win){
                    //transfer pot
                    transferAmount = transferAfterPayingFee(b.bettor, _pot + BET_AMOUNT);
                    //pot = 0; 으로 초기화
                    _pot = 0;
                    //emit win
                    emit WIN(cur, b.bettor, transferAmount, b.challenges, answerBlockHash[0], b.answerBlockNumber);
                }
                //fail bettor's momey goes pot
                if(currentBettingResult == BettingResult.fail){
                    //pot = pot+bet_amount
                    _pot = _pot + BET_AMOUNT;
                    //emit fail
                    emit FAIL(cur, b.bettor, 0, b.challenges, answerBlockHash[0], b.answerBlockNumber);
                }
                //하나만 맞췄을 경우 refund bettor's money
                if(currentBettingResult == BettingResult.draw){
                    // transfer only bet_amount
                    transferAmount = transferAfterPayingFee(b.bettor, BET_AMOUNT);
                    //emit draw
                    emit DRAW(cur, b.bettor, transferAmount, b.challenges, answerBlockHash[0], b.answerBlockNumber);
                }
            }
            if(currentBlockStatus == BlockStatus.NotRevealed){
                break;
            }
            if(currentBlockStatus == BlockStatus.BlockLimitPassed){
                transferAmount = transferAfterPayingFee(b.bettor, BET_AMOUNT);
                emit REFUND(cur, b.bettor, transferAmount, b.challenges, b.answerBlockNumber);
            }
            popBet(cur);
        }
        _head = cur;
    }

emit의 event들을 작성해준다.

    event WIN(uint256 index, address bettor, uint256 amount, byte challenges, byte answer, uint256 answerBlockNumber);
    event FAIL(uint256 index, address bettor, uint256 amount, byte challenges, byte answer, uint256 answerBlockNumber);
    event DRAW(uint256 index, address bettor, uint256 amount, byte challenges, byte answer, uint256 answerBlockNumber);
    event REFUND(uint256 index, address bettor, uint256 amount, byte challenges, uint256 answerBlockNumber);

마지막으로 이 함수를 작성해준다.

    //이 로터리에서는 운영자가 아닌 사용자가 계속 답을 확인하면서 베팅을 하는
    // 로터리를 구현할 것이기 때문에 이 함수를 사용할거임
    function betAndDistribute(byte challenges) public payable returns(bool result){
        bet(challenges);
        distribute();

        return true;
    }

Distribute 함수 테스트

###두 글자 다 맞춰서 이겼을 경우

        describe('when the answer is checkable', function() {
            it('should give the user the pot when the answer matches', async () => {
                //두 글자 다 일치했을 때
                await lotery.setAnswerForTest('0xab66ec4675534645e7f83e0c9d369356db51a012a0746e2f0e82df38a345b38b', {from:deployer});
                
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //1 -> 4
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //2 -> 5
                await lotery.betAndDistribute('0xab',{from:user1, value:betAmount}); //3 -> 6 //win
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //4 -> 7
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //5 -> 8
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //6 -> 9

                let potBefore = await lotery.getPot(); // ==0.01eth
                let user1BalanceBefore = await web3.eth.getBalance(user1);

                let receipt7 = await lotery.betAndDistribute('0xef',{form:user2,value:betAmount}); //7 -> 10 //여기에서 win확인 가능 user1에게 pot이 간다
                let potAfter = await lotery.getPot();// win : ==0 eth
                let user1BalanceAfter = await web3.eth.getBalance(user1); //==balancebefore + 0.015 eth
               
                //console.log(user1BalanceBefore.toString(), new web3.utils.BN('10000000000000000').toString());
                //pot 확인
                assert.equal(potBefore.toString(), new web3.utils.BN('10000000000000000').toString());
                assert.equal(potAfter.toString(), new web3.utils.BN('0').toString());
                
                user1BalanceBefore = new web3.utils.BN(user1BalanceBefore);
                assert.equal(user1BalanceBefore.add(potBefore).add(betAmountBN).toString(), new web3.utils.BN(user1BalanceAfter).toString());
             
            })

3번째에서 정답 2글자를 다 맞히는 경우를 넣어준다. 여기서 주의할 점은 user1으로 부터라는 것을 유의하여야 한다. 나는 까먹고 다 user2로 해서 equal값이 기대하는 것과 달라 오류가 났었다.

3번째에서 이겼으므로 정답블록을 확인할 수 있는 블록번호는 6이다. 이 블록6번을 확인할려면 블록 7번이 mining되어야 확인 할 수 있으므로 7번 블록까지 betAndDistribute함수를 이용해 베팅해준다.

pot에는 앞에 두명이 fail하였으므로 2 x 0.005 eth 를 가지고 있다. 3번 블록이 이겼으므로 이 pot값을 다 가져가 값이 0이 된다.

따라서 user1은 pot머니 + 베팅한 금액을 얻게 된다.

그 결과

user1이 이겨서 eth를 얻은 것을 확인 할 수 있다.

###한글자만 맞춰서 이겼을 경우

            it('should give the user the amount he bet when a single character matches', async () => {
                //한글자 맞췄을 때
                await lotery.setAnswerForTest('0xab66ec4675534645e7f83e0c9d369356db51a012a0746e2f0e82df38a345b38b', {from:deployer});
                
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //1 -> 4
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //2 -> 5
                await lotery.betAndDistribute('0xaf',{from:user1, value:betAmount}); //3 -> 6 //draw
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //4 -> 7
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //5 -> 8
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //6 -> 9

                let potBefore = await lotery.getPot(); // ==0.01eth
                let user1BalanceBefore = await web3.eth.getBalance(user1);

                let receipt7 = await lotery.betAndDistribute('0xef',{form:user2,value:betAmount}); //7 -> 10 //여기에서 확인 가능 
                let potAfter = await lotery.getPot();// draw : ==0.01 eth
                let user1BalanceAfter = await web3.eth.getBalance(user1); //==balancebefore + 0.005 eth
               
                //draw
               assert.equal(potBefore.toString(), potAfter.toString());

               user1BalanceBefore = new web3.utils.BN(user1BalanceBefore);
               assert.equal(user1BalanceBefore.add(betAmountBN).toString(), new web3.utils.BN(user1BalanceAfter).toString());
              
            })

한 글자만 맞췄을 경우에는 자신이 베팅한 금액만 다시 돌려 받으므로 pot머니는 전과 후가 같다 그리고 user1의 잔고는 베팅한 금액만 더해지면 된다.

테스트한 결과

###맞추지 못한 경우

            it.only('should get the eth of the user when the answer does not matches at all', async () => {
                // 꽝
                await lotery.setAnswerForTest('0xab66ec4675534645e7f83e0c9d369356db51a012a0746e2f0e82df38a345b38b', {from:deployer});
                
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //1 -> 4
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //2 -> 5
                await lotery.betAndDistribute('0xef',{from:user1, value:betAmount}); //3 -> 6 //fail
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //4 -> 7
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //5 -> 8
                await lotery.betAndDistribute('0xef',{from:user2, value:betAmount}); //6 -> 9

                let potBefore = await lotery.getPot(); // ==0.01eth
                let user1BalanceBefore = await web3.eth.getBalance(user1);

                let receipt7 = await lotery.betAndDistribute('0xef',{form:user2,value:betAmount}); //7 -> 10 //여기에서 확인 가능
                let potAfter = await lotery.getPot();// fail : ==0.015 eth
                let user1BalanceAfter = await web3.eth.getBalance(user1); //==balancebefore 

                //fail
                assert.equal(potBefore.add(betAmountBN).toString(), potAfter.toString());
        
                user1BalanceBefore = new web3.utils.BN(user1BalanceBefore);
                assert.equal(user1BalanceBefore.toString(), new web3.utils.BN(user1BalanceAfter).toString());
       
            });

지면 베팅한 금액이 pot에 들어간다. 테스트한 결과

Lottery DApp 개발 - Lottery contract 개발[4]

2020-04-12T00:00:00+00:00

Distribute 함수설계 & isMath함수 구현 및 테스트

Distribute 함수설계

Bet함수 사용 후 큐에 저장된 베팅 정보를 해결하는 Distribute함수를 설계 해보자

function distribute() public {
        // head 부터 tail 까지 도는 loop
        uint256 cur;
        BetInfo memory b;
        
        for(cur = _head; cur < _tail; cur++){
            b = _bets[cur];
	
	//현재 블록과 결과확인 블록의 hash가 같을 경우 = win
	//현재 블록과 결과확인 블록의 hash가 한 글자만 같을 경우 = draw
	//현재 블록과 결과확인 블록의 hash가 다를 경우 = fail
    }

이 때, 베팅한 hash와 +3 블럭의 hash가 같은지 비교해주는 함수를 따로 작성해준다.

isMatch함수를 구현해 보면

/**
    * @dev 베팅글자와 정답을 확인
    * @param challenges 베팅 글자
    * @param answer 블럭해쉬
    * @return 정답결과
    */
    function isMatch(byte challenges, bytes32 answer) public pure returns(BettingResult){
        //challenges 0xab, answer 0xab....... 32bytes
        byte c1 = challenges;
        byte c2 = challenges;
        byte a1 = answer[0];
        byte a2 = answer[0];

        c1 = c1 >> 4;
        c1 = c1 << 4;
        a1 = a1 >> 4;
        a1 = a1 << 4;

        c2 = c2 << 4;
        c2 = c2 >> 4;
        a2 = a2 << 4;
        a2 = a2 >> 4;

        if(a1 == c1 && a2 == c2)
            return BettingResult.win;
        if(a1 == c1 || a2 == c2)
            return BettingResult.draw;
        return BettingResult.fail;
    }

shift를 이용해서 값을 한 비트씩 비교해준다.
0xab » 4 = 0x0a / 0x0a « 4 = 0xa0

isMatch 함수의 리턴 값은 BettingResult 로 해주었으니 변수를 선언해 준다.

enum BettingResult {fail, win, draw}

fail부터 0, win은 1, draw는 2로 인식하게 된다. 잘 기억해 두자 test할 때 비교값으로 넣어준다

또 필요한 함수가 뭐가 있을까 생각해보자
현재 블록의 상태를 구해서 에러가 나는 상황인지 체크해주는 함수가 필요하다.

현재 가리키고 있는 블록이 내가 베팅한 블록보다 뒤에 있어야 답 체크가 가능하다.

블록의 최대치는 256이므로 256을 넘으면 에러처리
이걸 생각하고 if문을 생각해 보면

function getBlockStatus(uint256 answerBlockNumber) internal view returns(BlockStatus) {
     if(block.number > answerBlockNumber && block.number < BLOCK_LIMIT + answerBlockNumber){
         return BlockStatus.Checkable;
     }
     if(block.number <= answerBlockNumber){
         return BlockStatus.NotRevealed;
     }
     if(block.number >= answerBlockNumber + BLOCK_LIMIT){
         return BlockStatus.BlockLimitPassed;
     }
     return BlockStatus.BlockLimitPassed;
 }

여기서 return값이 BlockStatus이므로 변수로 선언해준다.

enum BlockStatus {Checkable, NotRevealed, BlockLimitPassed}

checkable은 매핑이 완료 되 답 비교가 가능한 것을 나타내고 notrevealed는 현재 블럭이 베팅을 건 블럭보다 앞에 있으면 매핑이 안되 답을 확인할 수 없는 것을 나타내고, BlockLimitPassed는 limit를 넘겼을 때 답을 구할 수 없는 것을 나타내는 것이다.
지금까지 작성한 함수를 이용해 distribute함수를 작성해보자!

function distribute() public {
        // head 부터 tail 까지 도는 loop
        uint256 cur;
        BetInfo memory b;
        BlockStatus currentBlockStatus;
        for(cur = _head; cur < _tail; cur++){
            b = _bets[cur];
            currentBlockStatus = getBlockStatus(b.answerBlockNumber);

            if(currentBlockStatus == BlockStatus.Checkable){
                //win bettor gets pot

                //fail bettor's momey goes pot

                //하나만 맞췄을 경우 refund bettor's money
            }
            if(currentBlockStatus == BlockStatus.NotRevealed){
                break;
            }
            if(currentBlockStatus == BlockStatus.BlockLimitPassed){
                
            }
            popBet(cur);
        }
    }

sMath함수 구현 및 테스트

lotery.test.js 파일에

describe.only('isMatch', function (){
        let blockHash ='0xab66ec4675534645e7f83e0c9d369356db51a012a0746e2f0e82df38a345b38b'
	
        it('should be BettingResult.win when two characters match', async () =>{
            let matchingResult = await lotery.isMatch('0xab', blockHash);

            assert.equal(matchingResult, 1);
        })
        it('should be BettingResult.draw when two characters match', async () =>{
            let matchingResult = await lotery.isMatch('0xac', blockHash);

            assert.equal(matchingResult, 2);
        })
        it('should be BettingResult.fail when two characters match', async () =>{
            let matchingResult = await lotery.isMatch('0xcd', blockHash);

            assert.equal(matchingResult, 0);
        })
    });

이 때 Blockhash값은 web3.eth.getBlock(0) 해서 아무값이나 넣어주었다.
처음에 이곳에서 오류가 낫었다 이유는 BettingResult를 선언해 줄 때 win, fail, draw 순으로 선언 해 주고는 강의 그대로 따라해서 넣었더니 당연이 일치하지 않으므로 에러가 났었다. 그래서 고쳐 준 후 isMatch 함수 return 부분을 다시 입력해주고 truffle test test/lotery.test.js를 실행하니

Lottery DApp 개발 - Lottery contract 개발[3]

2020-04-10T00:00:00+00:00

Bet 함수 구현&테스트

expectEvent.js 생성 후 lotery.test.js의 위에 추가

const expectEvent = require(‘./expectEvent’);

event가 제대로 찍히는지 확인해 주기 위해

await expectEvent.inLogs(receipt.logs, ‘BET’);

추가해준다. 이때 BET 대신에 WIN을 넣어보면

await expectEvent.inLogs(receipt.logs, ‘WIN’);

일치하지 않았기 때문에 오류가 난다. 제대로 하면

성공

Lottery DApp 개발 - Lottery contract 개발[2]

2020-04-06T00:00:00+00:00

Bet 함수 구현&테스트

Lottery DApp 개발 - Lottery contract 개발[1]

2020-04-05T00:00:00+00:00

Lotery domain과 queue설계

Lottery DApp개발 - truffle project test

2020-03-31T00:00:00+00:00

Lotery 를 테스트할 테스트 파일을 test폴더 안에 만들어준다.

Lotery 컨트랙트를 만들어준다. function 함수 안에 파라미터가 3개인데 최대 10개까지 들어올 수 있다.

따라서 파라미터에 가나슈의 인덱스 0, 1, 2의 주소가 들어간다.

변수 lotery를 선언해 배포해준다.

owner와 value변수를 선언해 주소와 Lotery.sol에서 정의한 getSomeValue함수의 리턴값을 넣어준다.

마지막으로 함수의 리턴 값과 5와 같으면 passing이 되는가를 테스트해본다.

Lottery DApp개발 - truffle project 세팅

2020-03-30T00:00:00+00:00

컨트랙트 안에 주소 owner를 public으로 선언해준다.

그 다음, 배포될 때 가장 먼저 실행되는 생성자를 선언해준다.

owner에 메세지 발신자(현재 호출)을 넣어준다.

getSomeValue()라는 함수를 생성해 준다. value라는 정수 인자를 받고 5를 리턴하는 함수이다.

컴파일 한 후 배포해준다.

가나슈의 10개의 주소를 확인하는 함수이다.

0번째 주소를 사용하므로 이더리움 잔고를 확인하는 getBalance함수에 0번째 주소를 넣어줘서 잔고를 확인해준다.

배포한 컨트랙트의 인스턴스를 lt에 넣어준다. 그러면 lt를 활용해 여러가지 함수를 사용할 수 있다.

lt의 abi를 볼 수 있다.

owner() 함수를 사용해 주소를 확인할 수 있다. 결과화면을 보면 0번째 주소와 같은 것을 볼 수 있다.

Lotery.sol에서 정의 해준 함수 getSomeValue()의 결과를 보면 5를 반환한 것을 볼 수 있다.