[EXPERIMENTAL] Feat/kitsunet

app/manifest.json

@@ -85,4 +85,4 @@
       "*"
     ]
   }
-}
+}

app/scripts/background.js

@@ -181,8 +181,8 @@ async function loadStateFromPersistence () {
   // read from disk
   // first from preferred, async API:
   versionedData = (await localStore.get()) ||
-                  diskStore.getState() ||
-                  migrator.generateInitialState(firstTimeState)
+    diskStore.getState() ||
+    migrator.generateInitialState(firstTimeState)
 
   // check if somehow state is empty
   // this should never happen but new error reporting suggests that it has
@@ -246,7 +246,7 @@ async function loadStateFromPersistence () {
  * @param {String} initLangCode - The region code for the language preferred by the current user.
  * @returns {Promise} After setup is complete.
  */
-function setupController (initState, initLangCode) {
+async function setupController (initState, initLangCode) {
   //
   // MetaMask Controller
   //
@@ -264,9 +264,11 @@ function setupController (initState, initLangCode) {
     initLangCode,
     // platform specific api
     platform,
-    encryptor: isEdge ? new EdgeEncryptor() : undefined,
+    // encryptor: isEdge ? new EdgeEncryptor() : undefined,
   })
 
+  await controller.init()
+
   const provider = controller.provider
   setupEnsIpfsResolver({ provider })
 
@@ -473,7 +475,7 @@ function openPopup () {
 }
 
 // On first install, open a new tab with MetaMask
-extension.runtime.onInstalled.addListener(({reason}) => {
+extension.runtime.onInstalled.addListener(({ reason }) => {
   if ((reason === 'install') && (!METAMASK_DEBUG)) {
     platform.openExtensionInBrowser()
   }

app/scripts/controllers/network/createKitsunetClient.js

@@ -0,0 +1,145 @@
+'use strict'
+
+const EE = require('safe-event-emitter')
+
+const PeerId = require('peer-id')
+const PeerInfo = require('peer-info')
+const pify = require('pify')
+
+const { MAINNET_CODE } = require('./enums')
+
+const mergeMiddleware = require('json-rpc-engine/src/mergeMiddleware')
+const createBlockRefRewriteMiddleware = require('eth-json-rpc-middleware/block-ref-rewrite')
+const createAsyncMiddleware = require('json-rpc-engine/src/createAsyncMiddleware')
+const providerFromMiddleware = require('eth-json-rpc-middleware/providerFromMiddleware')
+const createSliceMiddleware = require('eth-json-rpc-kitsunet-slice')
+const scaffold = require('eth-json-rpc-middleware/scaffold')
+const createVmMiddleware = require('eth-json-rpc-middleware/vm')
+
+const utils = require('ethereumjs-util')
+const createKitsunet = require('kitsunet')
+
+module.exports = async function () {
+  const id = await pify(PeerId.create)()
+  const peerInfo = await pify(PeerInfo.create)(id)
+  const clientId = peerInfo.id.toB58String()
+  const identity = id.toJSON()
+  const devMode = true
+
+  const kitsunet = await createKitsunet({
+    identity,
+    libp2pAddrs: [
+      // `/dns4/signaller.lab.metamask.io/tcp/443/wss/p2p-webrtc-star/ipfs/${clientId}`
+      `/ip4/127.0.0.1/tcp/9090/ws/p2p-webrtc-star/ipfs/${clientId}`,
+    ],
+    NODE_ENV: devMode ? 'dev' : 'prod',
+    sliceDepth: 10,
+    // rpcUrl: 'http://localhost:8546',
+    ethAddrs: [
+      '0x52bc44d5378309ee2abf1539bf71de1b7d7be3b5',
+      '0x6810e776880c02933d47db1b9fc05908e5386b96',
+      '0x1d805bc00b8fa3c96ae6c8fa97b2fd24b19a9801',
+    ],
+    libp2pBootstrap: [
+      '/ip4/127.0.0.1/tcp/30334/ws/ipfs/QmUA1Ghihi5u3gDwEDxhbu49jU42QPbvHttZFwB6b4K5oC',
+    ],
+    slicePath: ['8e99', '1372'],
+    dialInterval: 10000,
+  })
+
+  // block tracker
+  const blockTracker = new KsnBlockTracker(kitsunet)
+
+  // create higher level
+  const provider = providerFromMiddleware(createKitsunetMiddleware({ kitsunet }))
+
+  // add handlers
+  const networkMiddleware = mergeMiddleware([
+    createKitsunetMiddleware({ kitsunet }),
+    createBlockRefRewriteMiddleware({ blockTracker }),
+    createSliceMiddleware({ kitsunet, depth: 10 }),
+    createVmMiddleware({ provider }),
+  ])
+
+  await kitsunet.start()
+  return { networkMiddleware, blockTracker }
+}
+
+function createKitsunetMiddleware ({ kitsunet }) {
+  return scaffold({
+    eth_getBlockByNumber: createAsyncMiddleware(async (req, res, next) => {
+      const [blockRef] = req.params
+      let block = null
+      if (blockRef === 'latest') {
+        block = await kitsunet.getLatestBlock()
+      } else {
+        block = await kitsunet.getBlockByNumber(blockRef, false)
+      }
+
+      if (!block) return next()
+      res.result = blockToRpc(block)
+    }),
+    eth_getBlockNumber: createAsyncMiddleware(async (req, res, next) => {
+      const block = await kitsunet.getLatestBlock()
+      console.log(`got block: `)
+      console.dir(block.header.number.toString('hex'))
+      if (!block) return next()
+      res.result = blockToRpc(block)
+      console.dir(res.result)
+    }),
+    net_version: createAsyncMiddleware(async () => {
+      res.result = MAINNET_CODE
+    }),
+  })
+}
+
+class KsnBlockTracker extends EE {
+  constructor (client) {
+    super()
+    this.client = client
+    this.current = null
+
+    this.client.on('latest', (block) => {
+      this.current = utils.addHexPrefix(block.header.number.toString('hex'))
+      this.emit('latest', this.current)
+    })
+
+    this.client.on('sync', ({ newBlock, oldBlock }) => {
+      this.emit('sync', {
+        newBlock: newBlock ? utils.addHexPrefix(newBlock.header.number.toString('hex')) : '0x0',
+        oldBlock: oldBlock ? utils.addHexPrefix(oldBlock.header.number.toString('hex')) : '0x0',
+      })
+    })
+  }
+
+  async getLatestBlock () {
+    const block = await this.client.getLatestBlock()
+    return utils.addHexPrefix(block.header.number.toString('hex'))
+  }
+
+  getCurrentBlock () {
+    return this.current
+  }
+}
+
+function blockToRpc (block) {
+  const jsonBlock = block.toJSON(true)
+  return {
+    parentHash: jsonBlock.header.parentHash,
+    sha3Uncles: jsonBlock.header.uncleHash,
+    miner: jsonBlock.header.coinbase,
+    stateRoot: jsonBlock.header.stateRoot,
+    transactionsRoot: jsonBlock.header.transactionsTrie,
+    receiptRoot: jsonBlock.header.receiptTrie || utils.SHA3_NULL,
+    logsBloom: jsonBlock.header.bloom,
+    difficulty: jsonBlock.header.difficulty,
+    number: jsonBlock.header.number,
+    gasLimit: jsonBlock.header.gasLimit,
+    gasUsed: jsonBlock.header.gasUsed,
+    timestamp: jsonBlock.header.timestamp,
+    extraData: jsonBlock.header.extraData,
+    mixHash: jsonBlock.header.mixHash,
+    nonce: jsonBlock.header.nonce,
+    transactions: jsonBlock.transactions,
+  }
+}

app/scripts/controllers/network/network.js

@@ -10,6 +10,8 @@ const createMetamaskMiddleware = require('./createMetamaskMiddleware')
 const createInfuraClient = require('./createInfuraClient')
 const createJsonRpcClient = require('./createJsonRpcClient')
 const createLocalhostClient = require('./createLocalhostClient')
+const createKitsunetClient = require('./createKitsunetClient')
+
 const { createSwappableProxy, createEventEmitterProxy } = require('swappable-obj-proxy')
 const extend = require('extend')
 const networks = { networkList: {} }
@@ -65,10 +67,10 @@ module.exports = class NetworkController extends EventEmitter {
     this._blockTrackerProxy = null
   }
 
-  initializeProvider (providerParams) {
+  async initializeProvider (providerParams) {
     this._baseProviderParams = providerParams
     const { type, rpcTarget, chainId, ticker, nickname } = this.providerStore.getState()
-    this._configureProvider({ type, rpcTarget, chainId, ticker, nickname })
+    await this._configureProvider({ type, rpcTarget, chainId, ticker, nickname })
     this.lookupNetwork()
   }
 
@@ -141,8 +143,8 @@ module.exports = class NetworkController extends EventEmitter {
   }
 
   async setProviderType (type) {
-    assert.notEqual(type, 'rpc', `NetworkController - cannot call "setProviderType" with type 'rpc'. use "setRpcTarget"`)
-    assert(INFURA_PROVIDER_TYPES.includes(type) || type === LOCALHOST, `NetworkController - Unknown rpc type "${type}"`)
+    // assert.notEqual(type, 'rpc', `NetworkController - cannot call "setProviderType" with type 'rpc'. use "setRpcTarget"`)
+    // assert(INFURA_PROVIDER_TYPES.includes(type) || type === LOCALHOST, `NetworkController - Unknown rpc type "${type}"`)
     const providerConfig = { type }
     this.providerConfig = providerConfig
   }
@@ -164,13 +166,13 @@ module.exports = class NetworkController extends EventEmitter {
   // Private
   //
 
-  _switchNetwork (opts) {
+  async _switchNetwork (opts) {
     this.setNetworkState('loading')
-    this._configureProvider(opts)
+    await this._configureProvider(opts)
     this.emit('networkDidChange', opts.type)
   }
 
-  _configureProvider (opts) {
+  async _configureProvider (opts) {
     const { type, rpcTarget, chainId, ticker, nickname } = opts
     // infura type-based endpoints
     const isInfura = INFURA_PROVIDER_TYPES.includes(type)
@@ -182,6 +184,8 @@ module.exports = class NetworkController extends EventEmitter {
     // url-based rpc endpoints
     } else if (type === 'rpc') {
       this._configureStandardProvider({ rpcUrl: rpcTarget, chainId, ticker, nickname })
+    } else if (type === 'kitsunet') {
+      await this._configureKitsunetProvider({})
     } else {
       throw new Error(`NetworkController - _configureProvider - unknown type "${type}"`)
     }
@@ -204,6 +208,12 @@ module.exports = class NetworkController extends EventEmitter {
     this._setNetworkClient(networkClient)
   }
 
+  async _configureKitsunetProvider () {
+    log.info('NetworkController - configureKitsunetProvider')
+    const networkClient = await createKitsunetClient({})
+    this._setNetworkClient(networkClient)
+  }
+
   _configureStandardProvider ({ rpcUrl, chainId, ticker, nickname }) {
     log.info('NetworkController - configureStandardProvider', rpcUrl)
     const networkClient = createJsonRpcClient({ rpcUrl, platform: this.platform })

app/scripts/lib/setupMetamaskMeshMetrics.js

@@ -5,8 +5,8 @@ module.exports = setupMetamaskMeshMetrics
  * Injects an iframe into the current document for testing
  */
 function setupMetamaskMeshMetrics () {
-  const testingContainer = document.createElement('iframe')
-  testingContainer.src = 'https://metamask.github.io/mesh-testing/'
-  console.log('Injecting MetaMask Mesh testing client')
-  document.head.appendChild(testingContainer)
+  // const testingContainer = document.createElement('iframe')
+  // testingContainer.src = 'https://metamask.github.io/mesh-testing/'
+  // console.log('Injecting MetaMask Mesh testing client')
+  // document.head.appendChild(testingContainer)
 }