e6_7_SimpleProject.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Chapter 6. 맛보기 웹디앱 프로젝트\n",
    "\n",
    "Last Updated 20220403_20200504_20190422_20180717_201801231_20160207\n",
    "\n",
    "## 학습내용\n",
    "\n",
    "### 목표\n",
    "\n",
    "첫 프로젝트를 구현해 보자.\n",
    "Solidity로 스마트컨트랙을 만들고, nodejs로 앞 단을 구현한다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 목차\n",
    "\n",
    "* 1. 자바스크립트 웹3\n",
    "* 1.1 node 설치\n",
    "* 1.2 web3.js 설치\n",
    "* 1.3 ganache 설치\n",
    "* 문제 6-1: ganache 접속\n",
    "* 2. 웹에서 블록체인에 연결\n",
    "* 2.1 네트워크 연결\n",
    "* 2.2 web3.eth 모듈\n",
    "* 2.3 web3.utils 모듈\n",
    "* 3. Hello World 디앱\n",
    "\t* 3.1 단계 1: 컨트랙 개발\n",
    "\t* 3.2 단계 2: 컴파일\n",
    "\t* 3.3 단계 3: 컨트랙 배포\n",
    "\t* 3.4 단계 4: 사용\n",
    "\t* 3.5 웹디앱\n",
    "* 4. Greeter 디앱\n",
    "\t* 4.1 단계 1: 컨트랙 개발\n",
    "\t* 4.2 단계 2: 컴파일\n",
    "\t* 4.3 단계 3: 컨트랙 배포\n",
    "\t* 4.4 단계 4: 사용\n",
    "* 5. 계수기 디앱\n",
    "\t* 5.1 단계 1: 컨트랙 개발\n",
    "\t* 5.2 단계 2: 컴파일\n",
    "\t* 5.3 단계 3: 컨트랙 배포\n",
    "\t* 5.4 단계 4: 사용\n",
    "* 실습문제: 타이머 디앱 (파일에서 ABI, bytecode 읽음)\n",
    "* 연습문제: 자바스크립트 전역변수 설정\n",
    "* 연습문제: Hello Snowman 출력\n",
    "* 연습문제: byte32 타입의 Hello Greeter\n",
    "* 연습문제: Timer\n",
    "* 연습문제: 7 곱하는 컨트랙\n",
    "* 연습문제: 계수기와 Timer 콘트랙\n",
    "* 연습문제: 거듭제곱 컨트랙\n",
    "* 연습문제: 이체\n",
    "* 연습문제: 환전 계산\n",
    "* 연습문제: 웹소켓으로 blockNumber 출력\n",
    "* 연습문제: coinbase를 출력\n",
    "* 연습문제: Counter 짝수, 홀수 판별\n",
    "* 연습문제: Counter 4 판별\n",
    "* 연습문제: Counter 다른 세션에서의 값 확인\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 1. 자바스크립트 웹3\n",
    "\n",
    "nodejs를 통해 스마트콘트랙과 인터페이스하기 위해서는 web3.js를 사용해야 한다.\n",
    "```Web3.js```는 그 명칭에서 대략 무엇을 하는 것이구나라는 느낌이 오겠지만, 웹에서 이더리움 노드에 **HTTP, WebSocket 또는 IPC**로 연결해서, 통신하기 위한 **자바스크립트 라이브러리**이다.\n",
    "분산앱 dApp을 웹으로 구현하려면 스마트콘트랙 API를 자바스크립트 ```Web3.js```에서 호출하면서 그 결과를 화면단에서 받아서 처리하게 된다.\n",
    "\n",
    "```python\n",
    " -------------------                                 ------------\n",
    " | 웹디앱 - web3.js |  --- http, WebSocket, IPC ---  | ethereum |\n",
    " -------------------                                 ------------\n",
    "```\n",
    "\n",
    "nodejs는 자바스크립트의 서버 버전으로, 자바스크립트 문법에 따라 프로그래밍하면 된다.\n",
    "자바스크립트는 **비동기** 프로그래밍을 지원한다.\n",
    "블록체인은 그 특성 상 비동기 프로그래밍이 자연스럽다.\n",
    "거래가 발생한 후 바로 인증이 되는 것이 아니다.\n",
    "**마이닝을 통해 작업 증명을 해야 하고, 일정 시간 후 거래가 완성**이 되는 방식이다.\n",
    "따라서 그 시간 동안 프로그램의 실행을 막아놓고 마이닝이 끝나기를 기다리는 동기방식은 바람직하지 않다.\n",
    "예를 들어, 투표 스마트콘트랙에 후보A에 투표를 했다고 하자. 곧 이어 그 투표수를 조회해도 변경이 없을 것이다.\n",
    "**바로 조회를 하게 될 경우, 마이닝으로 인해 증가된 값을 가지게 되려면 마이닝까지 시간이 걸리기** 때문이다.\n",
    "마이닝을 해야 완성되므로 비동기 방식이 자연스럽다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 1.1 node 설치\n",
    "\n",
    "### node 설치\n",
    "\n",
    "https://nodejs.org 사이트에 가서 자신의 운영체제에 맞는 nodejs를 다운로드한다.\n",
    "윈도우에 설치하려면 64 또는 32비트 중 자신의 컴퓨터에 맞는 설치파일을 다운로드해서 설치한다.\n",
    "\n",
    "리눅스나 맥os를 사용하면, 단말에서 명령어를 입력하여 설치할 수 있다.\n",
    "* 리눅스는 ```apt install nodejs```,\n",
    "* 맥은 ```brew install nodejs```로 입력한다.\n",
    "![alt text](figures/6_nodeDownload.png \"node download\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "윈도우에서는 내려받읃 msi 파일을 설치한다. 설치 디렉토리는 ```C:\\Program Files\\nodejs```로 하자.\n",
    "\n",
    "![alt text](figures/6_nodeInstall.png \"node install\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "nodejs의 경로를 설정한다. nodejs를 설치한 경로를 등록하여, 명령창에서 실행이 바로 가능하도록 한다. \n",
    "\n",
    "![alt text](figures/6_nodePath.png \"node path\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### npm\n",
    "\n",
    "npm은 노드 패키지 관리자 Node Package Manager이다. npm은 노드 패키지의 저장소 (npm registry)이고 이 저장소로부터 설치하거나 관리에 필요한 명령어를 지원한다.\n",
    "**web3.js를 설치하기 위해서는 npm이 필요**하다.\n",
    "윈도우에서 **npm은 ```nodejs```와 함께 이미 설치**되어 있다.\n",
    "명령창에서 ```which npm``` (윈도우 명령창에서는 ```where npm```)하면 알 수 있다.\n",
    "리눅스는 ```apt install npm```으로 설치한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### package.json 생성\n",
    "\n",
    "자바스크립트에서는 npm registry에서 패키지를 설치하게 된다.\n",
    "자신이 새로운 패키지를 생성하려면, 디렉토리를 만들고, 그 안에 ```package.json``` 파일을 만든다.\n",
    "```package.json```은 패키지명, 버전, 설명 등 관련 내용을 담고 있다.\n",
    "\n",
    "```npm init``` 명령을 입력해보자.\n",
    "```python\n",
    "C:\\Users\\G312\\Code\\201711111> npm init\n",
    "```\n",
    "\n",
    "이 명령어를 입력하면 생성하려는 패키지 관련하여 package name, version, author 등의 정보를 입력하게끔 되어 있고, 그러면 package.json을 생성하게 된다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### npm 명령어들\n",
    "\n",
    "설치는 전역으로 설치하거나 특정 사용자 권한으로 설치할 수 있다. 전역으로 설치할 때는 ```-g``` 스위치를 넣어주고, 이를 생략하면 사용자 권한으로 설치하게 된다.\n",
    "\n",
    "필요한 라이브러리를 설치하는 명령어는 ```install```이고, 설치 디렉토리 아래 ```node_modules```이 생성된다.\n",
    "```python\n",
    "npm install\n",
    "```\n",
    "\n",
    "라이브러리가 설치 되었는지 확인하기 위해서는:\n",
    "```python\n",
    "npm list\n",
    "```\n",
    "\n",
    "전역으로 설치한 패키지 ```{prefix}/lib/node_modules/<package>```에 대한 symlink를 현재 디렉토리에 만든다.\n",
    "prefix는 ```npm config list```에 적혀있다.\n",
    "\n",
    "```python\n",
    "npm link\n",
    "```\n",
    "\n",
    "![alt text](figures/6_nodeweb3After_npm_link_web3.png \"nodel run web3 after npm link web3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 1.2 web3.js 설치\n",
    "\n",
    "npm으로 web3.js를 **프로젝트 디렉토리** ```C:\\Users\\G312\\Code\\jsl\\20171111```에서 설치해보자.\n",
    "```python\n",
    "npm install web3\n",
    "```\n",
    "\n",
    "버전 1.0 이전에는 0.20.x버전으로 머물렀다.\n",
    "버전 1.0은 오랫동안 beta로 50회 넘게 버전 업이 되었다가,\n",
    "2019년 중반 1.2.0이 발표되었다.\n",
    "\n",
    "```npm view``` 명령어로 버전 정보를 알아보자.\n",
    "```--json``` 스위치를 붙이면 전체 목록을 출력하게 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "!npm view web3 versions --json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### npm web3.js 설치\n",
    "\n",
    "nodejs 단말을 열어서 실행한다.\n",
    "```npm install 패키지명```으로 설치를 하게 돤다. ```package.json```에 기록된 패키지의 의존성이 갱신되어야 하는데 ```--save``` 옵션으로 해준다. ```--save```는 생략해도 기본 옵션으로 처리된다.\n",
    "\n",
    "```python\n",
    "npm install web3.js\n",
    "```\n",
    "\n",
    "![alt text](figures/6_npmInstallWeb3AfterWindow-build-tools.png \"nodel install Window-build-tools\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "> **nodejs 설치할 때 gyp 오류**\n",
    "\n",
    "> ```npm install web3```하면 최신 버전을 설치한다.\n",
    "web3.js 1.0 버전을 설치하면서 gyp 오류가 나는 경우 ```windows-build-tools```를 설치해야 한다.\n",
    "gyp는 nodejs로 만든 모듈을 컴파일하는 명령어 도구이다.\n",
    "```python\n",
    "npm install --global --production windows-build-tools (관리자 권한으로)\n",
    "npm install web3@^1.0.0-beta.36\n",
    "npm install -g node-gyp\n",
    "node-gyp configure --msvs_version=2015\n",
    "```\n",
    "\n",
    "> 설치하면서 사용하게 되는 python 버전을 설정하기 위해서는 다음과 같이 한다.\n",
    "npm은 이 python 버전 정보를 node-gyp를 실행할 떄 넘겨준다.\n",
    "```python\n",
    "npm install --python=python2.7\n",
    "또는\n",
    "npm config set python /path/to/executable/python2.7\n",
    "```\n",
    "nodejs 단말을 열어서 실행한다.\n",
    "\n",
    "![alt text](figures/6_npmInstallWindow-build-tools.png \"nodel install Window-build-tools\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```npm list```하면 ```web3.js``` 설치된 라이브러리를 확인할 수 있다.\n",
    "\n",
    "> npm **ERR! extraneous**\n",
    "\n",
    "> 패키지가 설치되었지만 package.json에 등록이 되지 않았다는 의미이다. 따라서 무시하고 문제없이 사용하면 된다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bitcoin@1.0.0 /home/jsl/Code/git/bb/jsl/bitcoin\r\n",
      "├── @openzeppelin/contracts@2.5.0 \u001b[40m\u001b[32mextraneous\u001b[0m\u001b[0m\r\n",
      "└── web3@1.2.5-rc.0 \u001b[40m\u001b[32mextraneous\u001b[0m\u001b[0m\r\n",
      "\r\n",
      "\u001b[?25h\u001b[0G\u001b[K\u001b[?25h\u001b[0G\u001b[K\u001b[37m\u001b[40mnpm\u001b[0m \u001b[0m\u001b[31m\u001b[40mERR!\u001b[0m\u001b[35m\u001b[0m extraneous: @openzeppelin/contracts@2.5.0 /home/jsl/Code/git/bb/jsl/bitcoin/node_modules/@openzeppelin/contracts\r\n",
      "\u001b[0m\u001b[37m\u001b[40mnpm\u001b[0m \u001b[0m\u001b[31m\u001b[40mERR!\u001b[0m\u001b[35m\u001b[0m extraneous: web3@1.2.5-rc.0 /home/jsl/Code/git/bb/jsl/bitcoin/node_modules/web3\r\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!npm list --depth 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "201711111@1.0.0 C:\\Users\\jsl\\Code\\201711111\n",
      "+-- @openzeppelin/contracts@4.5.0\n",
      "+-- ganache@7.0.3\n",
      "| +-- @trufflesuite/bigint-buffer@1.1.9\n",
      "| +-- bufferutil@4.0.5\n",
      "| +-- emittery@0.10.0\n",
      "| +-- keccak@3.0.1\n",
      "| +-- leveldown@6.1.0\n",
      "| +-- secp256k1@4.0.2\n",
      "| `-- utf-8-validate@5.0.7\n",
      "`-- web3@1.2.6\n",
      "  +-- @types/node@12.12.35\n",
      "  +-- web3-bzz@1.2.6\n",
      "  +-- web3-core@1.2.6\n",
      "  +-- web3-eth@1.2.6\n",
      "  +-- web3-eth-personal@1.2.6\n",
      "  +-- web3-net@1.2.6\n",
      "  +-- web3-shh@1.2.6\n",
      "  `-- web3-utils@1.2.6\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!npm list --depth 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### web3.js 버전 선택하여 설치하기\n",
    "\n",
    "버전 1.0을 사용하기 주저한다면, 관리자 권한으로 이미 설치되었던 1.0을 제거하고, 하위 버전을 명시하여 ```npm install <package>@<version>```으로 한다.\n",
    "\n",
    "다음과 같이 ``` @0.20``` 버전을 명시하고, 해당 버전의 최신버전으로 설치하자.\n",
    "```python\n",
    "npm install -g web3@^0.20\n",
    "```\n",
    "\n",
    "설치하고 버전을 확인하려면\n",
    "```python\n",
    "npm view web3 versions\n",
    "```\n",
    "\n",
    "![alt text](figures/6_installWeb3_0.2AfterUninstall_1.0beta.png \"node web3 test run\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### web3.js 테스트 실행\n",
    "\n",
    "네트워크에 연결하려면 geth가 실행되고 있어야 한다.\n",
    "여기서는 버전만 확인해 본다.\n",
    "대소문자 web3, Web3에 주의한다.\n",
    "```python\n",
    "> var Web3=require('web3');\n",
    "> Web3.version\n",
    "```\n",
    "그리고 Web3.modules.<TAB>을 누르면, 출력되는 \n",
    "4개의 모듈 Eth, Personal, Net, Shh을 확인해 보자.\n",
    "\n",
    "![alt text](figures/6_nodeWeb3TestRun.png \"node web3 test run\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 ganache 설치\n",
    "\n",
    "이더리움 geth의 TestRPC인 ganache를 설치한다.\n",
    "ganache는 마이닝을 하지 않기 때문에 보다 편리하다.\n",
    "(ganache-cli는 더 이상 지원하지 않고, ganache를 설치하도록 한다)\n",
    "\n",
    "```python\n",
    "C:\\Users\\G312\\Code\\jsl\\20171111>npm install ganche\n",
    "```\n",
    "\n",
    "설치하고 나서, ganache를 띄워보자.\n",
    "포트는 8345로 설정한다 (기본 8545는 geth에서 사용하므로 다른 포트를 사용한다)\n",
    "\n",
    "```python\n",
    "jsl@jsl-smu:~/Code/git/bb/jsl/bitcoin$ ganache -p 8345\n",
    "Ganache CLI v6.3.0 (ganache-core: 2.4.0)\n",
    "\n",
    "Available Accounts\n",
    "==================\n",
    "(0) 0xdc3f9fd9b1205bb854e5a8bb287816bf3e9fbdf6 (~100 ETH)\n",
    "(1) 0x6d814bcd9060d1998c6d43fe01f919c16e0cf667 (~100 ETH)\n",
    "(2) 0x6ee93ca4837d1ab240a572b9b0003e28c91985f0 (~100 ETH)\n",
    "(3) 0xec4c1cdc59be9c1255126af2bef68db15901d7fb (~100 ETH)\n",
    "(4) 0x52d6ab35013028e7e27b3a885395eceab31e9379 (~100 ETH)\n",
    "(5) 0x600aa8cab64a4cdd2311179df664eba32f3133b5 (~100 ETH)\n",
    "(6) 0x413d6070ff97092fa34daa2aa5625bea25f9864b (~100 ETH)\n",
    "(7) 0x4bdc6ea64d2d54b881c0524ccd13080983f8f967 (~100 ETH)\n",
    "(8) 0xe19dcbd534ef302ee8b9c1a6306c42306c93c82f (~100 ETH)\n",
    "(9) 0xfc4aa1584398e0eb77a8a4154fed71761ba5534e (~100 ETH)\n",
    "\n",
    "Listening on 127.0.0.1:8345\n",
    "eth_accounts 아래 web3.eth.accounts 명령어에 반응\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](figures/6_gangacheInstallRun.png \"ganache-cli install and run\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "앞서 사설망 연결했던 것을 기억해서, geth attach http://localhost:8345 로 접속한다 (또는 http://127.0.0.1:8345)\n",
    "\n",
    "![alt text](figures/6_gangacheAttachConsole.png \"gangache-cli console on 8345\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nodejs에서 ganache에 연결하려면\n",
    "ganache를 실행하고, node에서 HttpProvider()로 연결한다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "jsl@jsl-smu:~/Code/git/bb/jsl/bitcoin$ node\n",
    "> var Web3=require('web3')\n",
    "undefined\n",
    "> var web3=new Web3(new Web3.providers.HttpProvider(\"http://localhost:8345\"));\n",
    "undefined\n",
    "> web3.eth.accounts\n",
    "[ '0xdc3f9fd9b1205bb854e5a8bb287816bf3e9fbdf6',\n",
    "  '0x6d814bcd9060d1998c6d43fe01f919c16e0cf667',\n",
    "  '0x6ee93ca4837d1ab240a572b9b0003e28c91985f0',\n",
    "  '0xec4c1cdc59be9c1255126af2bef68db15901d7fb',\n",
    "  '0x52d6ab35013028e7e27b3a885395eceab31e9379',\n",
    "  '0x600aa8cab64a4cdd2311179df664eba32f3133b5',\n",
    "  '0x413d6070ff97092fa34daa2aa5625bea25f9864b',\n",
    "  '0x4bdc6ea64d2d54b881c0524ccd13080983f8f967',\n",
    "  '0xe19dcbd534ef302ee8b9c1a6306c42306c93c82f',\n",
    "  '0xfc4aa1584398e0eb77a8a4154fed71761ba5534e' ]\n",
    "> \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "node에서 컴파일을 할 필요가 있는 경우, nodejs solc 컴파일러를 설치한다.\n",
    "nodejs 단말을 열어서 실행한다.\n",
    "그러나 우리는 앞서 설치한 solidity 또는 REMIX를 사용하게 된다.\n",
    "\n",
    "![alt text](figures/6_nodejsInstallsolc.png \"node install solc compiler\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 문제 6-1: ganache  접속\n",
    "<a id='3-4'></a>\n",
    "\n",
    "### ganache 띄우기\n",
    "\n",
    "앞서 geth 사설망을 개설한 바 있다.\n",
    "거의 유사한 방식으로 하겠지만, geth 대신 ganache를 실행하기로 한다.\n",
    "ganache를 설정하고 실행하는 차이는 거의 없다.\n",
    "ganache는 마이닝을 할 필요가 없어서 편리하다.\n",
    "다음과 같이 IP 주소를 적고, 포트를 8345로 해서 접속한다.\n",
    "\n",
    "ganache-cli 또는 ganache로 적어 주어도 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing _ganacheNow.bat\n"
     ]
    }
   ],
   "source": [
    "%%writefile _ganacheNow.bat\n",
    "node_modules\\.bin\\ganache-cli --unlock 0 --host \"127.0.0.1\" --port \"8345\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### geth attach\n",
    "\n",
    "그리고 명령창을 하나 더 열어 설정한다.\n",
    "```python\n",
    "geth attach http://127.0.0.1:8345\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### node\n",
    "\n",
    "명령창을 하나 더 열어 node를 시작한다.\n",
    "앞서 web3.js를 설치한 **프로젝트 디렉토리에서 node를 실행**한다.\n",
    "\n",
    "```python\n",
    "$ Code\\jsl\\201711111> node\n",
    "> var Web3=require('web3')\n",
    "undefined\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. 웹에서 블록체인에 연결\n",
    "\n",
    "## 2.1 네트워크 연결\n",
    "\n",
    "node에서 'web3'라이브러리를 호출한다.\n",
    "그리고 Web3에서 HTTP, WebSocket 또는 IPC로 이더리움 노드에 연결할 수 있다.\n",
    "\n",
    "```python\n",
    "> var Web3=require('web3');\n",
    "> var web3=new Web3('http://localhost:8445');   //replace 'localhost' with an ip address\n",
    "또는\n",
    "> var web3=new Web3(new Web3.providers.HttpProvider('http://localhost:8445'));\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 web3.eth 모듈\n",
    "\n",
    "앞서 geth에서 배웠던 eth 모듈의 함수를 실행하여 결과를 볼 수 있다. 함수명에는 버전1.0부터 ```get```이 붙게 되었고, 대동소이하지만\n",
    "자바스크립트 이벤트 처리 방식의 문법을 따르고 있다.\n",
    "Web3 1.0는 함수의 callback에 Promises를 지원하고 있다. ```then(console.log)```과 같이 결과를 출력한다.\n",
    "\n",
    "nodejs를 실행하기 때문에 파일에 저장하고 실행해 보자.\n",
    "IP는 자신의 설정에 맞게 변경해 주어야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/web3ethCommands.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/web3ethCommands.js\n",
    "var Web3 = require('web3');\n",
    "var web3 = new Web3('http://localhost:8345');\n",
    "//web3.eth.getChainId().then(console.log);\n",
    "web3.eth.getAccounts(console.log);\n",
    "web3.eth.getCoinbase().then(console.log);\n",
    "web3.eth.getBlockNumber().then(console.log);\n",
    "web3.eth.getBalance('0xf2a4f09c903a0a7b3450d9d16bbca14dea36aee1').then(console.log);\n",
    "web3.eth.getNodeInfo().then(console.log);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0x8078e6bc8e02e5853d3191f9b921c5aea8d7f631\n",
      "null [ '0x8078e6Bc8e02e5853D3191f9b921C5aEA8D7F631',\n",
      "  '0x2371f0A50b4E63ED38063Ca4aE42E0Ad43965330',\n",
      "  '0xCC16c60a1fb054d2594aD06c6f8323AFAD729065',\n",
      "  '0x3b84FEb6A90Ae6934ae40cD21cD936f5876225Ea',\n",
      "  '0x220780a0F17eE76d1c84a3EBc0A11664E9aF0D71',\n",
      "  '0xdee208c40aD39394B1D3488917eEE5F4a09f6C08',\n",
      "  '0xB207508510652d7B47DC0386dD6D90aCA3010A27',\n",
      "  '0x85fD4841330BE7301fDF4e746aa349fb9f90E73D',\n",
      "  '0x108c2A1Ee171608FaB937897038dcf631db973A0',\n",
      "  '0xCE40E2396fafA297aDC4107c5968513f58e4C1FD' ]\n",
      "11\n",
      "0\n",
      "EthereumJS TestRPC/v2.10.2/ethereum-js\n"
     ]
    }
   ],
   "source": [
    "!node src/web3ethCommands.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### account 조회\n",
    "\n",
    "버전 1.0 이후 주소는 ```eth.accounts[0]``` 이런 식으로 배열 인덱스로 읽어올 수 없게 되었다.\n",
    "비동기로 가져오게 변경되었는데, 배열을 이용하면 동기화 문제로 출력이 되지 않는다.\n",
    "```python\n",
    "var my=web3.eth.getAccounts().then(it => { console.log(it[0]); });\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "계정주소는 거래가 발생할 때마다 필요한 정보이므로, 하드코딩하기 보다는 변수에 저장해 놓고 사용하면 편리하다.\n",
    "그러나 getAccounts() 함수가 비동기적으로 실행되므로, 계정주소를 전역변수에 저장하려면 문제가 발생한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/web3accounts.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/web3accounts.js\n",
    "var Web3 = require('web3');\n",
    "var web3 = new Web3('http://localhost:8345');\n",
    "web3.eth.getAccounts(function(err,res) { console.log(\"(1) accounts: \" + res); } );\n",
    "my=[]\n",
    "web3.eth.getAccounts(function(err, res) { for (x in res) { my.push(res[x]) } } );\n",
    "console.log(\"(2) accounts from array: \" + my[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "결과를 보면, **출력의 순서**가 바뀌어 있다.\n",
    "비동기 명령문은 앞에 있더라도, 먼저 실행이 된다는 보장이 없다.\n",
    "명령문 (2)는 undefined 출력이 되고 있는데, 출력하려는 배열의 데이터를 push로 저장하는 것이 먼저 실행이 되지 않는 **비동기적** 특성때문이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2) accounts from array: undefined\n",
      "(1) accounts: 0x8078e6Bc8e02e5853D3191f9b921C5aEA8D7F631,0x2371f0A50b4E63ED38063Ca4aE42E0Ad43965330,0xCC16c60a1fb054d2594aD06c6f8323AFAD729065,0x3b84FEb6A90Ae6934ae40cD21cD936f5876225Ea,0x220780a0F17eE76d1c84a3EBc0A11664E9aF0D71,0xdee208c40aD39394B1D3488917eEE5F4a09f6C08,0xB207508510652d7B47DC0386dD6D90aCA3010A27,0x85fD4841330BE7301fDF4e746aa349fb9f90E73D,0x108c2A1Ee171608FaB937897038dcf631db973A0,0xCE40E2396fafA297aDC4107c5968513f58e4C1FD\n"
     ]
    }
   ],
   "source": [
    "!node src/web3accounts.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "계정정보는 함수내에서 구해서 사용하면 된다.\n",
    "우선은 하드코딩해서 사용하고, 나중에 다음과 같이 함수내에서 계정정보를 받아와서 프로그래밍하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/web3account0.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/web3account0.js\n",
    "var Web3 = require('web3');\n",
    "var web3 = new Web3('http://117.16.44.45:8345');\n",
    "var account0;\n",
    "async function getAccount0() {\n",
    "    accounts = await web3.eth.getAccounts();\n",
    "    account0=accounts[0];\n",
    "    console.log(\"local account0: \" + account0);\n",
    "}\n",
    "getAccount0()\n",
    "console.log(\"global account0: \" + account0);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "global account0: undefined\r\n",
      "local account0: 0xbdC3f3ddBd068E0e739b926aaA527BF1D1Eb7EF0\r\n"
     ]
    }
   ],
   "source": [
    "!node src/web3account0.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### personal 모듈\n",
    "\n",
    "personal 모듈은 eth를 통해 제공된다.\n",
    "계정관련 ```web3.eth.personal.lockAccount```, ```web3.eth.personal.unlockAccount```\n",
    "거래관련 ```web3.eth.personal.sendTransaction```, ```web3.eth.personal.signTransaction``` 등의 함수가 제공된다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 web3.utils 모듈\n",
    "\n",
    "```randomHex()```는 32바이트 무작위 hex를 생성한다. 64자리 문자열이 출력된다.\n",
    "```keccak256()```는 입력의 keccak256을 계산한다.\n",
    "```isAddress()```는 입력이 이더리움 주소인지 확인한다.\n",
    "```utf8ToHex()```는 utf8 문자열을 hex로 변환한다.\n",
    "```toWei()``` Wei로 변환한다.\n",
    "\n",
    "```console.log()```로 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/web3utils.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/web3utils.js\n",
    "var Web3 = require('web3');\n",
    "var web3 = new Web3('http://localhosst:8345');\n",
    "console.log(\"random hex: \", web3.utils.randomHex(32));    //generate random 32 byte hex\n",
    "console.log(\"234 hash: \", web3.utils.keccak256('234'));  //calculate keccak256 for '234'\n",
    "console.log(\"is address?: \",web3.utils.isAddress('0xf2a4f09c903a0a7b3450d9d16bbca14dea36aee1'));  //check if the input is a valid address\n",
    "console.log(\"안녕 in Hex: \"+web3.utils.utf8ToHex('안녕'));\n",
    "console.log(\"wei of 1 ether: \"+web3.utils.toWei('1', 'ether'));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "console.log() 함수에서 한글이 깨지는 것은 주피터노트북에서 유니코드를 지원하지 않아서 발생하는 현상이다. 명령창에서 유니코드를 지원한다면 깨짐 없이 출력된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "random hex:  0x64e29f97e97a194a0acde5832d29487dda5f3ca28ee828b85d623ec6927324c2\n",
      "234 hash:  0xc1912fee45d61c87cc5ea59dae311904cd86b84fee17cc96966216f811ce6a79\n",
      "is address?:  true\n",
      "�븞�뀞 in Hex: 0xec9588eb8595\n",
      "wei of 1 ether: 1000000000000000000\n"
     ]
    }
   ],
   "source": [
    "!node src/web3utils.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Hello World 디앱\n",
    "\n",
    "프로그래밍을 배우면서 보통 처음으로 \"Hello World\"를 출력하게 된다.\n",
    "간단한 프로그램이지만 코딩, 컴파일, 실행, 테스트의 전과정을 해보면서 그 언어의 특징을 보다 잘 이해하게 된다.\n",
    "\n",
    "단계 | 구분 | 설명\n",
    "-----|-----|-----\n",
    "1 | 개발 | 컨트랙 **소스 코드** 개발\n",
    "2 | 컴파일 | 소스코드를 컴파일해서 **ABI**, **Byte code** 생성\n",
    "3 | 컨트랙 배포 | 컴파일해서 얻은 ABI, Byte code로 객체를 생성한 후 배포 요청, 마이닝해서 블록체인의 주소 **contract address** 획득\n",
    "4 | 사용 | **ABI**, **contract address**로 컨트랙 객체를 생성해서, ```call()``` 또는 ```sendTransaction()``` 함수로 API 호출.\n",
    "\n",
    "소스코드를 컴파일하고 나면 ABI Application Binary Interface와 Byte code를 얻게 된다.\n",
    "표에서 등장한 ABI는 컨트랙을 사용하기 위해 인터페이스 표준으로, JSON으로 표현된다. 또한 Byte code는 Solidity 소스코드를 컴파일한 기계어인 바이트코드이다.\n",
    "이 단계들은 C또는 자바로 해도 별 다르지 않다.\n",
    "그러나 '배포'와 같은 작업은 독특하다.\n",
    "디앱에서는 네트워크에 떠 있는 분산 블록체인에 배포하는 작업이 필수적이며, 그러고 나서야 API를 호출할 수 있게 된다.\n",
    "\n",
    "PlantUML을 사용해서 절차도를 그려보자 (https://github.com/jbn/IPlantUML)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "%%plantuml --jar\n",
    "@startuml\n",
    "actor developer\n",
    "developer -> local: 1.develop_source_codes\n",
    "developer -> local: 2.compile_to_get_abi_and_bin\n",
    "developer -> blockchain: 3.deploy_to_get_contract_address\n",
    "developer -> blockchain: 3.get_an_instance_with_the_contract_address\n",
    "developer -> local: 4.call()\n",
    "developer -> blockchain: 4.sendTransaction()\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.1 단계 1: 컨트랙 개발\n",
    "\n",
    "컨트랙은 REMIX에서 개발해보자.\n",
    "**REMIX**는 온라인 http://remix.ethereum.org/ 에서 제공되는 Solidity 통합개발환경 (IDE, Integrated Development Environment)을 말한다. http WebProvider를 사용하기 위해서 https 보다는 http연결을 하자. \n",
    "REMIX는 보통 개발환경에서 제공하는 컴파일, 디버깅, 편집, 배포, 테스트 등의 기능을 제공한다.\n",
    "온라인에서 사용하는 것이 불편하다면, https://github.com/ethereum/remix-live/tree/gh-pages로 가서 zip파일을 내려받아 자신의 컴퓨터에 설치하여 사용할 수 있다.\n",
    "\n",
    "또한 github과 연동하여 사용할 수 있다. ```&gist=여기에 id```를 URL에 넣어서 전송하여, gist로 소스코드를 내보내거나 읽을 수 있다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Solidity가 처음이라 명령어가 낯설겠지만, 객체지향언어이므로 클래스를 코딩하는 것과 같이 시작을 한다.\n",
    "지금은 한 사이클을 완성하기 위해서 하는 코딩이다. 명령어는 차츰 배워나가게 된다.\n",
    "REMIX에서 테스트해보고 요구사항대로 작동하면 코드를 복사해서 저장한다.\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "1 | 메이저 버전 0.6이상 가운데, 최신 버전으로 컴파일. 앞의 햇 ```^```표시가 그런 의미이다.\n",
    "2 | 컨트랙 명칭을 Hello로 정함\n",
    "3 | ```sayHello()``` 함수, string으로 지역변수 값을 반환하는 단순 조회\n",
    "4 | 문자열 ```Hello World``` 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/Hello.sol\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/Hello.sol\n",
    "pragma solidity ^0.6.0;\n",
    "contract Hello {\n",
    "    function sayHello() pure public returns(string memory) {\n",
    "        return \"Hello World\";\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.2 단계 2: 컴파일\n",
    "\n",
    "소스코드를 컴파일하는 목적은 (1) ABI와 (2) bytecode를 얻기 위한 것이다.\n",
    "컴파일은 (1) REMIX를 사용하거나, (2) solc compiler를 사용하면 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### REMIX 컴파일\n",
    "\n",
    "REMIX에서 버전 0.6.0으로 컴파일 해보자.\n",
    "* ```Hello.sol```을 코딩한 후,\n",
    "* ```compile``` 버튼을 누른다.\n",
    "* ```Compilation Details``` 버튼을 누르면, ABI와 bytecode가 생성되어 있다.\n",
    "또는 ```WEB3DEPLOY```에 ABI, bytecode가 포함된 코드를 발견할 수 있다.\n",
    "주의할 점은 ```WEB3DEPLOY```가 우리가 사용하는 **web3.js 버전을 지원**하는지의 여부이다.\n",
    "\n",
    "![alt text](figures/6_helloWeb3Remix.png \"geth download page\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### solc compile\n",
    "\n",
    "설치해 놓은 solc commpiler를 실행하여 ABI, bytecode를 생성할 수 있다.\n",
    "sayHello()의 gas가 ```infinite```라고 하는 것은 반드시 무한대로 필요하다는 의미는 아니다.\n",
    "(```solc --asm src/Hello.sol```로 컴파일을 하면 backward jump 문이 포함되어 있는 경우 무한대로 계산)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solc, the solidity compiler commandline interface\n",
      "Version: 0.6.1+commit.e6f7d5a4.Windows.msvc\n"
     ]
    }
   ],
   "source": [
    "!solc --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "ABI는 컨트랙과 인터페이스하기 위한 표준으로 JSON으로 출력된다. 아래의 abi를 보자. \n",
    "```sayHello()``` 함수의 입력 ```inputs```, 출력 ```outputs```를 정의하고 ```stateMutability```가 ```pure```, ```view```, ```non-payable```, ```payable``` 인지 정의하고 있다.\n",
    "이전에는 ```constant```, ```payable```이 사용되었지만 지금은 제거되어 ```stateMutability```로 대체된다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n",
      "======= src/Hello.sol:Hello =======\r\n",
      "Gas estimation:\r\n",
      "construction:\r\n",
      "   105 + 57200 = 57305\r\n",
      "external:\r\n",
      "   sayHello():\tinfinite\r\n",
      "Binary:\r\n",
      "608060405234801561001057600080fd5b5061011e806100206000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063ef5fb05b14602d575b600080fd5b603360ab565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101560715780820151818401526020810190506058565b50505050905090810190601f168015609d5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60606040518060400160405280600b81526020017f48656c6c6f20576f726c6400000000000000000000000000000000000000000081525090509056fea26469706673582212208ff7c230fefd3d4a66a11d93dd077f556120f8054ee595e3f77349648b8460e064736f6c63430006010033\r\n",
      "Contract JSON ABI\r\n",
      "[{\"inputs\":[],\"name\":\"sayHello\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]\r\n"
     ]
    }
   ],
   "source": [
    "!solc --abi --bin --gas src/Hello.sol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 언어에 내장된 solc\n",
    "\n",
    "geth 1.6부터는 eth_compilers, eth_compileSolidity 지원이 중단되었다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "!geth --exec \"eth.getCompilers()\" attach http://localhost:8345"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "다른 언어에서 내장형으로 컴파일 할 수 있다. node solc, py-solc 등이 제공되고 있다. 한 줄씩 실행하는 Solidity REPL 기능도 설치하여 사용할 수 있다.\n",
    "```python\n",
    "npm install solidity-repl\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.3 단계 3: 배포\n",
    "\n",
    "컨트랙 배포의 목적은 주소이다. \n",
    "컴파일하고 구한 ABI, bytecode를 사용해 배포된 컨트랙의 블록체인 주소를 얻는 것이다.\n",
    "필요한 절차는:\n",
    "* (3-1) 앞 2단계의 컴파일을 하고 그 결과로 얻은 **ABI, byteode를 사용해서 contract 객체를 생성**하고\n",
    "* (3-2) 그 객체의 배포를 ```deploy()``` 함수로 요청하고 ```transactionHash```를 얻음)\n",
    "* (3-3) 마이닝을 하고 나면 ```blockchain```에서의 주소 ```contractAddress```를 받게 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 단계 3-1: contract 생성\n",
    "\n",
    "```new()``` 명령어로 객체를 생성한다. 이 때 ABI가 필수적으로 필요하고, address, options은 꼭 그렇지 않다.\n",
    "\n",
    "```python\n",
    "new web3.eth.Contract(abi [, address] [, options])\n",
    "```\n",
    "\n",
    "* abi: 컨트랙에 대한 json 인터페이스\n",
    "* address: 컨트랙이 배포된 블록체인 주소를 말하며, 최초 배포할 때는 당연히 없으므로 비워놓는다. 배포된 컨트랙을 사용할 경우 해당 주소를 적어주면 된다.\n",
    "* options: from, gasPrice, gas, data (컨트랙의 바이트코드)\n",
    "\n",
    "\n",
    "코드로 표현해보자. ABI, 바이트코드를 추가해서 컨트랙을 생성하고 있다.\n",
    "```python\n",
    "> var myGreeter = new web3.eth.Contract(_abi, {data:'0x'+_bin});\n",
    "undefined\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 단계 3-2 배포요청\n",
    "\n",
    "#### ```deploy()```\n",
    "컨트랙을 배포하려면 ```deploy()``` 함수를 사용하면 해당 컨트랙을 블록체인에 배포하게 된다.\n",
    "\n",
    "```python\n",
    "myGreeter.deploy(options)\n",
    "```\n",
    "\n",
    "options에 설정할 수 있는 입력은 data와 arguments를 포함한다.\n",
    "* data: 컨트랙의 바이트코드\n",
    "* arguments: 컨트랙 생성자는 인자를 가질 수 있다. 그 인자를 넣고, 없으면 생략한다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ```send()```\n",
    "\n",
    "컨트랙을 배포할 경우, 물론 블록체인에 전송해야 한다.\n",
    "```deploy()``` 함수에 연결하여 ```send()``` 함수를 적어준다.\n",
    "\n",
    "```python\n",
    "send(options [, callback])\n",
    "```\n",
    "* options에는 ```from```, ```gasPrice```, ```gas```, ```value```\n",
    "* callback함수는 앞의 함수 ```send()```가 실행된 후 실행이벤트 ('transactionHash' 등)에 따라 callback된다. 첫 인자는 'error'를 넣어주어야 한다. callback 함수는 **PromiEvent를 반환**한다. ```PromiEvent```에 ```on```, ```once```, ```off``` 함수를 연결 chaining하여 이벤트를 처리할 수 있다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 비동기함수에 대한 Promise Events\n",
    "\n",
    "web3.js에서의 함수는 promise를 반환한 다음 연결함수 ```on```, ```once```, ```off```를 통해 이벤트 event를 발생할 수 있다. 사용할 수 있는 PromiEvent는:\n",
    "* ```transactionHash```: 거래가 전송된 직후 transction hash가 발생하는 이벤트 발생\n",
    "* ```receipt```: transactionReceipt이 만들어지는 이벤트 발생\n",
    "* ```confirmation``` 매 24번째 confirmation 마다 이벤트 발생\n",
    "* ```error```: 오류에 대해 이벤트 발생\n",
    "\n",
    "예를 들어, 이벤트가 발생하면 그 이벤트를 출력하는 명령문이다.\n",
    "```\n",
    "web3.eth.sendTransaction({from: '0x123...', data: '0x432...'})\n",
    ".once('sending', function(payload){ ... })\n",
    ".once('sent', function(payload){ ... })\n",
    ".once('transactionHash', function(hash){ ... })\n",
    ".once('receipt', function(receipt){ ... })\n",
    ".on('confirmation', function(confNumber, receipt, latestBlockHash){ ... })\n",
    ".on('error', function(error){ ... })\n",
    ".then(function(receipt){\n",
    "    // 마이닝이 끝나면 실행되는 코드\n",
    "});\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 단계 3-3 주소 출력에 필요한 ```then()```\n",
    "\n",
    "배포를 하는 이유는 무엇일까? 주소를 알아내는 것이다. 블록체인에 배포된 주소가 있어야, 그 주소를 통해 그 컨트랙을 호출할 수 있기 때문이다.\n",
    "그러나 deploy() 함수는 비동기적인 특징이 있으므로, 배포하고 나면 바로 주소가 주어지는 것이 아니라 대신 Promise가 주어진다. 이를 해소해야만 비로서 주소를 얻을 수 있게 된다.\n",
    "\n",
    "```promise```는 결과 값이 지연되는 경우의 약속코드이고, ```then()``` 함수로 성공인 경우, 실패인 경우로 약속코드의 결과 값을 출력할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **자바스크립트 Promise**\n",
    "\n",
    "> 비동기 함수를 처리하는 패턴으로,\n",
    "> **결과 값을 지금이 아니고, 약속을 하여 처리에 필요한 시간이 경과한 후 반환**하게 된다.\n",
    "> 약속은 아직 완료되지 않은 실행을 의미하며, ```fulfilled```, ```rejected```, ```pending``` 또는 ```settled (fulfilled 혹은 rejected)```이 될 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "아래 코드를 보자.\n",
    "* ```doPromise```은 ```promise```의 인자는 성공에 해당하는 ```myResolve``` 또는 실패에 해당하는 ```myReject```를 가진다.\n",
    "* 이 값은 ```doPromise```의 연결 함수 ```then()``` 함수의 인자 ```my```로 넘겨가게 된다. ```err```인 경우에 callback으로 처리할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/promiseThen.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/promiseThen.js\n",
    "var doPromise = new Promise(function(myResolve, myReject) {\n",
    "    myResolve(123);  //when successful, returns 123\n",
    "    //myReject(\"Rejected\"); //when error\n",
    "});\n",
    "\n",
    "//\n",
    "doPromise.then(function(my){\n",
    "        console.log(\"RETURNED: \"+my);\n",
    "    }, function(err) {\n",
    "        console.log(\"ERROR: \"+err);\n",
    "    });"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "코드에서 성공인 경우에 실행되는 ```myResolve(123)``` 또는 ```myReject(\"Rejected\")```를 도움말처리 comment out를 해서 실행해보자. 이렇게 연습을 해보면 Promise, then코드를 좀 더 잘 이해하게 될 것이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RETURNED: 123\n"
     ]
    }
   ],
   "source": [
    "!node src/promiseThen.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "promise를 3으로 결과 값을 만들고 then() 함수로 보낸다. 연이어 10을 곱해서 다음 then()으로 보낸다.\n",
    "결과가 하나씩 순서대로 출력되고 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/promiseThen1.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/promiseThen1.js\n",
    "new Promise(function(resolve, reject) {\n",
    "    resolve(3)\n",
    "}).then(function(res) {\n",
    "    console.log(\"3 is expected...\"+res); //3\n",
    "    return res * 10;\n",
    "}).then(function(res) {\n",
    "    console.log(\"30 is expected...\"+res); //30 as multiplied by 10 on 2 lines above\n",
    "    return res * 10;\n",
    "}).then(function(res) {\n",
    "    console.log(\"300 is expected...\"+res); //300\n",
    "});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 is expected...3\r\n",
      "30 is expected...30\r\n",
      "300 is expected...300\r\n"
     ]
    }
   ],
   "source": [
    "!node src/promiseThen1.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 비동기 함수의 async/await\n",
    "\n",
    "비동기 함수는 Promise를 반환한다. 비동기이므로 바로 값을 반환하지 않고 일단 약속만 돌려주는 것이다. Promise가 성공적으로 완료되면 결과 값이 반환되고, 그렇지 못하는 경우에는 예외를 발생하거나 오류가 발생하여 반환된다.\n",
    "\n",
    "**await**는 **async 함수의 실행을 promise가 완결할 때까지 (fulfilled 또는 rejected) 중지**하고, promoise가 완료되는 경우 그 실행을 재개하고 그 결과 값을 받게된다 (성공인 경우 결과 값, rejected이면 거절된 값). **await 함수는 async 함수에서만** 쓰이고, 전역으로는 쓰일 수 없다.\n",
    "async/await를 사용하면, await가 결과가 나올 때까지 대기상태로 있기 때문에 **```.then```을 사용하지 않아도 된다**.\n",
    "또한 **try..catch문**을 (```.catch``` 구문을 사용하기 보다는) 쓰면 편리하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/asyncAwait.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/asyncAwait.js\n",
    "async function hello() {\n",
    "    await 1000;\n",
    "    return \"hello\";\n",
    "}\n",
    "hello().then(console.log);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\r\n"
     ]
    }
   ],
   "source": [
    "!node src/asyncAwait.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 마이닝\n",
    "\n",
    "배포를 완성하려면 그 거래가 마이닝되어야 한다.\n",
    "```python\n",
    "> miner.start(1);admin.sleepBlocks(1);miner.stop\n",
    "```\n",
    "\n",
    "마이닝이 되고 나면 비로서 콘트랙이 블록체인에 배포된다.\n",
    "따라서 ```blockNumber```가 증가하게 된다.\n",
    "그리고 콘트랙이 배포된 블록체인의 주소 값이 생성된다. 아래 ```getTransactioinReceipt(해시주소)```를 조회해보면 마이닝이 완료되기 전에는 null이다.\n",
    "\n",
    "```python\n",
    "> eth.getTransactionReceipt(\"0x3c58a...50bd5\")\n",
    "> eth.getTransactionReceipt(\"0x3c58a...50bd5\").contractAddress\n",
    "> eth.getCode(greeter.address) 배포 주소로 deployed code를 확인\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3단계 실행에 필요한 코드 종합: Web3 과거 버전\n",
    "\n",
    "REMIX에서 자동생성된 배포 파일을 가져와서 해보자. 이 web3의 어떤 버전을 사용하는지 유의한다.\n",
    "버전이 다르면 당연히 문제가 되기 때문이다.\n",
    "REMIX에서 복사해서 HttpProvider만 생성하도록 수정한 아래 ```HelloDeploy__.js```는 이전 버전의 문법을 사용하기 때문에 web3.js 1.0이상 버전에서는 실행되지 않는다 (앞으로 web3.js 0.20.x에서 실행하는 파일명 뒤에는 underscore를 붙임).\n",
    "실행하기 전, geth를 띄워놓아서 코드를 실행하면 어떤 변화가 발생하는지 지켜보는 것이 좋다. 포트번호만 다르게 해서 ganache도 같이 띄워 놓자.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/HelloDeploy__.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/HelloDeploy__.js\n",
    "var Web3=require('web3');\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://localhost:8345\"));\n",
    "var helloContract = web3.eth.contract([{\"inputs\":[],\"name\":\"sayHello\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]);\n",
    "var hello = helloContract.new(\n",
    "   {\n",
    "     from: web3.eth.accounts[0], \n",
    "     data: '0x608060405234801561001057600080fd5b5061011e806100206000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063ef5fb05b14602d575b600080fd5b603360ab565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101560715780820151818401526020810190506058565b50505050905090810190601f168015609d5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60606040518060400160405280600b81526020017f48656c6c6f20576f726c6400000000000000000000000000000000000000000081525090509056fea2646970667358221220b6877a972a9ca7f396c5cb7c0a7ae50d7532a82ded3789e90afa4b3e108a631364736f6c63430006010033', \n",
    "     gas: '4700000'\n",
    "   }, function (e, contract){\n",
    "    console.log(e, contract);\n",
    "    if (typeof contract.address !== 'undefined') {\n",
    "         console.log('Contract mined! address: ' + contract.address + ' transactionHash: ' + contract.transactionHash);\n",
    "    }\n",
    " })"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위 프로그램은 web3.js@0.20.x 버전의 문법으로 작성되었고, 버전업이 되면서 명령어가 부분적으로 변경되어야 한다.\n",
    "현재 web3 버전으로 실행하면 오류가 발생하게 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/jsl/Code/git/bb/jsl/bitcoin/src/HelloDeploy__.js:3\r\n",
      "var helloContract = web3.eth.contract([{\"inputs\":[],\"name\":\"sayHello\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]);\r\n",
      "                             ^\r\n",
      "\r\n",
      "TypeError: web3.eth.contract is not a function\r\n",
      "    at Object.<anonymous> (/home/jsl/Code/git/bb/jsl/bitcoin/src/HelloDeploy__.js:3:30)\r\n",
      "    at Module._compile (module.js:652:30)\r\n",
      "    at Object.Module._extensions..js (module.js:663:10)\r\n",
      "    at Module.load (module.js:565:32)\r\n",
      "    at tryModuleLoad (module.js:505:12)\r\n",
      "    at Function.Module._load (module.js:497:3)\r\n",
      "    at Function.Module.runMain (module.js:693:10)\r\n",
      "    at startup (bootstrap_node.js:188:16)\r\n",
      "    at bootstrap_node.js:609:3\r\n"
     ]
    }
   ],
   "source": [
    "!node src/HelloDeploy__.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3단계 실행에 필요한 코드 종합: Web3 1.0 이상 버전\n",
    "\n",
    "web3.js 최신버전에서 실행이 되도록 수정해 주자.\n",
    "우선, Gas 값을 계산해보자. 이를 위해서는 data를 입력해 주면 그 바이트 크기와 Opcode에 따라 계산된다.\n",
    "\n",
    "gas를 산정하기 위해서는 ```estimateGas()```로 한다.\n",
    "```python\n",
    "myGreeter.deploy().estimateGas()\n",
    "    .then((estimatedGas) => {\n",
    "        console.log(\"Estimated gas: \" + estimatedGas);\n",
    "        gas = estimatedGas;\n",
    "    })\n",
    "```\n",
    "\n",
    "getGasPrice()는 사설망에서는 일정 금액으로 일괄 설정되어 있다 (아래 금액을 환산하면 0.000000001 이더).\n",
    "그러나 평균가격은 이 보다 높다 (2022년 1월 10일 0.00000020을 넘고 0.000000050 내외에서 변동이 있다)\n",
    "```python\n",
    "> web3.eth.getGasPrice().then(console.log);\n",
    "> 1000000000\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이전 버전과 비교해 보자. 컨트랙을 생성할 때 ```new``` 명령어를 사용하고 있다.\n",
    "주소 from은 생략할 수 있다.\n",
    "잠깐, ganache-cli가 설치되었다면, 오류가 발생하게 된다.\n",
    "ganache-cli는 더 이상 지원이 중단되었으므로, uninstall하고 ganache를 새로 install하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/HelloDeployGas.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/HelloDeployGas.js\n",
    "var Web3=require('web3');\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://localhost:8345\"));\n",
    "var shelloContract = new web3.eth.Contract([{\"inputs\":[],\"name\":\"sayHello\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]);\n",
    "shelloContract.deploy({\n",
    "        //from: '0x4aae75084f715390Aad4a251DC70327AfEf8a03c',\n",
    "        data: '0x608060405234801561001057600080fd5b50610139806100206000396000f3fe608060405234801561001057600080fd5b5060043610610048576000357c010000000000000000000000000000000000000000000000000000000090048063ef5fb05b1461004d575b600080fd5b6100556100d0565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561009557808201518184015260208101905061007a565b50505050905090810190601f1680156100c25780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60606040805190810160405280600b81526020017f48656c6c6f20576f726c6400000000000000000000000000000000000000000081525090509056fea165627a7a72305820992c2f4c73a27b9eb53c6aa7b52ba8a5eddba258089eb7d1a3710711703459950029', \n",
    "    }).estimateGas().then(function(myGas) {\n",
    "        console.log(\"Estimated gas: \" + myGas);\n",
    "        gas = myGas;\n",
    "    })\n",
    "    .catch(console.error);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "컨트랙을 생성, 배포하기 위해 소요되는 gas는 120,415, gasPrice를 곱하면 필요한 0.006 ether이다.\n",
    "한화로 환산하면 24,000원이 필요하다. 적지 않은 금액이다.\n",
    "gasPrice가 2배가 되는 경우도 많다. 그렇다면 48,000원으로 껑충 높아진다.\n",
    "\n",
    "120,000 Gas * 0.000000050 * 4백만원 = 24,000원\n",
    "\n",
    "게다가 곧 배포된 컨트랙을 사용하기 위해서 별도로 gas를 지불해야 한다.\n",
    "이 금액을 더한다면 가격은 더 올라가게 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estimated gas: 120415\n"
     ]
    }
   ],
   "source": [
    "!node src/HelloDeployGas.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 키 읽기\n",
    "\n",
    "주소를 출력해보자. web3 0.20.x에서는 계정배열의 인덱스로 쉽게 얻을 수 있었다.\n",
    "잠깐! **geth console에서는 배열 인덱스로 가능**하다. 지금은 **노드에서 실행했을 경우는 배열 인덱스가 더 이상 지원되지 않고** 있다.\n",
    "\n",
    "```python\n",
    "var address0 = web3.eth.accounts[0];  //이렇게 읽어올 수 없다.\n",
    "```\n",
    "\n",
    "web3.js 1.0 이상에서는 비동기방식으로 계정을 읽어오며, promise가 반환이 된다.\n",
    "비동기방식으로 키를 설정하기 어려우므로, 일단 하드코딩해서 키 값을 넣자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/getMyAddr.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/getMyAddr.js\n",
    "var Web3=require('web3');\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://localhost:8345\"))\n",
    "var myAddr0;\n",
    "web3.eth.getAccounts().then(console.log);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ '0xEb670169A5fcD2550035588A2ba3b45509703ABd',\n",
      "  '0xF724CDbfCf9C94f28547b1111B3A6E3672a9aDCE',\n",
      "  '0xE49Fd7F47c5cA0c061cb842EF177f4F9a55C1F7B',\n",
      "  '0x7CdA18350f0E68C37a110FfE12236Ea86Bf836A5',\n",
      "  '0x0CB5e8D12Ca5C0d367AE2AE293313BfC7B61b159',\n",
      "  '0xB075622d93692A41D90B57E27a5C99A1881aFd55',\n",
      "  '0x5fc4A84F7e5Cac9d9c0eF090182c121a71B50620',\n",
      "  '0x8f72c892BAEaA4aD1F03da6ce41841A1243Ad30B',\n",
      "  '0x60f55f755Fd7fD95e3521b1f5A5BBd6f1873Da48',\n",
      "  '0xe04852Cb018778545e75CC21EEC1849DdCdFa79f' ]\n"
     ]
    }
   ],
   "source": [
    "!node src/getMyAddr.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ganache 배포 web3 1.20\n",
    "\n",
    "ganache로 배포하려면 포트 번호 8345로 해주면 된다.\n",
    "지급계정 주소는 ```getMyAddr```실행하고 출력된 목록에서 복사해서 넣어주었다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing src/HelloDeploy.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/HelloDeploy.js\n",
    "var Web3=require('web3');\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://localhost:8345\"));\n",
    "var shelloContract = new web3.eth.Contract([{\"inputs\":[],\"name\":\"sayHello\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]);\n",
    "shelloContract\n",
    "    .deploy({\n",
    "            data: '0x608060405234801561001057600080fd5b50610139806100206000396000f3fe608060405234801561001057600080fd5b5060043610610048576000357c010000000000000000000000000000000000000000000000000000000090048063ef5fb05b1461004d575b600080fd5b6100556100d0565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561009557808201518184015260208101905061007a565b50505050905090810190601f1680156100c25780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60606040805190810160405280600b81526020017f48656c6c6f20576f726c6400000000000000000000000000000000000000000081525090509056fea165627a7a72305820992c2f4c73a27b9eb53c6aa7b52ba8a5eddba258089eb7d1a3710711703459950029', \n",
    "    })\n",
    "    .send({\n",
    "     from: \"0xEb670169A5fcD2550035588A2ba3b45509703ABd\",\n",
    "     gas: '4700000'\n",
    "    }, function (error, transactionHash){ \n",
    "            console.log(error, transactionHash); \n",
    "    })\n",
    "    .then(function(newContractInstance){\n",
    "        console.log(newContractInstance.options.address)\n",
    "    });"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "null '0xc255f82ab2150858ce0414f2ceaf0f919a64359f405ebded942bd04610f1a2f4'\n",
      "0x0d3C29cAD3c40497699e13CC34bA099E1fe426Ba\n"
     ]
    }
   ],
   "source": [
    "!node src/HelloDeploy.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### geth배포 web3 1.20\n",
    "\n",
    "geth에 배포할 경우에는 지급계정을 해제하고 또한 마이닝도 해주어야 한다.\n",
    "**지급계정을 해제**하면 시간을 설정하지 않는한 1회에 한한다. 또한 **잔고**가 남아 있어, 거래에 필요한 gas비용을 충당할 수 있어야 한다.\n",
    "**계정, 비밀번호, 해제기간**을 인자로 넣어주고 계정을 해제한다. ganache에서는 계정를 해제해 줄 필요가 없다.\n",
    "\n",
    "계정해제를 해주지 않고 거래를 요청하면 '불충분 가스' 오류가 생성된다 (```Error: Returned values aren't valid, did it run Out of Gas?```)\n",
    "\n",
    "**노드**에서는 다음과 같이 계정을 해제해준다. 이 코드를 프로그램에 위 배포프로그램에 넣어 실행할 수도 있다. 비밀번호를 넣어 하드코딩한다는 것은 좋은 생각은 아니다.\n",
    "```python\n",
    "web3.eth.personal.unlockAccount(\"0x778ea...\",\"password\",1000).then(console.log('unlocked!'));\n",
    "```\n",
    "\n",
    "**geth**창에서 직접해줄 수 있다. coinbase로 하거나 eth.accounts[0]과 같이 인덱스를 넣어주어도 된다.\n",
    "```python\n",
    "personal.unlockAccount(eth.coinbase);  //or eth.accounts[0]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/HelloDeploy2.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/HelloDeploy2.js\n",
    "var Web3=require('web3');\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://117.16.44.45:8445\"));\n",
    "var shelloContract = new web3.eth.Contract([{\"constant\":true,\"inputs\":[],\"name\":\"sayHello\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}]);\n",
    "shelloContract\n",
    "    .deploy({\n",
    "            data: '0x608060405234801561001057600080fd5b50610139806100206000396000f3fe608060405234801561001057600080fd5b5060043610610048576000357c010000000000000000000000000000000000000000000000000000000090048063ef5fb05b1461004d575b600080fd5b6100556100d0565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561009557808201518184015260208101905061007a565b50505050905090810190601f1680156100c25780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60606040805190810160405280600b81526020017f48656c6c6f20576f726c6400000000000000000000000000000000000000000081525090509056fea165627a7a72305820992c2f4c73a27b9eb53c6aa7b52ba8a5eddba258089eb7d1a3710711703459950029', \n",
    "    })\n",
    "    .send({\n",
    "     from: \"0x21c704354D07f804baB01894e8B4eB4E0EBA7451\",\n",
    "     gas: '4700000'\n",
    "    }, function (error, transactionHash){ \n",
    "            console.log(error, transactionHash); \n",
    "    })\n",
    "    .on('transactionHash', function(error,transactionHash) {\n",
    "        console.log(\"hash-- \"+transactionHash);\n",
    "    })\n",
    "    .on('receipt', function(receipt) {\n",
    "        console.log('receipt:: '+receipt.contractAddress);\n",
    "    })\n",
    "    .then(function(newContractInstance){\n",
    "        console.log(newContractInstance.options.address)\n",
    "    });"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "null '0xa40eaf3185812b93c6a5432288a6efe6f6a1d3c644ca50592d850256afa3729c'\r\n",
      "hash-- undefined\r\n",
      "receipt:: 0xb8770393a75E5B88E7d5cFb5db1068e28B4dA8Ba\r\n",
      "0xb8770393a75E5B88E7d5cFb5db1068e28B4dA8Ba\r\n"
     ]
    }
   ],
   "source": [
    "!node src/HelloDeploy2.js"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "null '0x93e0955edc48e1986e326257948d4fd0258cf19415058161f52249709e0bee70'\n",
      "hash-- undefined\n",
      "receipt:: 0x462F4f235D290235A42d5171A5D1269e32278543\n",
      "0x462F4f235D290235A42d5171A5D1269e32278543\n"
     ]
    }
   ],
   "source": [
    "!node src/HelloDeploy2.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "node로 ```HelloDeploy2.js```를 실행하면 화면좌측에서 보듯이 transaction이 생성되고 그 hash 값이 주어진다.\n",
    "\n",
    "우측 geth 단말에서 보듯이, 대기하고 있는 transaction hash 값이 서로 일치한다.\n",
    "마이닝을 하고 나면 콘트랙 주소가 주어진다.\n",
    "\n",
    "```python\n",
    "INFO [01-07|10:34:47.871] Submitted contract creation\n",
    "fullhash=0x851d565882f9758d03ef232a5badb6f23629a1f5768db2f3ca2c13e22a1ef40b\n",
    "contract=0xd29b9e81388F91658a2120587A0e123c29eC6c36\n",
    "```\n",
    "\n",
    "![alt text](figures/6_helloWeb3DeployMining.png \"deploy hello.sol using web3 with mining\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{\r\n",
      "    blockHash: \u001b[1mnull\u001b[0m,\r\n",
      "    blockNumber: \u001b[1mnull\u001b[0m,\r\n",
      "    from: \u001b[32m\"0x21c704354d07f804bab01894e8b4eb4e0eba7451\"\u001b[0m,\r\n",
      "    gas: \u001b[31m4700000\u001b[0m,\r\n",
      "    gasPrice: \u001b[31m1000000000\u001b[0m,\r\n",
      "    hash: \u001b[32m\"0xda6de30494de91cd34c2a92d33e25720935e5f6b2fc5a4ec6b5d59990935ba53\"\u001b[0m,\r\n",
      "    input: \u001b[32m\"0x608060405234801561001057600080fd5b50610139806100206000396000f3fe608060405234801561001057600080fd5b5060043610610048576000357c010000000000000000000000000000000000000000000000000000000090048063ef5fb05b1461004d575b600080fd5b6100556100d0565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561009557808201518184015260208101905061007a565b50505050905090810190601f1680156100c25780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60606040805190810160405280600b81526020017f48656c6c6f20576f726c6400000000000000000000000000000000000000000081525090509056fea165627a7a72305820992c2f4c73a27b9eb53c6aa7b52ba8a5eddba258089eb7d1a3710711703459950029\"\u001b[0m,\r\n",
      "    nonce: \u001b[31m265\u001b[0m,\r\n",
      "    r: \u001b[32m\"0xe995ae41b4193839df768ad629a9f2dc09ec7cfc08d5f42ce1207021d3395835\"\u001b[0m,\r\n",
      "    s: \u001b[32m\"0x26c380eb4f60e90cbdb54a45fbf691ce37b18b4b3e8603875f3cf5f6e30a0553\"\u001b[0m,\r\n",
      "    to: \u001b[1mnull\u001b[0m,\r\n",
      "    transactionIndex: \u001b[1mnull\u001b[0m,\r\n",
      "    v: \u001b[32m\"0x66\"\u001b[0m,\r\n",
      "    value: \u001b[31m0\u001b[0m\r\n",
      "}]\r\n"
     ]
    }
   ],
   "source": [
    "!geth --exec \"eth.pendingTransactions\" attach http://117.16.44.45:8445"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.4 단계 4: 사용\n",
    "\n",
    "컨트랙이 배포되었고, 그 주소를 획득하였다.\n",
    "이제 그 컨트랙의 API를 호출해보자.\n",
    "* 먼저 컨트랙의 객체를 생성하고,\n",
    "* methods를 통해 API를 호출한다.\n",
    "\n",
    "### 4-1 주소를 가진 객체생성\n",
    "\n",
    "배포한 콘트랙을 사용하려면 객체를 먼저 생성해야 한다.\n",
    "앞서 블록체인에 생성된 객체를 얻어와야 하므로, 거래가 발생하게 된다.\n",
    "거래가 발생하면, transactionHash가 생성되고, 마이닝이 수행되면 블록체인에 기록된다.\n",
    "앞에서 얻은 ABI, contractAddress가 필요하다.\n",
    "web3 0.20.x에서는 ```at()``` 함수를 사용하는데, 앞서 얻은 컨트랙 주소를 넣어준다.\n",
    "\n",
    "```python\n",
    "var greeter = eth.contract(ABI).at(Address); //web3 0.20.x\n",
    "```\n",
    "\n",
    "web3 1.20에서는 ```new``` 명령어와 함께, abi와 컨트랙주소를 인자로 넘겨주어야 한다.\n",
    "```\n",
    "var MyContract = new web3.eth.Contract(abi, 컨트랙주소);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 4-2 methods\n",
    "\n",
    "```methods```는 함수호출을 가능하게 한다. 즉 ```myContract.methods.myMethod(123)```과 같이 컨트랙의 함수를 호출할 수 있게 한다. 이어서 call 또는 send함수의 호출이 가능하다.\n",
    "\n",
    "```\n",
    "myballot.methods.vote.call(1);\n",
    "myballot.methods.vote.sendTransaction(1, {from: primary})\n",
    "\n",
    "```\n",
    "인자가 여러 개인 경우\n",
    "```\n",
    "myInstance.methods.myStateChangingMethod('param1', 23, {value: 200, gas: 2000});\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### call, send\n",
    "\n",
    "주소를 획득하면 컨트랙 객체를 사용할 수 있게 된다.\n",
    "로컬 블록체인에서 실행하는 ```call()``` 또는 블록체인에 기록되는 ```send()``` 함수를 사용한다.\n",
    "거래가 발생하면, ```transactionHash```가 생성된다. 마이닝 전까지 대기 pending 한다.\n",
    "\n",
    "함수 | 설명 | 블록체인\n",
    "----------|----------|----------\n",
    "```call()``` | 로컬에서 실행, 마이닝 불필요 | ```view```, ```pure```, ```constant``` 함수를 호출하는 경우. 블록체인에 기록되지 않는다.\n",
    "```send()``` | 블럭체인에 기록하는 거래라서 마이닝 필요 | 블록체인에 기록된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing src/HelloUse__.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/HelloUse__.js\n",
    "var Web3=require('web3');\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://117.16.44.45:8345\"));\n",
    "var shelloContract = web3.eth.contract([{\"constant\":true,\"inputs\":[],\"name\":\"sayHello\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}]);\n",
    "var hello = shelloContract.at(\"0x325bb34f889fa04ada00fa126ed7e8a7600080ba\");\n",
    "console.log(hello.sayHello.call());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "API를 사용하는 프로그램은 geth, ganache 어느 경우에나 포트번호만 변경해주면 된다.\n",
    "물론 컨트랙의 주소는 정확하게 복사해서 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing src/HelloUse.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/HelloUse.js\n",
    "var Web3=require('web3');\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://localhost:8345\"));\n",
    "var shelloContract = new web3.eth.Contract([{\"constant\":true,\"inputs\":[],\"name\":\"sayHello\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}],\n",
    "                                      \"0x0d3C29cAD3c40497699e13CC34bA099E1fe426Ba\");\n",
    "shelloContract.methods.sayHello().call().then(function(str) {console.log(str);});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "!node src/HelloUse.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **버전의 문제**\n",
    "\n",
    "> ```Hello```를 Geth에서 Deploy는 성공하였지만, API를 사용하는 단계에서 반환 값의 오류가 나는 경우가 있다.\n",
    "예를 들어, 이런 오류를 경험하였다 **ERROR Returned values aren't valid. did it run Ouf of Gas?**\n",
    "이 경우 **Solidity 버전을 낮추어** 컴파일 한 후 (0.4.25, 0.5.0, 0.5.1, 0.5.3 모두 성공, 0.5 후반대와 0.6은 모두 오류), ABI와 Bytecode로 새로 배포해서 API를 호출해보자.\n",
    "또는 getPastEvents() 함수를 사용하는 경우 web3 1.0.0 beta에서는 **ERROR Returned values aren't valid. did it run Ouf of Gas?** 오류가 나지만, **web3 버전을 낮추어** 0.20.7에서는 그렇지 않다는 이슈가 있기도 하다.\n",
    "나중에 배우겠지만 **Library**를 배포하고, API를 사용하면서 Solidity 0.5.x에서는 올바르게 작동하지 않았다. 버전을 낮추어 0.4.25로 하니까 오류가 사라졌다. Solidity 언어가 버전 간의 **후방호환성 backward compatibility**가 보장이 되지 않아서 문제가 발생할 수 있다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5 웹디앱\n",
    "\n",
    "앞서 구현한 Hello 컨트랙을 웹페이지로 만들어 보자.\n",
    "매우 단순한 기능이지만 웹페이지에서 블록체인과 인터페이스하게 된다.\n",
    "잠깐 생각해 보자. 지금까지 우리가 알고 있는 웹은 서버가 있기 마련이다.\n",
    "웹페이지에서 버튼을 누르거나 클릭을 하거나 서비스를 요청하고, 그 요청을 받아 처리하는 중앙 서버가 있다.\n",
    "여기서 만드는 웹페이지는 서비스가 처리하되는 중앙 서버가 없는 **분산 애플리케이션 Distriubted Application, dApp**이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "프로젝트 디렉토리 아래 scripts 폴더를 만든다.\n",
    "html을 편집기를 이용해서, 파일을 scripts폴더에 저장한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting scripts/simpleCoinbase.html\n"
     ]
    }
   ],
   "source": [
    "%%writefile scripts/simpleCoinbase.html\n",
    "<!doctype>\n",
    "<html>\n",
    "<head>\n",
    "<script src=\"https://cdn.jsdelivr.net/npm/web3@1.2.5/dist/web3.min.js\"></script>\n",
    "<!-- script src=\"https://cdn.jsdelivr.net/npm/web3@0.20.5/dist/web3.min.js\"></script -->\n",
    "<script type=\"text/javascript\">\n",
    "    //var Web3 = require('web3');  //can be removed\n",
    "    var web3 = new Web3(new Web3.providers.HttpProvider(\"http://localhost:8345\"));\n",
    "\n",
    "    function displayCoinbase() {\n",
    "        var web3version = web3.version;  //web3.version.api\n",
    "        //web3@0.20.x\n",
    "        //document.getElementById('web3ver').innerText = 'web3 version 0.20.x: '+web3version.api;\n",
    "        //document.getElementById('web3coinbase').innerText = 'coinbase: ' + web3.eth.coinbase;\n",
    "        //web3@1.2.x\n",
    "        document.getElementById('web3ver').innerText = 'web3 version: '+web3version;\n",
    "        web3.eth.getCoinbase().then(function(coin) {\n",
    "            document.getElementById('web3coinbase').innerText = 'coinbase: ' + coin;\n",
    "            });\n",
    "    }\n",
    "</script>\n",
    "</head>\n",
    "<body>\n",
    "    <h1>Hello</h1>\n",
    "    <button type=\"button\" onClick=\"displayCoinbase();\">Display Coinbase</button>\n",
    "    <div></div>\n",
    "    <div id=\"web3ver\"></div>\n",
    "    <div id=\"web3coinbase\"></div>\n",
    "</body>\n",
    "</html>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "HTML 코딩이 되었으면 웹서버를 띄운다. 포트번호는 의도적으로 8045을 사용한다.\n",
    "8000번은 누구나 쉽게 접근가능하고, Python 서버는 가벼운 대신 보안을 통제할 수 없으므로 잠깐 사용하는 시간에도 문제가 될 수 있다.\n",
    "\n",
    "명령창을 열어, Python 3.x 버전에서는 ```python3 -m http.server 8045 --bind xxx.xxx.xxx.xxx```로 웹서버를 띄운다.\n",
    "\n",
    "```python\n",
    "C:\\Users\\jsl\\Code\\201711111>python -m http.server 8045\n",
    "Serving HTTP on 0.0.0.0 port 8045 (http://0.0.0.0:8045/) ...\n",
    "127.0.0.1 - - [30/Apr/2020 06:38:09] \"GET / HTTP/1.1\" 200 -\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "다음으로 웹브라우저에서 URL을 넣어서 띄운다.\n",
    "url은 호스트명, 포트번호, 그 다음에 파일경로는 웹서버를 띄운 프로젝트 디렉토리를 기준으로 적어준다.\n",
    "http://xxx.xxx.xxx.xxx:8045/scripts/hello.html\n",
    "\n",
    "로컬호스트에서 띄어보자.\n",
    "```python\n",
    "http://localhost:8045/scripts/simpleCoinbase.html\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "다음으로 Hello 컨트랙으로터 결과를 받아서, \"Hello World!\"를 출력해보자. 적지 않은 시간과 노력을 들어, 처음으로 만드는 dApp이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting scripts/hello.html\n"
     ]
    }
   ],
   "source": [
    "%%writefile scripts/hello.html\n",
    "<!doctype>\n",
    "<html>\n",
    "<head>\n",
    "<script src=\"https://cdn.jsdelivr.net/npm/web3@1.2.5/dist/web3.min.js\"></script>\n",
    "<!-- script src=\"https://cdn.jsdelivr.net/npm/web3@0.20.5/dist/web3.min.js\"></script -->\n",
    "<script type=\"text/javascript\">\n",
    "    //var Web3 = require('web3');  //can be removed\n",
    "    var web3 = new Web3(new Web3.providers.HttpProvider(\"http://localhost:8345\"));\n",
    "\n",
    "    function displayHello() {\n",
    "        var web3version = web3.version;  //web3.version.api\n",
    "        //web3@0.20.x\n",
    "        //var shelloContract = web3.eth.contract([{\"constant\":true,\"inputs\":[],\"name\":\"sayHello\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}]);\n",
    "        //var hello = shelloContract.at(\"0x0d3C29cAD3c40497699e13CC34bA099E1fe426Ba\");\n",
    "        //var hello=hello.sayHello.call();\n",
    "        //document.getElementById('sayhello').innerText = \"The message from blockchain: \" + hello;\n",
    "        //document.getElementById('web3ver').innerText = 'web3 version 0.20.x: '+web3version.api;\n",
    "        //document.getElementById('web3coinbase').innerText = 'coinbase: ' + web3.eth.coinbase;\n",
    "\n",
    "        //web3@1.2.x - can not instanciate a contract\n",
    "        var shelloContract = new web3.eth.Contract([{\"constant\":true,\"inputs\":[],\"name\":\"sayHello\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}],\n",
    "                                      \"0x0d3C29cAD3c40497699e13CC34bA099E1fe426Ba\");\n",
    "        shelloContract.methods.sayHello().call().then(function(str) {\n",
    "            document.getElementById('sayhello').innerText = \"The message from blockchain: \" + str;\n",
    "        });\n",
    "        document.getElementById('web3ver').innerText = '*web3 version: '+web3version;\n",
    "        web3.eth.getCoinbase().then(function(coin) {\n",
    "            document.getElementById('web3coinbase').innerText = 'coinbase: ' + coin;\n",
    "            });\n",
    "    }\n",
    "</script>\n",
    "</head>\n",
    "<body>\n",
    "    <h1>Hello</h1>\n",
    "    <button type=\"button\" onClick=\"displayHello();\">Display Hello</button>\n",
    "    <div></div>\n",
    "    <div id=\"sayhello\"></div>\n",
    "    <div id=\"web3ver\"></div>\n",
    "    <div id=\"web3coinbase\"></div>\n",
    "</body>\n",
    "</html>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 4. Greeter 디앱\n",
    "<a id='e-6'></a>\n",
    "\n",
    "앞서 Hello 컨트랙은 함수 하나만으로 구성되었다.\n",
    "이를 조금 수정하여, **데이터를 저장하는 컨트랙**으로 개발해 보자.\n",
    "저장하는 데이터는 단순한 문자열이고, 구현하는 방식은 보통 프로그램과 크게 다르지 않다.\n",
    "\n",
    "그러나 데이터를 저장하면, gas가 더 필요하다는 것을 주의해야 한다.\n",
    "(256비트 당 20,000 gas가 필요하다).\n",
    "\n",
    "우리가 저장하는 문자열을 생각해보자.\n",
    "string은 동적으로 크기가 할당된다. 반면에 일정한 크기로 제한한다면 bytes4, bytes8 등을 사용하는 편이 필요하다. 최대 32바이트를 사용하다면 bytes32, 크키를 알 수 없다면 string을 사용한다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.1 단계 1. 컨트랙 개발\n",
    "\n",
    "생성자는 배포하는 시점에 실행이 되기 때문에 'Hello' 문자열이 기본으로 저장된다.\n",
    "매우 단순한 기능으로, ```set()```, ```get()```함수를 구현했다.\n",
    "```get()```은 블록체인에서 읽어오는 함수, set()은 블록체인의 값을 변경한다.\n",
    "따라서 ```set()```함수는 블록체인에 저장된다.\n",
    "```web3.js```에서 ```sendTransaction()``` 함수로 호출한다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### REMIX\n",
    "\n",
    "좌측 메뉴에서 ```+``` 버튼을 눌러 프로그램을 새로 연다.\n",
    "프로그램의 이름을 정한다. REMIX의 디렉토리 ```browser/```는 기본으로 주어지는 디렉토리이므로 그냥 둔다.\n",
    "\n",
    "![alt text](figures/6_remixConnectToWebProvider.png \"remix connecting to web provider\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/greeter.sol\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/greeter.sol\n",
    "pragma solidity ^0.6.0;\n",
    "\n",
    "contract Greeter {\n",
    "    string greeting;\n",
    "\n",
    "    constructor() public {\n",
    "        greeting = 'Hello';\n",
    "    }\n",
    "\n",
    "    function setGreeting(string memory _greeting) public {\n",
    "        greeting = _greeting;\n",
    "    }\n",
    "\n",
    "    function greet() view public returns (string memory) {\n",
    "        return greeting;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.2 단계 2. 컴파일\n",
    "\n",
    "REMIX 또는 Solc로 컴파일해볼 수 있다.\n",
    "여기서는 ```solc```로 컴파일 해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n",
      "======= src/greeter.sol:Greeter =======\r\n",
      "Contract JSON ABI\r\n",
      "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"greet\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"_greeting\",\"type\":\"string\"}],\"name\":\"setGreeting\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]\r\n"
     ]
    }
   ],
   "source": [
    "!solc --abi src/greeter.sol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n",
      "======= src/greeter.sol:Greeter =======\r\n",
      "Binary:\r\n",
      "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\r\n"
     ]
    }
   ],
   "source": [
    "!solc --bin src/greeter.sol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "gas비용이 무한 infinite로 산정되었다. 이 경우는 산정할 수 없다는 표현이 더 적절하다. 프로그램의 string은 배열이고 그 크기를 알 수 없기 때문에 그렇다.\n",
    "실제 동적배열 또는 반복문을 적절하지 못하게 사용하면 무한의 gas비가 산정될 수 있고 따라서 실행이 되지 않을 수 있다는 점에 유의해야 한다.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n",
      "======= src/greeter.sol:Greeter =======\r\n",
      "Gas estimation:\r\n",
      "construction:\r\n",
      "   infinite + 156800 = infinite\r\n",
      "external:\r\n",
      "   greet():\tinfinite\r\n",
      "   setGreeting(string):\tinfinite\r\n"
     ]
    }
   ],
   "source": [
    "!solc --gas src/greeter.sol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.3 단계 3. 컨트랙 배포\n",
    "\n",
    "ABI, Byte code로 컨트랙 객체를 생성하고 배포를 요청한다.\n",
    "배포하기 전 지급계정은 해제되어야 한다.\n",
    "배포하기 위해서는 마이닝을 해야 하고, 비로서 콘트랙이 블록체인에 배포된다.\n",
    "배포가 완성되면 주소 값이 생성된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### REMIX\n",
    "\n",
    "```Run``` 탭을 누르고 ```Deploy``` 버튼을 눌러 배포할 수 있다.\n",
    "배포할 때는 3가지 옵션 가운데 선택할 수 있다:\n",
    "- ```JavaScript VM```: 브라우저에서 독립적으로 실행. 콘트랙을 테스트할 때 유용하다.\n",
    "- ```Injected Web3```: MetaMask, Mist 등을 web3의 provider로 사용할 경우에 선택한다.\n",
    "    * metamask에서 사설망으로 전송할 경우 ```invalid sender``` 오류가 발생하면 사설망의 ```chainId```가 ```networkId```와 동일한지 확인한다.\n",
    "- ```Web3 Provider```: RPC를 통하여 ```http://localhost:8305```에 연결한다. ```Web3 provider```에 연결하면 자신의 계정이 나타난다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* ```Javascript VM```\n",
    "\n",
    "Deployed Contracts 아래에 해당 컨트랙을 선택하여 실행해 볼 수 있다.\n",
    "버튼의 색에 따라 함수를 구분할 수 있게 해 놓았다.\n",
    "**분홍색은 transaction**,\n",
    "**하늘색은 view, pure 함수**로 블록체인에 기록되지 않는 함수이다. \n",
    "함수에 필요한 실제 값을 타입에 맞게 넣고 실행해 보자.\n",
    "\n",
    "타잎 | 구성 | 예\n",
    "-----|-----|-----\n",
    "bytes | 따옴표 | \"0x123456\"\n",
    "strings | 따옴표 | \"hello\"\n",
    "large numbers | 따옴표 |\n",
    "array | [] | [\"hello\",42,\"0x123456\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* ```Web3 provider```\n",
    "\n",
    "Web3 provider를 선택하면, 해당 IP에서 개설된 자신의 계정으로 거래에 사인을 하게 된다. 그리고 우측 '```Deploy```'버튼을 누르면 하단에 보이듯이 contract address가 주어진다.\n",
    "단 마이닝이 실행되어야 한다.\n",
    "\n",
    "![alt text](figures/6_remixConnectToWebProviderKeySign.png \"remix connecting to web provider\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### web3.js\n",
    "\n",
    "아래는 web3 0.20.x 버전을 사용하고 있는 코드다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%writefile src/greeterDeploy_.js\n",
    "var Web3=require('web3');\n",
    "var web3;\n",
    "if (typeof web3 !== 'undefined') {\n",
    "    web3 = new Web3(web3.currentProvider);\n",
    "} else {\n",
    "    web3 = new Web3(new Web3.providers.HttpProvider(\"http://117.16.44.45:8445\"));\n",
    "}\n",
    "var _abiArray=[{\"constant\":false,\"inputs\":[{\"name\":\"_greeting\",\"type\":\"string\"}],\"name\":\"setGreeting\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"greet\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}];\n",
    "var _bin=\"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\";\n",
    "var _contract = web3.eth.contract(_abiArray);\n",
    "//unlock the account with a password provided\n",
    "//web3.personal.unlockAccount(web3.eth.accounts[0],'password');\n",
    "var _instance=_contract.new(\"hello world\",{data:\"0x\"+_bin,from:web3.eth.accounts[0],gas:1000000}, function(err, contract) {\n",
    "    if (!err) {\n",
    "        console.log(\"contractAddress: \", contract.address);\n",
    "        console.log(\"transactionHash: \", contract.transactionHash);\n",
    "    }\n",
    "});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "web3 1.20으로 배포를 해보자.\n",
    "currentProvider는 현재 설정된 Web3.providers가 있다면, 예를 들어 MetaMask, Mist가 제공하는 것을 쓴다는 뜻이다. 그렇지 않으면 수동으로 설정된 IP를 사용하게 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/greeterDeploy.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/greeterDeploy.js\n",
    "var Web3=require('web3');\n",
    "var web3;\n",
    "if (typeof web3 !== 'undefined') {\n",
    "    web3 = new Web3(web3.currentProvider);\n",
    "} else {\n",
    "    web3 = new Web3(new Web3.providers.HttpProvider(\"http://117.16.44.45:8345\"));\n",
    "}\n",
    "var _abiArray=[{\"constant\":false,\"inputs\":[{\"name\":\"_greeting\",\"type\":\"string\"}],\"name\":\"setGreeting\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"greet\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}];\n",
    "var _bin=\"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\";\n",
    "var _contract = new web3.eth.Contract(_abiArray);\n",
    "//unlock the account with a password provided\n",
    "//web3.personal.unlockAccount(web3.eth.accounts[0],'password');\n",
    "_contract\n",
    "    .deploy({data:\"0x\"+_bin})\n",
    "    .send({from: \"0xfA279EEA36550b831ce5734475F67e7d6eC4d607\", gas: 364124, gasPrice: '1000000000'})\n",
    "    .then(function(newContractInstance){\n",
    "        console.log(newContractInstance.options.address) // instance with the new contract address\n",
    "    });\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0xE4E640c0BF81Bbe45342589bd0c318D837ebDf2A\r\n"
     ]
    }
   ],
   "source": [
    "!node src/greeterDeploy.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![alt text](figures/5_greeterDeployPending.png \"remix connecting to web provider\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![alt text](figures/5_greeterDeployMining.png \"remix connecting to web provider\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 4.4 단계 4. 사용\n",
    "\n",
    "위에서 얻은 contract address를 넣어 방금 만든 콘트랙을 사용할 수 있게 된다.\n",
    "객체를 생성할 경우 ABI, Byte code를 사용한다.\n",
    "함수를 호출할 경우 로컬 또는 블록체인을 사용할지 판단한다.\n",
    "\n",
    "* 값을 읽는 경우 ```call()```을 사용하고, gas비용이 발생하지 않는다.\n",
    "```python\n",
    "greeter.methods.greet().call()\n",
    "```\n",
    "\n",
    "* 값을 변경하는 경우, 함수를 직접 호출하거나 ```send()```을 사용한다. gas비용이 발생하고, 적게 설정하면 오류가 난다. 반환 값이 없다. options에는 from, gasPrice, gas, value를 넣어준다.\n",
    "\n",
    "```python\n",
    "myContract.methods.myMethod([param1[, param2[, ...]]]).send(options[, callback])\n",
    "```\n",
    "\n",
    "```python\n",
    "greeter.methods.setGreeting(\"Hello World\").send({from:web3.eth.accounts[0],gas:1000});\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "아래는 web3 0.20.x 버전을 사용하고 있는 코드다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%%writefile src/greeterUse_.js\n",
    "var Web3=require('web3');\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://117.16.44.45:8445\"));\n",
    "var _abiArray=[{\"constant\":false,\"inputs\":[{\"name\":\"_greeting\",\"type\":\"string\"}],\"name\":\"setGreeting\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"greet\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}];\n",
    "var _contract = web3.eth.contract(_abiArray);\n",
    "var greeter = _contract.at(\"0x9397fbedbcdf9b80bad6805df98d24b6676e19e3\");\n",
    "console.log(greeter.greet.call());\n",
    "console.log(greeter.setGreeting({from:web3.eth.accounts[0],gas:100000}));\n",
    "//console.log(greeter.greet());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "web3 1.20으로 배포를 해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/greeterUse.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/greeterUse.js\n",
    "var Web3=require('web3');\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://117.16.44.45:8345\"));\n",
    "var _abiArray=[{\"constant\":false,\"inputs\":[{\"name\":\"_greeting\",\"type\":\"string\"}],\"name\":\"setGreeting\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"greet\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}];\n",
    "var greeter = new web3.eth.Contract(_abiArray,\"0xE4E640c0BF81Bbe45342589bd0c318D837ebDf2A\");\n",
    "greeter.methods.greet().call().then(function(value) {console.log(value);});\n",
    "greeter.methods.setGreeting(\"Hello SMU\").send({from:\"0xfA279EEA36550b831ce5734475F67e7d6eC4d607\",gas:100000});\n",
    "greeter.methods.greet().call().then(function(value) {console.log(value);});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "노드 함수를 1회 실행하면, 비동기적 특성으로 ```setGreeting()``` 함수가 반영되지 않는다.\n",
    "처음에는 Hello가 출력된다.\n",
    "2회 실행시키면, 즉 Hello World로 문자열을 변경한 결과가 출력된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello SMU\r\n",
      "Hello SMU\r\n"
     ]
    }
   ],
   "source": [
    "!node src/greeterUse.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 5. 간단한 계수기\n",
    "\n",
    "계수기는 언제나 현재의 계수를 가지고 있다.\n",
    "0부터 시작해서 하나씩 증가하거나 감소하며, **현재의 계수로부터 증감**한다는 것이다.\n",
    "블록체인은 **state machine**이라서, 전의 값을 기억하고 그로부터 증가하게 된다.\n",
    "**프로그램을 호출한 횟수**가 좋은 예가 될 수 있다. 여러 사람이 호출했다고 하더라도 총 횟수를 기억할 수 있다.\n",
    "현재 값을 저장하고 있고, 그 값이 누구에게나 공개된다는 점이 블록체인의 특징을 보여주고 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1 단계 1. 컨트랙 개발"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/Counter.sol\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/Counter.sol\n",
    "pragma solidity ^0.6.0;\n",
    "contract Counter {\n",
    "    uint256 counter = 0;\n",
    "    function add() public {\n",
    "        counter++;\n",
    "    }\n",
    "    function subtract() public {\n",
    "        counter--;\n",
    "    }\n",
    "    function getCounter() public view returns (uint256) {\n",
    "        return counter;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.2 단계 2. 컴파일\n",
    "\n",
    "solc 컴파일을 통해 abi, bin, gas를 구한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "======= src/Counter.sol:Counter =======\n",
      "Gas estimation:\n",
      "construction:\n",
      "   5099 + 42200 = 47299\n",
      "external:\n",
      "   add():\t20959\n",
      "   getCounter():\t1035\n",
      "   subtract():\t20984\n",
      "Binary:\n",
      "60806040526000805534801561001457600080fd5b5060d3806100236000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c80634f2be91f1460415780636deebae31460495780638ada066e146051575b600080fd5b6047606d565b005b604f6080565b005b60576094565b6040518082815260200191505060405180910390f35b6000808154809291906001019190505550565b600080815480929190600190039190505550565b6000805490509056fea2646970667358221220a19d7e0374295c3c6dd75807d6b2bb20a12deb6f736a4ad98c0065f0d9d4bf5764736f6c63430006010033\n",
      "Contract JSON ABI\n",
      "[{\"inputs\":[],\"name\":\"add\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCounter\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"subtract\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]\n"
     ]
    }
   ],
   "source": [
    "!solc --abi --bin --gas src/Counter.sol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3 단계 3. 배포\n",
    "\n",
    "web3 0.20.x버전과 1.2.x 버전의 배포 프로그램이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing src/counterDeploy__.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/counterDeploy__.js\n",
    "var Web3=require('web3');\n",
    "var web3;\n",
    "if (typeof web3 !== 'undefined') {\n",
    "    web3 = new Web3(web3.currentProvider);\n",
    "} else {\n",
    "    web3 = new Web3(new Web3.providers.HttpProvider(\"http://117.16.44.45:8445\"));\n",
    "}\n",
    "var _abiArray=[{\"constant\":false,\"inputs\":[],\"name\":\"add\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"subtract\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"getCounter\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}];\n",
    "var _bin=\"60806040526000805534801561001457600080fd5b5060e6806100236000396000f3fe6080604052348015600f57600080fd5b50600436106059576000357c0100000000000000000000000000000000000000000000000000000000900480634f2be91f14605e5780636deebae31460665780638ada066e14606e575b600080fd5b6064608a565b005b606c609d565b005b607460b1565b6040518082815260200191505060405180910390f35b6000808154809291906001019190505550565b600080815480929190600190039190505550565b6000805490509056fea165627a7a723058201fbaa288a76e68fea3b0373a390c6e375e9bb90c0fd24b0660d64ebb408088d60029\";\n",
    "var _contract = web3.eth.contract(_abiArray);\n",
    "//unlock the account with a password provided\n",
    "//web3.personal.unlockAccount(web3.eth.accounts[0],'password');\n",
    "var _instance=_contract.new({data:\"0x\"+_bin,from:web3.eth.accounts[0],gas:100000}, function(err, contract) {\n",
    "    if (!err) {\n",
    "        console.log(\"contractAddress: \", contract.address);\n",
    "        console.log(\"transactionHash: \", contract.transactionHash);\n",
    "    }\n",
    "});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/counterDeploy.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/counterDeploy.js\n",
    "var Web3=require('web3');\n",
    "var web3;\n",
    "if (typeof web3 !== 'undefined') {\n",
    "    web3 = new Web3(web3.currentProvider);\n",
    "} else {\n",
    "    web3 = new Web3(new Web3.providers.HttpProvider(\"http://117.16.44.45:8345\"));\n",
    "}\n",
    "//solc 0.5.0\n",
    "//var _abiArray=[{\"constant\":false,\"inputs\":[],\"name\":\"add\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"subtract\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"getCounter\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}];\n",
    "//var _bin=\"60806040526000805534801561001457600080fd5b5060e6806100236000396000f3fe6080604052348015600f57600080fd5b50600436106059576000357c0100000000000000000000000000000000000000000000000000000000900480634f2be91f14605e5780636deebae31460665780638ada066e14606e575b600080fd5b6064608a565b005b606c609d565b005b607460b1565b6040518082815260200191505060405180910390f35b6000808154809291906001019190505550565b600080815480929190600190039190505550565b6000805490509056fea165627a7a723058201fbaa288a76e68fea3b0373a390c6e375e9bb90c0fd24b0660d64ebb408088d60029\";\n",
    "//solc 0.6.1\n",
    "var _abiArray=[{\"inputs\":[],\"name\":\"add\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCounter\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"subtract\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}];\n",
    "var _bin=\"60806040526000805534801561001457600080fd5b5060d3806100236000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c80634f2be91f1460415780636deebae31460495780638ada066e146051575b600080fd5b6047606d565b005b604f6080565b005b60576094565b6040518082815260200191505060405180910390f35b6000808154809291906001019190505550565b600080815480929190600190039190505550565b6000805490509056fea2646970667358221220a19d7e0374295c3c6dd75807d6b2bb20a12deb6f736a4ad98c0065f0d9d4bf5764736f6c63430006010033\";\n",
    "var _contract = new web3.eth.Contract(_abiArray);\n",
    "//unlock the account with a password provided\n",
    "//web3.personal.unlockAccount(web3.eth.accounts[0],'password');\n",
    "_contract\n",
    "    .deploy({data:\"0x\"+_bin})\n",
    "    .send({from: \"0x0A815B7818A8e6BC27B430e41Edc8FC455F658c2\", gas: 364124, gasPrice: '1000000000'})\n",
    "    .then(function(newContractInstance){\n",
    "        console.log(newContractInstance.options.address) // instance with the new contract address\n",
    "    });\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0xb24ab776373e53fFeb9B7298209E195853D2fc8e\r\n"
     ]
    }
   ],
   "source": [
    "!node src/counterDeploy.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.4 단계 4. 사용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/counterUse.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/counterUse.js\n",
    "var Web3=require('web3');\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://117.16.44.45:8345\"));\n",
    "var abi =[{\"constant\":false,\"inputs\":[],\"name\":\"add\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"subtract\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"getCounter\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}];\n",
    "var addr = \"0xb24ab776373e53fFeb9B7298209E195853D2fc8e\";\n",
    "var counter = new web3.eth.Contract(abi,addr);\n",
    "counter.methods.getCounter().call().then(function(str) {console.log(str);});\n",
    "//counter.methods.subtract().send({from:\"0x0A815B7818A8e6BC27B430e41Edc8FC455F658c2\",gas:100000});\n",
    "counter.methods.add().send({from:\"0x0A815B7818A8e6BC27B430e41Edc8FC455F658c2\",gas:100000});\n",
    "counter.methods.add().send({from:\"0x0A815B7818A8e6BC27B430e41Edc8FC455F658c2\",gas:100000});\n",
    "counter.methods.getCounter().call().then(function(str) {console.log(str);});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "geth 개인망에서 ```add()```, ```subtract()``` 함수는 호출하고, Pending Transactions을 처리하고 나면 숫자가 증감한 것을 알 수 있다.\n",
    "```add()```는 counter에 1을 더하는, ```subtract()```은 1을 빼는 상태변경 이므로 마이닝을 해야 그 결과가 반영된다.\n",
    "그러고 나면 ```getCounter()```에서 알 수 있다.\n",
    "주목할 점은 수가 계속 증감한다는 점이다. 세션을 다시 열어도 전의 ```counter``` 값은 남아 있는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\r\n",
      "4\r\n"
     ]
    }
   ],
   "source": [
    "!node src/counterUse.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 실습문제: 타이머 디앱 (파일에서 ABI, bytecode 읽음)\n",
    "\n",
    "블록체인에서 시간을 측정해보자.\n",
    "블록체인은 개방되어 있으므로 누구나 타이머를 설정하고 사용할 수 있다.\n",
    "이러한 점때문에 누구나 자신의 타이머를 가질 수 있지만, 다른 누군가에 의해 재설정될 수도 있다.\n",
    "이러한 단점을 보완하는 방법은 차츰 학습하기로 하자.\n",
    "\n",
    "이번 예제에서는 배포, 사용하는 방법을 바꾸어 보았다.\n",
    "컴파일하고 **abi, bin을 매번 복사하는 것이 불편**하다고 생각했을 것이다.\n",
    "파일로 저장한 후, abi, bin을 읽도록 프로그램을 작성하였다.\n",
    "프로그램이 조금 복잡해지지만, 관심이 있으면 복사-붙여넣기 없이 할 수 있게 된다.\n",
    "\n",
    "또한 Geth에서도 배포하고, API를 사용하여 보자."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 단계 1: 컨트랙 개발\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "1 | Pragma 프로그램 버전. 맨 앞의 ```^``` (caret)은 메이저버전으로 시작하는 최근 버전의 컴파일러를 사용. 따라서 5로 시작하는 최근 버전인 5.21을 사용\n",
    "4 | public으로 사용권한을 제한하지 않음\n",
    "5 | ```now```는 현재 시간, 시스템에서 제공하는 전역변수. now는 버전0.7부터 더 이상 지원되지 않는다. ```block.timestamp```를 사용하자.\n",
    "7 | public이고, pure 또는 view로 읽는 기능으로 한정함.\n",
    "\n",
    "\n",
    "0.6.0으로 로컬컴파일 후,\n",
    "ganache에서는 문제가 없으나,\n",
    "geth에서 getNow()호출에 ```returned values aren't valid, did it run out of gas?``` 오류가 발생한다.\n",
    "REMIX에서 컴파일하고, 그 abi, bin으로 사용해서 확인하니, 문제가 없다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/Timer.sol\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/Timer.sol\n",
    "pragma solidity ^0.6.0;\n",
    "contract Timer {\n",
    "    uint256 startTime;\n",
    "    function start() public {\n",
    "        //startTime=now; now is deprecated as of v0.7\n",
    "        startTime=block.timestamp;\n",
    "    }\n",
    "    function timePassed() public view returns(uint256) {\n",
    "        //return now-startTime;\n",
    "        return block.timestamp-startTime;\n",
    "    }\n",
    "    function getNow() view public returns(uint) {\n",
    "        //return now;\n",
    "        return block.timestamp;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 단계 2: 컴파일\n",
    "\n",
    "컴파일하고 난 ABI, bytecode를 (1) 자바스크립트, (2) JSON 파일로 내보내게 된다.\n",
    "\n",
    "### 방법 1: 자바스크립트 파일로 내보내기\n",
    "\n",
    "```combined-json```을 사용한 컴파일 결과를 ```Timer.js``` 파일에 저장한다. 파일의 확장자가 ```.js```라는 것은 자바스크립트를 의미한다.\n",
    "아래 solc명령어는 앞서 사용했던 명령문과 다르지 않지만, 조금 복잡해졌다.\n",
    "그 이유는 자바스크립트 파일로 만들기 위해 몇 가지 명령문을 사용하고 있다.\n",
    "```python\n",
    "!echo \"exports._compiled=`solc --optimize --combined-json abi,bin,interface src/Timer.sol`\" > src/Timer.js\n",
    "```\n",
    "\n",
    "위 명령문에 쓰인 echo, exports 그리고 부등호 (>)를 하나씩 배워보자.\n",
    "\n",
    "명령문 | 의미\n",
    "-----|-----\n",
    "리눅스 echo | echo는 부등호와 같이 쓰여, 부등호 우측으로 내용을 보내 파일을 생성하게 된다. 이 경우, solc 컴파일이 되고 --combined-json의 abi, bin, interface가 생성되어 자바스크립트 파일이 만들어지게 된다. 즉 ```src/Timer.sol```을 컴파일하고 그 결과를 자바스크립트 변수 **```_compiled```**로 저장하고, ```src/Timer.js``` 파일에 쓴다.\n",
    "```exports``` | 변수를 require()할 때 노출시키게 되어 사용할 수 있다.\n",
    "부등호 | 좌측 결과를 우측으로 보내라는 의미, 그러니까 echo의 결과를 src/Timer.js 파일을 생성하여 쓰게 된다. 참고로 부등호 2개 \">>\"는 이미 기존에 있는 파일에 추가한다는 의미이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!echo \"exports._compiled=`solc --optimize --combined-json abi,bin,interface src/Timer.sol`\" > src/Timer.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 주의: **윈도우 echo 명령어**\n",
    "\n",
    "> 윈도우는 운영체제가 달라, 조금 다르다는 점에 유의하자.\n",
    "> 윈도우에서는 echo 다음에 쓰이는 pipe ```\"|\"```, 변수값을 입력받는 \"set /p\" 명령어, 파일에 쓰고 \">\", 파일에 붙여넣는 \">>\" 명령어를 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "!echo | set /p=\"exports.compiled=\" > src\\Timer.js"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "!solc --optimize --combined-json abi,bin,interface src/Timer.sol >> src\\Timer.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "결과가 적힌 ```Timer.js``` 파일의 내용을 확인해 보자.\n",
    "\n",
    "그 내용이 아래와 같이 생성이 되어 있지 않으면 오류이다.\n",
    "cat은 내용을 출력하는 리눅스 명령어이다. 윈도우에서는 type을 대신 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exports.compiled={\"contracts\":{\"src/Timer.sol:Timer\":{\"abi\":\"[{\\\"inputs\\\":[],\\\"name\\\":\\\"getNow\\\",\\\"outputs\\\":[{\\\"internalType\\\":\\\"uint256\\\",\\\"name\\\":\\\"\\\",\\\"type\\\":\\\"uint256\\\"}],\\\"stateMutability\\\":\\\"view\\\",\\\"type\\\":\\\"function\\\"},{\\\"inputs\\\":[],\\\"name\\\":\\\"start\\\",\\\"outputs\\\":[],\\\"stateMutability\\\":\\\"nonpayable\\\",\\\"type\\\":\\\"function\\\"},{\\\"inputs\\\":[],\\\"name\\\":\\\"timePassed\\\",\\\"outputs\\\":[{\\\"internalType\\\":\\\"uint256\\\",\\\"name\\\":\\\"\\\",\\\"type\\\":\\\"uint256\\\"}],\\\"stateMutability\\\":\\\"view\\\",\\\"type\\\":\\\"function\\\"}]\",\"bin\":\"608060405234801561001057600080fd5b5060af8061001f6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c8063b4454253146041578063bbe4fd50146059578063be9a655514605f575b600080fd5b60476067565b60408051918252519081900360200190f35b6047606f565b60656073565b005b600054420390565b4290565b4260005556fea2646970667358221220f2dd49ad7ab0645d152793d9df9439e21492b4a9dd91cb1b9fcfd494293709bd64736f6c63430006010033\"}},\"version\":\"0.6.1+commit.e6f7d5a4.Windows.msvc\"}\n"
     ]
    }
   ],
   "source": [
    "!type src\\Timer.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "파일확장자를 주었듯이, 이렇게 생성된 파일은 자바스크립트 파일이다. json파일이 아니다.\n",
    "\n",
    "* (1) **node에서 그 파일을 require**해서 사용할 수 있고, \n",
    "* (2) 반면에 geth는 자바스크립트를 사용하면서도 불구하고 require() 함수를 사용해서 파일을 읽을 수 없다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 방법 2: json 파일 생성\n",
    "\n",
    "abi, bin를 하나씩 생성하지 않고, 한꺼번에 ```json```파일을 생성하여 읽도록 하자.\n",
    "\n",
    "주의: ```--combined-json abi, bin``` 이렇게 공백이 포함되면 안된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Invalid option to --combined-json: \n"
     ]
    }
   ],
   "source": [
    "!solc --optimize --combined-json abi, bin src/Timer.sol > src/Timer.json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "!solc --optimize --combined-json abi,bin src/Timer.sol > src/Timer.json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "운영체제 별로 명령어와 디렉토리 구분자가 다르므로 주의해야 한다.\n",
    "윈도우에서는 ```type src\\Timer.json``` 리눅스에서는 ```cat src/Timer.json```이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"contracts\":{\"src/Timer.sol:Timer\":{\"abi\":\"[{\\\"inputs\\\":[],\\\"name\\\":\\\"getNow\\\",\\\"outputs\\\":[{\\\"internalType\\\":\\\"uint256\\\",\\\"name\\\":\\\"\\\",\\\"type\\\":\\\"uint256\\\"}],\\\"stateMutability\\\":\\\"view\\\",\\\"type\\\":\\\"function\\\"},{\\\"inputs\\\":[],\\\"name\\\":\\\"start\\\",\\\"outputs\\\":[],\\\"stateMutability\\\":\\\"nonpayable\\\",\\\"type\\\":\\\"function\\\"},{\\\"inputs\\\":[],\\\"name\\\":\\\"timePassed\\\",\\\"outputs\\\":[{\\\"internalType\\\":\\\"uint256\\\",\\\"name\\\":\\\"\\\",\\\"type\\\":\\\"uint256\\\"}],\\\"stateMutability\\\":\\\"view\\\",\\\"type\\\":\\\"function\\\"}]\",\"bin\":\"608060405234801561001057600080fd5b5060af8061001f6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c8063b4454253146041578063bbe4fd50146059578063be9a655514605f575b600080fd5b60476067565b60408051918252519081900360200190f35b6047606f565b60656073565b005b600054420390565b4290565b4260005556fea2646970667358221220f2dd49ad7ab0645d152793d9df9439e21492b4a9dd91cb1b9fcfd494293709bd64736f6c63430006010033\"}},\"version\":\"0.6.1+commit.e6f7d5a4.Windows.msvc\"}\n"
     ]
    }
   ],
   "source": [
    "!type src\\Timer.json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이와 같이 생성된 json 파일은 다음 명령어로 JSON으로 변환할 수 있다.\n",
    "```python\n",
    "var fs = require('fs');\n",
    "var _abiJson=JSON.parse(fs.readFileSync('./src/TimerABI.json', 'utf8'));\n",
    "```\n",
    "\n",
    "반면에 JSON파일은 바로 ```require(JSON파일명)``` 함수로 아래와 같이 읽으면 편하다. Javascript 파일의 ```require(자바스크립트파일명)```와 달리 export 명령어를 사용할 필요가 없다.\n",
    "```require```에서 읽는 파일경로는 **현재파일의 상대적 경로**로 적어준다. 앞서 컴파일 결과는 JSON 형식이고, 여기서 abi, bin을 읽어올 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **solc로 컴파일할 경우 파일 경로와 import**\n",
    "\n",
    "solc에서 abi, bin을 생성하면 컨트랙 명칭이 'src/Timer.sol:Timer'와 같이 만들어 진다.\n",
    "이 부분은 문법 context:prefix=target에 따라 생성이 된다.\n",
    "이러한 명칭이 복잡하므로 프로그램으로 얻어보자.\n",
    "아래에서 사용한 자바스크립트 **객체의 키**를 읽어온다.\n",
    "```Object.keys(키)``` 명령문은 키를 입력하면, 그에 해당하는 값을 얻을 수 있다.\n",
    "**```Object.keys(_compiled.contracts)```는 괄호 안의 키를 전달하고 있다.\n",
    "\n",
    "구분 | 설명 | 선택 | 예\n",
    "-----|-----|-----|-----\n",
    "context | 읽을 파일 | 선택적 | src/Timer.sol\n",
    ":prefix |  |  | :Timer\n",
    "=target | 없으면 prefix와 동일  | 선택적 | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/TimerImportTest.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/TimerImportTest.js\n",
    "const _abiBinJson = require('./Timer.json');     //importing a javascript file\n",
    "contractName=Object.keys(_abiBinJson.contracts); // reading ['src/Timer.sol:Timer']\n",
    "console.log(\"- contract name: \", contractName);\n",
    "_abi=_abiBinJson.contracts[contractName].abi;\n",
    "_abiArray=JSON.parse(JSON.stringify(_abi));\n",
    "_bin=_abiBinJson.contracts[contractName].bin;\n",
    "console.log(\"- ABI: \", _abi);\n",
    "console.log(\"- ABIArray: \", _abiArray);\n",
    "console.log(\"- Bytecode: \", _bin);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "abi, bin 정보를 잘 읽었는지 확인해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- contract name:  [ 'src/Timer.sol:Timer' ]\n",
      "- ABI:  [{\"inputs\":[],\"name\":\"getNow\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"start\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"timePassed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]\n",
      "- ABIArray:  [{\"inputs\":[],\"name\":\"getNow\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"start\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"timePassed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]\n",
      "- Bytecode:  608060405234801561001057600080fd5b5060af8061001f6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c8063b4454253146041578063bbe4fd50146059578063be9a655514605f575b600080fd5b60476067565b60408051918252519081900360200190f35b6047606f565b60656073565b005b600054420390565b4290565b4260005556fea2646970667358221220f2dd49ad7ab0645d152793d9df9439e21492b4a9dd91cb1b9fcfd494293709bd64736f6c63430006010033\n"
     ]
    }
   ],
   "source": [
    "!node src/TimerImportTest.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 노드에서 한 줄씩 코딩해보기\n",
    "\n",
    "json을 생성하고 그 파일을 읽어오는 과정이 이해하기 어려우면 손코딩이 제일이다.\n",
    "노드에서 한 줄씩 ABI, BIN을 읽어오는 연습을 해보자.\n",
    "\n",
    "```python\n",
    "\n",
    "PS C:\\Users\\jsl\\Code\\201711111> node\n",
    "> var _abiBinJson=require('./src/Timer.json')\n",
    "undefined\n",
    "> Object.keys(_abiBinJson.contracts)\n",
    "[ 'src/Timer.sol:Timer' ]\n",
    "\n",
    "이후에도 한 줄씩 계속 입력하고 결과를 출력해보자.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 단계 3: 컨트랙 배포\n",
    "\n",
    "다음으로 배포를 해보자.\n",
    "컴파일하고 abi, bin는 파일에 저장하였고, 그 파일에서 읽어 온다.\n",
    "\n",
    "줄 | 설명\n",
    "-----|-----\n",
    "1 | 사용 계정을 설정한다.\n",
    "4 | 컴파일하고 생성된 abi, bin이 저장된 js파일을 읽는다\n",
    "5 | contract명에 path prefix인 디렉토리 구분자 '/'가 포함되어 있다. Object.keys로 읽은 key를 contract명으로 사용한다.\n",
    "10 | binary data는 '0x'가 빠져 있다. 블록체인에 배포할 때 0x를 붙여서 16진수 문자열이라고 명시해 준다. **gas**를 임의로 정해준다. 가격이 맞지 않으면....\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Geth 배포: 자바스크립트 파일을 읽어서\n",
    "\n",
    "앞서 **--combined-json abi,bin, interface** 스위치로 자바스크립트 파일을 생성해 놓았다. 이 파일을 읽어 Geth에서 Deploy를 해보자.\n",
    "loadScript()함수는 Geth에서 자바스크립트를 읽어 들일 수 있다. 단 require() 함수를 지원하지 않아서, JSON파일을 읽어올 수 없다.\n",
    "\n",
    "require()가 아니, loadScript()를 사용하면, export 명령어가 작동하지 않는다.\n",
    "따라서 ```export``` 대신, ```var _compiled```라고 해주었다.\n",
    "리눅스에서는 다음과 같이 명령어가 단순하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "!echo \"var _compiled=`solc --optimize --combined-json abi,bin,interface src/Timer.sol`\" > src/TimerGeth.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "윈도우에서는 다음과 같이 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "!echo | set /p=\"var _compiled=\" > src\\TimerGeth.js"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "!solc --optimize --combined-json abi,bin,interface src/Timer.sol >> src\\TimerGeth.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그리고 나서 Geth에서 읽을 수 있는지 확인해볼 수 있다.\n",
    "```\n",
    "C:\\Users\\jsl\\Code\\201711111> geth attach http://localhost:8345\n",
    "Welcome to the Geth JavaScript console!\n",
    "> loadScript('src/TimerGeth.js') <--- 조금 전 생성한 파일을 읽기\n",
    "true\n",
    "> _compiled                      <--- 파일의 변수 읽기 (solc 컴파일 결과)\n",
    "{\n",
    "  contracts: {\n",
    "    src/Timer.sol:Timer: {\n",
    "      abi: \"[{\\\"inputs\\\":[],\\\"name\\\":\\\"getNow\\\",\\\"outputs\\\":...}]\", 중간 생략\n",
    "      bin: \"6080604052...10033\"                                     중간 생략\n",
    "    }\n",
    "  },\n",
    "}\n",
    "> Object.keys(_compiled.contracts)   <--- 컨트랙 명 읽기\n",
    "[\"src/Timer.sol:Timer\"]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/TimerDeployGeth.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/TimerDeployGeth.js\n",
    "var primary = eth.accounts[0];\n",
    "console.log(\"primary ac: \",primary);\n",
    "console.log(\"balance: \",eth.getBalance(primary));\n",
    "loadScript('src/TimerGeth.js');\n",
    "contractName=Object.keys(_compiled.contracts); // reading ['src//Timer.sol:Timer']\n",
    "//_abi=JSON.parse(_compiled.contracts['src/Example.sol:Example'].abi)\n",
    "//_bin=_compiled.contracts['src/Example.sol:Example'].bin\n",
    "_abi=JSON.parse(_compiled.contracts[contractName[0]].abi)\n",
    "_bin=_compiled.contracts[contractName[0]].bin\n",
    "\n",
    "_class=eth.contract(_abi);\n",
    "console.log('bin code: ', _bin)\n",
    "//this async way does not work from the Jupyter Notebook\n",
    "_object=_class.new({from:primary,data:'0x'+_bin,gas:1000000}, function(err, contract) {\n",
    "  if (!err && contract.address)\n",
    "    console.log(\"contractAddress: \", contract.address);\n",
    "    console.log(\"transactionHash: \", contract.transactionHash);\n",
    "});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "primary ac:  0xeb670169a5fcd2550035588a2ba3b45509703abd\n",
      "balance:  999998252516772701039\n",
      "bin code:  608060405234801561001057600080fd5b5060af8061001f6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c8063b4454253146041578063bbe4fd50146059578063be9a655514605f575b600080fd5b60476067565b60408051918252519081900360200190f35b6047606f565b60656073565b005b600054420390565b4290565b4260005556fea2646970667358221220f2dd49ad7ab0645d152793d9df9439e21492b4a9dd91cb1b9fcfd494293709bd64736f6c63430006010033\n",
      "transactionHash:  0x1eb79103f4919a5540d19d1fb301468739adf5ad4d94b352c283d06451d76dcb\n",
      "true\n"
     ]
    }
   ],
   "source": [
    "!geth --exec \"loadScript('src/TimerDeployGeth.js')\" attach http://localhost:8345"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "마이닝하고나면 블록체인의 주소가 주어진다. **Jupyter Notebook에서는 geth async가 실행되지 않으므로, 주소가 출력이 되지 않는** 것으로 보인다. ```getTransactionReceipt()```의 결과를 보면 ```contractAddress```가 출력되어 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  blockHash: \"0x67717ff2152812529c2171659bea8606dd2b8129d00b130b97fc387d7920bb4f\",\n",
      "  blockNumber: 21,\n",
      "  contractAddress: \"0x41918c2a0b147ccbf4dc1061311c48534722016a\",\n",
      "  cumulativeGasUsed: 91227,\n",
      "  effectiveGasPrice: \"0x49c3b7b\",\n",
      "  from: \"0xeb670169a5fcd2550035588a2ba3b45509703abd\",\n",
      "  gasUsed: 91227,\n",
      "  logs: [],\n",
      "  logsBloom: \"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\",\n",
      "  status: \"0x1\",\n",
      "  to: null,\n",
      "  transactionHash: \"0x1eb79103f4919a5540d19d1fb301468739adf5ad4d94b352c283d06451d76dcb\",\n",
      "  transactionIndex: 0,\n",
      "  type: \"0x2\"\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "!geth --exec \"eth.getTransactionReceipt('0x1eb79103f4919a5540d19d1fb301468739adf5ad4d94b352c283d06451d76dcb')\" attach http://localhost:8345"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Node 배포: JSON 파일을 읽어서\n",
    "\n",
    "Node에서는 앞서 하나씩 생성한 ```Timer.json``` 파일을 읽어서 배포해보자.\n",
    "\n",
    "주의:\n",
    "* ```require('./Timer.json')```에 호출 시점의 상대 디렉토리 ```src/Timer.json```를 적는다.\n",
    "* bytecode는 16진수 표현 \"0x\"를 붙인다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/TimerDeployAbiBinFromFile.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/TimerDeployAbiBinFromFile.js\n",
    "var Web3 = require('web3');\n",
    "var _abiBinJson = require('./Timer.json');      //importing a javascript file\n",
    "\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://localhost:8345\"));\n",
    "\n",
    "contractName=Object.keys(_abiBinJson.contracts); // reading ['src/Timer.sol:Timer']\n",
    "console.log(\"- contract name: \", contractName);\n",
    "_abi=_abiBinJson.contracts[contractName].abi;\n",
    "//_abiArray=JSON.parse(JSON.stringify(_abi));\n",
    "_abiArray=JSON.parse(_abi);      //JSON parsing needed!!\n",
    "_bin=_abiBinJson.contracts[contractName].bin;\n",
    "\n",
    "console.log(\"- ABI: \" + _abiArray);\n",
    "console.log(\"- Bytecode: \" + _bin);\n",
    "\n",
    "async function deploy() {\n",
    "    const accounts = await web3.eth.getAccounts();\n",
    "    console.log(\"Deploying the contract from \" + accounts[0]);\n",
    "    var deployed = await new web3.eth.Contract(_abiArray)\n",
    "        .deploy({data: \"0x\"+_bin})\n",
    "        .send({from: accounts[0], gas: 364124}, function(err, transactionHash) {\n",
    "                if(!err) console.log(\"hash: \" + transactionHash); \n",
    "        })\n",
    "        //.then(function(newContractInstance){\n",
    "        //    console.log(newContractInstance)\n",
    "        //});\n",
    "    console.log(\"---> The contract deployed to: \" + deployed.options.address)\n",
    "}\n",
    "deploy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ABI를 출력하면 object가 포함되어 있다. 마지막 줄을 보면, 배포된 컨트랙의 주소를 얻을 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- contract name:  [ 'src/Timer.sol:Timer' ]\n",
      "- ABI: [object Object],[object Object],[object Object]\n",
      "- Bytecode: 608060405234801561001057600080fd5b5060af8061001f6000396000f3fe6080604052348015600f57600080fd5b5060043610603c5760003560e01c8063b4454253146041578063bbe4fd50146059578063be9a655514605f575b600080fd5b60476067565b60408051918252519081900360200190f35b6047606f565b60656073565b005b600054420390565b4290565b4260005556fea2646970667358221220f2dd49ad7ab0645d152793d9df9439e21492b4a9dd91cb1b9fcfd494293709bd64736f6c63430006010033\n",
      "Deploying the contract from 0xEb670169A5fcD2550035588A2ba3b45509703ABd\n",
      "hash: 0xbd010c6ed017b05579abd42f94d332ece6b4ce21c83eb881d46094fb3572eed4\n",
      "---> The contract deployed to: 0x5dB5E509ff13A760345C0B58591E2a5DA6e1B2DE\n"
     ]
    }
   ],
   "source": [
    "!node src/TimerDeployAbiBinFromFile.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "nodejs example.sol compile, deploy\n",
    "\n",
    "![alt text](figures/6_nodejsWeb3Example.png \"node web3 test run Example.sol\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 단계 4: 사용\n",
    "\n",
    "### web3.js가 아닌 eth를 사용\n",
    "\n",
    "위에서 Geth 배포가 성공하였다면, 이어서 API를 호출해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/TimerUseGeth.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/TimerUseGeth.js\n",
    "loadScript('src/TimerGeth.js')\n",
    "contractName=Object.keys(_compiled.contracts)\n",
    "_abi=JSON.parse(_compiled.contracts[contractName[0]].abi)\n",
    "//_abi=JSON.parse(_compiled.contracts['src/Example.sol:Example'].abi)\n",
    "var _contract=eth.contract(_abi);\n",
    "var _address=\"0xb5f064b6cf3d7b7497ab88a846819629d0c05136\";\n",
    "var _instance=eth.contract(_abi).at(_address);\n",
    "console.log(_instance.getNow.call());\n",
    "_instance.start.sendTransaction({from:eth.accounts[0]});\n",
    "console.log(_instance.timePassed.call());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Geth 개인망에서 실행하는 경우, 마이닝이 뒤따라야 한다.\n",
    "여기서는 조금 있다 보게되는 node의 실행결과와 달리 ```timePassed```가 올바르게 출력이 되지 않고 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1588492924\n",
      "0\n",
      "\u001b[1mtrue\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!geth --exec 'loadScript(\"src/TimerUseGeth.js\")' attach http://117.16.44.45:8345"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### web3.js를 사용\n",
    "\n",
    "JSON에서 파일을 읽어서 ABI를 가져온다. bytecode는 API를 호출할 때 불필요하다.\n",
    "우리가 호출한 ```getNow()```, ```timePased()```는 **call 함수**이다. 반면에 ```start()```는 **send 함수**이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/timerUse.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/timerUse.js\n",
    "var Web3=require('web3');\n",
    "var _abiBinJson = require('./Timer.json');      //importing a javascript file\n",
    "\n",
    "var web3 = new Web3(new Web3.providers.HttpProvider(\"http://localhost:8345\"));\n",
    "contractName=Object.keys(_abiBinJson.contracts); // reading ['src/Timer.sol:Timer']\n",
    "//console.log(\"- contract name: \", contractName); //or console.log(contractName[0]);\n",
    "_abi=_abiBinJson.contracts[contractName].abi;\n",
    "//_abiArray=JSON.parse(JSON.stringify(_abi));\n",
    "_abiArray=JSON.parse(_abi);      //JSON parsing needed!!\n",
    "//_bin=_abiBinJson.contracts[contractName].bin;\n",
    "//console.log(\"- ABI: \" + _abiArray);\n",
    "//console.log(\"- Bytecode: \" + _bin);\n",
    "\n",
    "var timer = new web3.eth.Contract(_abiArray,\"0x5dB5E509ff13A760345C0B58591E2a5DA6e1B2DE\");\n",
    "\n",
    "async function doIt() {\n",
    "    const accounts = await web3.eth.getAccounts();\n",
    "    console.log(\"Call from: \" + accounts[0]);\n",
    "    timer.methods.getNow().call().then(function(value) {console.log(\"Now: \", value);});\n",
    "    await timer.methods.start().send({from:accounts[0],gas:100000});\n",
    "    //await 4000;\n",
    "    timer.methods.timePassed().call().then(function(value) {console.log(\"Passed: \", value);});\n",
    "}\n",
    "\n",
    "doIt()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "일정 시간이 지난 후 몇 번 반복시켜서 지나간 시간이 변동하는지 확인해 보자.\n",
    "\n",
    "지난 시간은 타임스탬프 signed 32-bit 형식으로 출력된다. 이 형식을 우리가 사용하는 시간 형식으로 변환해야 한다. https://www.epochconverter.com/\n",
    "\n",
    "\n",
    "> **타임스탬프 timestamp**\n",
    "\n",
    "> 유닉스에서 사용하는 타임스탬프이고 Long Integer 형식이다. 1970년 1월 1일 00:00:00 기준으로 몇 초나 지났는지 계산한다. 하루는 86400초, 60초 x 24시간 x 60분 기준이다. 윤초는 계산에서 제외해야 한다.\n",
    "\n",
    "REMIX에서 테스트하면, 올바르게 작동하지만 여기서는 Passed가 0으로 출력되고 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Call from: 0xEb670169A5fcD2550035588A2ba3b45509703ABd\n",
      "Now:  1648957889\n",
      "Passed:  0\n"
     ]
    }
   ],
   "source": [
    "!node src/timerUse.js"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- contract name:  src/Timer.sol:Timer\n",
      "1619427898\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "!node src/timerUse.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "nodejs example.sol use after deploy 배포\n",
    "\n",
    "![alt text](figures/6_nodejsWeb3ExampleUse.png \"node web3 test run Example.sol\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 연습문제: 자바스크립트 전역변수 설정\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/hoistingTest.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/hoistingTest.js\n",
    "var x = 11;\n",
    "\n",
    "function hoist() {\n",
    "    x = 22;\n",
    "}\n",
    "hoist();\n",
    "console.log(x);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\r\n"
     ]
    }
   ],
   "source": [
    "!node src/hoistingTest.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제: Hello Snowman 출력\n",
    "\n",
    "```Hello``` 컨트랙을 수정해서 ```sayHello()``` 함수를 호출하면 ```\"Hello, Snowman\"```이 출력되도록 하세요.\n",
    "\n",
    "- Solidity로 ```Hello.sol```을 코딩하고\n",
    "- solc로 컴파일하고\n",
    "- web3.js를 사용하여 node로 프로그램해서 배포\n",
    "- web3.js를 사용하여 node로 ```sayHello()``` 출력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pragma solidity ^0.6.0;\n",
    "contract Hello {\n",
    "    function sayHello() pure public returns(string memory) {\n",
    "        return \"Hello, Snowman\";\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제: byte32 타입의 Hello Greeter\n",
    "\n",
    "```greeter```의 ```greeting```의 데이터타입을 ```string```에서 ```bytes32```로 변경하세요.\n",
    "- ```string```에서 ```bytes32```로 변경하면 gas의 차이가 있는지 확인\n",
    "- 노드에서 배포\n",
    "- 노드에서 인사를 설정하고 ```setGreeting(\"Hello World!\")```, ```greet()```을 출력하세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/GreeterB.sol\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/GreeterB.sol\n",
    "pragma solidity ^0.6.0;\n",
    "contract GreeterB {\n",
    "    bytes32 greeting;\n",
    "    constructor() public {\n",
    "        greeting = 'Hello';\n",
    "    }\n",
    "    function setGreeting(bytes32 _greeting) public {\n",
    "        greeting = _greeting;\n",
    "    }\n",
    "    function greet() view public returns (bytes32) {\n",
    "        return greeting;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```string```을 ```byte32```로 변경하면 글자 수가 제한되므로, gas비가 산정되는 것을 볼 수 있다.\n",
    "위에서는 infinite로 산정된 것을 기억해보자."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Hello SMU\"와 같은 String을 인자로 사용하면, 오류가 발생한다.\n",
    "반면에 \"Hello SMU\"에 해당하는 16진수 \"0x48656c6c6f20534d55\"를 넘겨주면,\n",
    "16진수 결과가 반환된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0x48656c6c6f20534d550000000000000000000000000000000000000000000000\n",
      "0x48656c6c6f20534d550000000000000000000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "!node src/GreeterBUse.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 연습문제: Timer\n",
    "\n",
    "\n",
    "```python\n",
    "pragma solidity ^0.5.0;\n",
    "contract Timer {\n",
    "    uint256 startTime;\n",
    "    uint256 endTime;\n",
    "    function start() public {\n",
    "        startTime=now;\n",
    "    }\n",
    "    function stop() public {\n",
    "        endTime=now;\n",
    "    }\n",
    "    function timePassed() public view returns(uint256) {\n",
    "        return endTime-startTime;\n",
    "    }\n",
    "    function getNow() view public returns(uint) {\n",
    "        return now;\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제: 7 곱하는 컨트랙\n",
    "\n",
    "### 문제\n",
    "\n",
    "어떤 수에 7을 곱하는 스마트 컨트랙을 만든다.\n",
    "\n",
    "\n",
    "### 해결\n",
    "\n",
    "컨트랙은 ```Multiply7```, 함수는:\n",
    "\n",
    "```python\n",
    "function multiply(uint input) public pure returns (uint)\n",
    "```\n",
    "\n",
    "- 컨트랙은 Solidity로, 클라이언트는 노드로 프로그램한다.\n",
    "\n",
    "- 8을 인자로 너기면, 7을 곱해서 56을 출력하세요."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "단계 | 방식 | 결과\n",
    "-----|-----|-----\n",
    "개발 | solidity | ok\n",
    "컴파일 | eth | ok\n",
    "배포 | _class.new | ok (transactionHash는 배포하지 않아도 생성)\n",
    "배포 | _class.new, async 방식 | nok  (geth console에서만 ok)\n",
    "생성 | async방식 | nok (geth console에서만 ok)\n",
    "\n",
    "* geth console에서의 사용 예.\n",
    "```\n",
    "> myMultiply=eth.contract(compiled.test.info.abiDefinition).at(_object.address)\n",
    "{\n",
    "  abi: [{\n",
    "      constant: false,\n",
    "      inputs: [{...}],\n",
    "      name: \"multiply\",\n",
    "      outputs: [{...}],\n",
    "      payable: false,\n",
    "      type: \"function\"\n",
    "  }],\n",
    "  address: \"0x050c96a751f86a699a541001223b1ba7f5364d8d\",\n",
    "  transactionHash: null,\n",
    "  allEvents: function(),\n",
    "  multiply: function()\n",
    "}\n",
    "> myMultiply.multiply.call(6)\n",
    "'42'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/Multiply7.sol\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/Multiply7.sol\n",
    "pragma solidity ^0.5.0;\n",
    "\n",
    "contract Multiply7 {\n",
    "   function multiply(uint input) public pure returns (uint) {\n",
    "      return input * 7;\n",
    "   }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* asynch 방식이라 마이닝이 될 때까지 기다려야 한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 위에서 만들어진 abi, contract address를 사용한다.\n",
    "* call은 로컬에서 실행하기 때문에, hash값도 없고 gas도 필요하지 않다. 블록체인에 기록되지 않는 거래이다.\n",
    "* sendTransaction으로 실행하면 블록체인에 기록된다.\n",
    "\n",
    "* transactionHash\n",
    "    * at()으로 생성하면, 거래가 발생하지 않았으므로 (주소에서 컨트랙을 생성했다), transactionHash는 null\n",
    "    * 계정에서는 여러 거래를 발생하므로, 거래를 확인하려면 id인 transactionHash가 필요."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제: 계수기와 Timer 콘트랙\n",
    "\n",
    "계수기와 Timer의 기능을 결합한 컨트랙을 구현하세요.\n",
    "계수기를 0부터 3까지 1회씩 증가시킨 후, 그 시점까지의 소요시간을 다음과 같이 출력하세요.\n",
    "```\n",
    "counter: 3\n",
    "timePassed: ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제: 거듭제곱 컨트랙\n",
    "\n",
    "### 문제\n",
    "\n",
    "아래 (2) ~ (6)은 노드로 프로그램하세요.\n",
    "\n",
    "(1) 2의 거듭제곱을 계산하는 컨트랙을 프로그램하세요.\n",
    "8을 입력하면 256, 32는 4294967296을 출력합니다.\n",
    "컨트랙은 Math.sol로 저장하고, 함수는 powerOf2로 명명해서 프로그램 작성\n",
    "power를 계산하려면, 반복문으로 하지 않는다. ** 연산자로 계산합니다.\n",
    "예: 2**2로 코딩하면 4를 얻는다.\n",
    "\t컴파일해서 abi, gas, bin을 화면에 출력한다.\n",
    "(2) ganache 배포\n",
    "(3) ganache 사용 (8과 32를 입력해서 결과 출력)\n",
    "(4) 웹페이지 powerOf2.html을 작성 (32를 입력하고, 결과를 화면에 출력하고 캡쳐해서 별도 제출)\n",
    "(5) 파일에서 ABI, BIN을 읽고 배포하고 사용\n",
    "(6) geth에서 배포하고 사용. geth@8446, geth@8445 가운데 선택.\n",
    "\n",
    "\n",
    "### 결과\n",
    "uint256 e = uint256(a)**uint256(b);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/Power.sol\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/Power.sol\n",
    "pragma solidity ^0.6.0;\n",
    "\n",
    "contract Math {\n",
    "   function powerOf2(uint p) public pure returns (uint) {\n",
    "      return 2 ** p;\n",
    "   }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제: 이체\n",
    "\n",
    "* ganache를 백그라운드로 띄우고, node에서 연결하여, coinbase주소를 출력하세요.\n",
    "* 위 문제를 geth를 띄우고 실행해보세요. geth에서의 coinbase를 출력하세요.\n",
    "* ganache의 coinbase에서 geth의 coinbase로 1 ether를 송금해 보세요. 송금 성공이면 잔고변화를 출력하고, 실패이면 그 이유를 간단히 설명하세요.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ```async/await``` 함수\n",
    "\n",
    "```getCoinbase()```, ```getBalance()```는 비동기함수라서 ```await```를 사용하고, ```getCoinbaseBalance()```를 ```async```로 선언하였다. 그 결과는 별로 도움이 되지 않는다. coinbase를 획득하지 못해서 ```undefined``` 오류가 발생하고 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### account, balance를 ```then()``` 함수로 구해보자.\n",
    "\n",
    "주소를 구해보자. 주소를 먼저 구해야 getBalance()를 실행할 수 있다. 여기서도 전역변수 coinbase로 저장하지 못하고 있다.\n",
    "로컬에서 출력된 주소 값을 사용하기로 하자."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```web3.eth.getBalance()``` 함수는 promise를 반환하는 함수라서 전역변수 ```balanceOfCoinbase``로 저장할 수 없다.\n",
    "결과에서 보듯이, Pending Promise가 반환될 뿐이다.\n",
    "그러나 callback 함수에서는 그 결과가 올바르게 출력이 되고 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Global> coinbase: 0x21c704354D07f804baB01894e8B4eB4E0EBA7451 balance: [object Promise]\r\n",
      "...returning 65000021786999969076\r\n"
     ]
    }
   ],
   "source": [
    "!node src/computeBalance0.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ganche에서 geth로 전송\n",
    "\n",
    "* geth\n",
    "    - 0x21c704354D07f804baB01894e8B4eB4E0EBA7451\n",
    "    - 65000021786999969076\n",
    "\n",
    "* ganache\n",
    "    - 0xB0dE384E3b90bB9F18E811E8b05CeEbC2d2bc20e\n",
    "    - 100,000,000,000,000,000,000\n",
    "    \n",
    "* 금액 차이를 잘 식별하기 위해 송금액은 ```1.001```로 정한다.\n",
    "* gas는 ```1,000,000```\n",
    "\n",
    "* 송신은 ganache 8345, 수신은 geth로 한다. geth의 포트 8445 번호는 수신측이므로 적어줄 필요가 없다.\n",
    "* geth는 전: 65,000,021,786,999,969,076 후: 65,000,021,786,999,969,076로 차이가 없다.\n",
    "* 반면 ganche는 전: 100ETH - 후: 98.99858ETH = 1.00142만큼의 차이가 있다.\n",
    "\n",
    "즉, ganache에서는 차감이 되지만 geth에서는 수신을 못하였다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제: 환전 계산\n",
    "\n",
    "* ganache를 연결하고, 현재 coinbase의 잔고를 ether로 출력하세요.\n",
    "* 현재 거래소 환전가격을 구해서 한화로 얼마인지 계산하여 출력하세요."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### wei를 ether로 변환하고 시세를 구해보자\n",
    "\n",
    "```then()``` 함수로 promise의 결과 값을 출력할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "```then()``` 함수안에 앞의 ```getBalacne()``` 함수의 결과 값을 인자 wei로 받아서 출력해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100000000000000000000\r\n"
     ]
    }
   ],
   "source": [
    "!node src/computeBalance2.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "```then()``` 함수안에 앞의 ```getBalacne()``` 함수의 결과 값을 인자 wei로 받아서 ```fromWei()``` 함수를 사용하여 ether로 and변경해보자.\n",
    "\n",
    "**wei를 문자열**로 받아서 출력하고 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "callback 함수에서 연산하여 결과 값을 출력하도록 한다.\n",
    "강의자료를 잘 보면 답을 만들 수 있어요.\n",
    "```console.log```는 화면출력이라서 변수에 저장할 수 없다.\n",
    "\n",
    "```\n",
    "web3.eth.getBalance().then(function (error, wei) {\n",
    "}\n",
    "```\n",
    "\n",
    "이런 식으로 callback 함수내에서 계산을 해야 한다. callback 함수는 인자로 넘겨지고, 앞의 함수 ```getBalance()```가 실행이 된 후 실행이 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 ether\r\n",
      "...converting into market price 236,000 in Apr 2020\r\n",
      "23600000 won\r\n"
     ]
    }
   ],
   "source": [
    "!node src/computeBalance4.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제: 웹소켓으로 blockNumber 출력\n",
    "\n",
    "ganache에 webSocket으로 연결하고 blockNumber 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제: coinbase 출력\n",
    "\n",
    "coinbase를 출력하세요.\n",
    "\n",
    "callback 함수로 키를 설정하여 보자. ```undefined```가 반환되고 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "```then()``` 함수로 통해 키를 설정하여 보자. ```promise```가 반환되고 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "async/await 명령어를 사용해서 해보자. 결과는 크게 다르지 않게 promise를 반환하고 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제: Counter 짝수, 홀수 판별\n",
    "\n",
    "Counter 콘트랙의 계수가 홀수인지, 짝수인지 판별하는 함수 ```isEven()```을 추가하세요.\n",
    "REMIX에서 인터페이스 및 배포\n",
    "\n",
    "* Counter를 0부터 3까지 증가\n",
    "* counter가 4일 때, isEven()을 실행해서 결과를 출력\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 연습문제: Counter 4 판별\n",
    "\n",
    "REMIX에서 배포하고, 아래를 노드로 프로그램하세요\n",
    "* Counter를 0부터 3까지 증가\n",
    "* counter가 4일 때, isEven()을 실행해서 결과를 출력\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 연습문제: Counter 다른 세션에서의 값 확인\n",
    "\n",
    "노드로 배포하고, 아래를 노드로 프로그램하세요.\n",
    "* counter를 조회하고, 위 REMIX에서 배포한 콘트랙의 counter의 수와 같은지 확인.\n",
    "* Counter를 0부터 3까지 증가\n",
    "* 노드 세션을 새로 열어, Counter를 하나 더 증가시키려고 할 때 0부터 시작하는지 또는 전 세션에서 끝낸 counter의 수가 남아 있는지 출력\n",
    "* counter가 4일 때, isEven()을 실행해서 결과를 출력\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}