ブロックチェーン入門 ─ JavaScriptで学ぶブロックチェーンとBitcoinウォレットの仕組みと実装

2018-11-30 · Copyright © 2024 en Japan Inc. All Rights Reserved.

const data = { hoge: 'ほげ', fuga: 'ふが' }
const serializedData = JSON.stringify(data)
console.log(serializedData)

000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
let counter = 0
console.log(counter) // --> 0
counter++            // データ更新
console.log(counter) // --> 1

const counterLogs = []

const printCounter = () => {
  console.log(counterLogs.reduce((acc, n) => acc + n, 0))
}

printCounter()       // --> 0
counterLogs.push(1)  // データ更新
printCounter()       // --> 1

const { createHash } = require('crypto')

const sha256s = buf => {
  const hash = createHash('sha256')
  // hash はハッシュ値を扱えるストリームオブジェクト
  hash.write(buf)
  return hash
    .digest()
    .toString('hex')
    .substr(-40)
}

const serialize = (type, data) => JSON.stringify({ type, ...data })

const createPacket = (type, data, rawdata = data) => {
  const serialized = serialize(type, data)
  const hash = sha256s(serialized)
  return { type, serialized, hash, ...rawdata }
}

const createTx = (from, sendTo, amount) => {
  const data = { from, sendTo, amount }
  return createPacket('tx', data)
}

const createCoinbaseTx = sendTo => {
  return createTx(null, sendTo, 50)
}

const createBlock = (txs, prevHash) => {
  const data = {
    txs: txs.map(tx => ({ hash: tx.hash, data: tx.serialized })),
    prevHash
  }
  const rawdata = { txs, prevHash }
  return createPacket('block', data, rawdata)
}

const deserialize = serialized => {
  const hash = sha256s(serialized)
  const rawdata = JSON.parse(serialized)
  return { type: rawdata.type, serialized, hash, ...rawdata }
}

const validateTxs = txs => {
  const wallets = {}

  return txs.every(({ from, sendTo, amount }) => {
    if (!from) {
      if (amount !== 50) {
        return false
      }
    } else {
      wallets[from] = (wallets[from] || 0) - amount
      if (wallets[from] < 0) {
        return false
      }
    }

    wallets[sendTo] = (wallets[sendTo] || 0) + amount
    return true
  })
}

const createInvalidBlockError = message =>
  new Error(`Invalid Block: ${message}`)

const validateBlocks = serializedBlocks => {
  let allTx = []
  let prevHash = '0000000000000000000000000000000000000000'

  serializedBlocks.forEach(serializedBlock => {
    const { data, hash } = deserialize(serializedBlock)
    if (prevHash !== data.prevHash) {
      throw createInvalidBlockError(
        `block hash error: ${prevHash} !== ${data.prevHash}`
      )
    }
    prevHash = hash

const txs = data.txs.map(serialized => {
  const tx = deserialize(serialized).data
  if (tx.type !== 'tx') {
    throw createInvalidBlockError(`Tx packet type error: ${tx.type} !== tx`)
  }
  return tx
})

if (txs.length < 1) {
  throw createInvalidBlockError('Empty Txs')
}

if (!isCoinbaseTx(txs[0])) {
  throw createInvalidBlockError('first Tx must be CoinbaseTx')
}

if (txs.length > 1 && !txs.slice(1).every(tx => !isCoinbaseTx(tx))) {
  throw createInvalidBlockError('Illegal CoinbaseTx')
}

    allTx = allTx.concat(txs)
  })

  evaluateTxs(allTx)
}

class Node {
  constructor(seed = null) {
    this.address = sha256s(seed || randomBytes(32))
    this.pendingTxs = []
    this.blocks = []
    this.peers = []
    this.prevHash = '0000000000000000000000000000000000000000'
  }

  _getAllTx() {
    return [].concat(
      ...this.blocks.map(block => {
        return deserialize(block).data.txs.map(tx => deserialize(tx).data)
      }),
      this.pendingTxs.map(tx => deserialize(tx).data)
    )
  }
  getBalance(address = this.address) {
    const txs = this._getAllTx()
    const wallets = evaluateTxs(txs)
    return wallets[address] || 0
  }

  generate() {
    const coinbaseTx = createCoinbaseTx(this.address)
    const txs = [coinbaseTx.serialized, ...this.pendingTxs]
    const block = createBlock(txs, this.prevHash)
    this.pendingTxs = []
    this.prevHash = block.hash
    this.blocks.push(block.serialized)
    this.broadcast(block.serialized)
  }

  send(sendTo, amount) {
    if (amount > this.getBalance()) {
      throw new Error('Wallet error: Insufficient funds')
    }
    const tx = createTx(this.address, sendTo, amount)
    this.pendingTxs.push(tx.serialized)
    this.broadcast(tx.serialized)
  }

  connect(peer) {
    this.peers.push(peer)
    peer.peers.push(this)
  }

  broadcast(packet) {
    this.peers.forEach(peer => {
      peer.recv(packet)
    })
  }

  recv(packet) {
    const { type } = deserialize(packet).data
    switch (type) {
      case 'tx': {
        this._receiveTx(packet)
        break
      }
      case 'block': {
        this._receiveBlock(packet)
        break
      }
    }
  }

  _receiveTx(packet) {
    const { from } = deserialize(packet).data
    if (from === null) {
      throw new Error('Invalid Tx: reject CoinbaseTx')
    }
    const txs = this._getAllTx()
    txs.push(deserialize(packet).data)
    evaluateTxs(txs)

    this.pendingTxs.push(packet)
  }

  _receiveBlock(packet) {
    const blocks = [...this.blocks, packet]
    validateBlocks(blocks)

    this.blocks.push(packet)
  }

mkdir bitcoin-wallet
cd bitcoin-wallet

brew install bitcoind

$ mkdir data
$ bitcoind -testnet -datadir=data -txindex -server -rpcuser=u -rpcpassword=p

npm init -y
npm i request-promise

const rp = require('request-promise')

rp(`http://localhost:18332`, {
  method: 'POST',
  body: JSON.stringify({ method, params }),
  auth: { user, pass }
})

rp(...).then(response => console.log(response))

const dispatch = async (user, pass, method, ...params) => {
  const { result, error } = JSON.parse(await rp(...))
}

catch(e => {
  if (e.statusCode) {
    return JSON.stringify({ error: JSON.parse(e.error).error })
  } else {
    return JSON.stringify({ error: e.error })
  }
})

const createClient = ({ host, rpcport, user, pass }) => {
  // dispatch関数にあたるものを返す
}

const rp = require('request-promise')

const createClient = ({ host, rpcport, user, pass }) => {
  return async (method, ...params) => {
    const { result, error } = JSON.parse(
      await rp(`http://${host}:${rpcport}`, {
        method: 'POST',
        body: JSON.stringify({ method, params }),
        auth: { user, pass }
      }).catch(e => {
        if (e.statusCode) {
          return JSON.stringify({ error: JSON.parse(e.error).error })
        } else {
          return JSON.stringify({ error: e.error })
        }
      })
    )
    if (error) {
      throw error
    } else {
      return result
    }
  }
}

module.exports = { createClient }

const { createClient } = require('./client')

const wallet = async () => {
  if (process.argv.length < 3) {
    console.log('usage: wallet <command> [option...]')
    process.exit(1)
  }

  const command = process.argv[2]
  if (!(command in commands)) {
    console.log(`unknown command: ${command}`)
    process.exit(1)
  }

  const conf = {
    host: 'localhost',
    rpcport: 18332,
    user: 'u',
    pass: 'p'
  }
  const cl = createClient(conf)
  await commands[command](cl, ...process.argv.slice(3))
}

wallet().catch(err => console.error(err))

const newAddress = async cl => {
  const address = await cl('getnewaddress', 'my address')

  console.log(address)
}
// 中略
const commands = { newAddress, info, send, dump, importPriv }

$ node src/wallet/cli.js newAddress
2N7wqmAYRhiDUXhnZKtMbWBDSeXG4ddYvSy

const newAddress = async cl => {
  const address = await cl('getnewaddress', 'my address')

  console.log(address)
}

$ node src/wallet/cli.js info
addresses: [2N7wqmAYRhiDUXhnZKtMbWBDSeXG4ddYvSy]
balance: 0
block height: 273905

const info = async cl => {
  const addresses = await cl('getaddressesbylabel', 'my address')
  const balance = await cl('getbalance')
  const blockchainInfo = await cl('getblockchaininfo')

  console.log(`addresses: [${Object.keys(addresses).join(', ')}]`)
  console.log(`balance: ${balance}`)
  console.log(`block height: ${blockchainInfo.blocks}`)
}

$ node src/wallet/cli.js send 2N6PaxqoUFbWYiumFq3i6nuQPQ1LG8VJrE1 0.04
bef4f254851ff8cff12c398978f45bb3d73c713c38238330f2869898e0547151

const send = async (cl, address, amount) => {
  const txid = await cl('sendtoaddress', address, amount)
  console.log(txid)
}

$ node src/wallet/cli.js dump 2N6PaxqoUFbWYiumFq3i6nuQPQ1LG8VJrE1
<プライベートキー>

const dump = async (cl, address) => {
  const priv = await cl('dumpprivkey', address)
  console.log(priv)
}

$ node src/wallet/cli.js importPriv <プライベートキー>

const importPriv = async (cl, priv) => {
  await cl('importprivkey', priv, 'my address')
}

ブロックチェーン入門 ─ JavaScriptで学ぶブロックチェーンとBitcoinウォレットの仕組みと実装

ブロックチェーンとは何か？

ブロックチェーンが活用されている分野

データ構造から見たブロックチェーン

トランザクション

ブロック

gitはブロックチェーンか？

分散合意アルゴリズムとしてのブロックチェーン

データの積み重ねで更新を表現する

データ更新を分散環境で合意する

PoWという発明

ブロックチェーンを作ってみよう

1. ハッシュ値をとる

2. パケットを作成する

3. トランザクションのパケットを作成する

4. ブロックを作成する

5. デシリアライズする

6. トランザクションを検証する

7. ブロックを検証する

8. Nodeクラスを作る

Bitcoinウォレットを作ってみよう

Bitcoin Coreをインストールする

bitcoindを起動する

必要なパッケージをインストールする

Bitcoin Coreを叩く

クライアントを作る関数を作る

ウォレットの作成

ウォレットのコマンド定義

newAddressコマンド

infoコマンド

sendコマンド

dumpコマンド

importPrivコマンド

最後に