add dist

.gitignore

@@ -12,7 +12,6 @@ temp
 .DS_Store
 app/.DS_Store
 
-dist
 builds/
 disc/
 builds.zip
@@ -27,4 +26,4 @@ test/test-bundle.js
 notes.txt
 
 .coveralls.yml
-.nyc_output
+.nyc_output

dist/auto-reload.js

@@ -0,0 +1,60 @@
+"use strict";
+
+module.exports = setupDappAutoReload;
+
+function setupDappAutoReload(provider, observable) {
+  // export web3 as a global, checking for usage
+  // MetaMask.createDefaultProvider
+  var hasBeenWarned = false;
+  var reloadInProgress = false;
+  var lastTimeUsed = void 0;
+  var lastSeenNetwork = void 0;
+  var reloadEnabledProvider = new Proxy(provider, {
+    get: function get(_provider, key) {
+      // get the time of use
+      lastTimeUsed = Date.now();
+      // return value normally
+      return _provider[key];
+    },
+    set: function set(_provider, key, value) {
+      // set value normally and return value in order to not break javascript
+      return _provider[key] = value;
+    }
+  });
+
+  observable.subscribe(function (state) {
+    // if reload in progress, no need to check reload logic
+    if (reloadInProgress) return;
+
+    var currentNetwork = state.networkVersion;
+
+    // set the initial network
+    if (!lastSeenNetwork) {
+      lastSeenNetwork = currentNetwork;
+      return;
+    }
+
+    // skip reload logic if web3 not used
+    if (!lastTimeUsed) return;
+
+    // if network did not change, exit
+    if (currentNetwork === lastSeenNetwork) return;
+
+    // initiate page reload
+    reloadInProgress = true;
+    var timeSinceUse = Date.now() - lastTimeUsed;
+    // if web3 was recently used then delay the reloading of the page
+    if (timeSinceUse > 500) {
+      triggerReset();
+    } else {
+      setTimeout(triggerReset, 500);
+    }
+  });
+
+  return reloadEnabledProvider;
+}
+
+// reload the page
+function triggerReset() {
+  global.location.reload();
+}

dist/inpage-provider.js

@@ -0,0 +1,117 @@
+'use strict';
+
+var pump = require('pump');
+var RpcEngine = require('json-rpc-engine');
+var createIdRemapMiddleware = require('json-rpc-engine/src/idRemapMiddleware');
+var createStreamMiddleware = require('json-rpc-middleware-stream');
+var LocalStorageStore = require('obs-store');
+var ObjectMultiplex = require('obj-multiplex');
+var config = require('../config.json');
+
+module.exports = MetamaskInpageProvider;
+
+function MetamaskInpageProvider(connectionStream) {
+  var self = this;
+
+  // setup connectionStream multiplexing
+  var mux = self.mux = new ObjectMultiplex();
+  pump(connectionStream, mux, connectionStream, function (err) {
+    return logStreamDisconnectWarning('MetaMask', err);
+  });
+
+  // subscribe to metamask public config (one-way)
+  self.publicConfigStore = new LocalStorageStore({ storageKey: 'MetaMask-Config' });
+  pump(mux.createStream('publicConfig'), self.publicConfigStore, function (err) {
+    return logStreamDisconnectWarning('MetaMask PublicConfigStore', err);
+  });
+
+  // ignore phishing warning message (handled elsewhere)
+  mux.ignoreStream('phishing');
+
+  // connect to async provider
+  var streamMiddleware = createStreamMiddleware();
+  pump(streamMiddleware.stream, mux.createStream('provider'), streamMiddleware.stream, function (err) {
+    return logStreamDisconnectWarning('MetaMask RpcProvider', err);
+  });
+
+  // handle sendAsync requests via dapp-side rpc engine
+  var rpcEngine = new RpcEngine();
+  rpcEngine.push(createIdRemapMiddleware());
+  // deprecations
+  rpcEngine.push(function (req, res, next, end) {
+    var deprecationMessage = config['ethereum']['deprecated-methods'][req.method];
+    if (!deprecationMessage) return next();
+    end(new Error('MetaMask - ' + deprecationMessage));
+  });
+
+  rpcEngine.push(streamMiddleware);
+  self.rpcEngine = rpcEngine;
+}
+
+// handle sendAsync requests via asyncProvider
+// also remap ids inbound and outbound
+MetamaskInpageProvider.prototype.sendAsync = function (payload, cb) {
+  var self = this;
+  self.rpcEngine.handle(payload, cb);
+};
+
+MetamaskInpageProvider.prototype.send = function (payload) {
+  var self = this;
+
+  var selectedAddress = void 0;
+  var result = null;
+  switch (payload.method) {
+
+    case 'eth_accounts':
+      // read from localStorage
+      selectedAddress = self.publicConfigStore.getState().selectedAddress;
+      result = selectedAddress ? [selectedAddress] : [];
+      break;
+
+    case 'eth_coinbase':
+      // read from localStorage
+      selectedAddress = self.publicConfigStore.getState().selectedAddress;
+      result = selectedAddress || null;
+      break;
+
+    case 'eth_uninstallFilter':
+      self.sendAsync(payload, noop);
+      result = true;
+      break;
+
+    case 'net_version':
+      var networkVersion = self.publicConfigStore.getState().networkVersion;
+      result = networkVersion || null;
+      break;
+
+    // throw not-supported Error
+    default:
+      var link = 'https://github.com/MetaMask/faq/blob/master/DEVELOPERS.md#dizzy-all-async---think-of-metamask-as-a-light-client';
+      var message = 'The MetaMask Web3 object does not support synchronous methods like ' + payload.method + ' without a callback parameter. See ' + link + ' for details.';
+      throw new Error(message);
+
+  }
+
+  // return the result
+  return {
+    id: payload.id,
+    jsonrpc: payload.jsonrpc,
+    result: result
+  };
+};
+
+MetamaskInpageProvider.prototype.isConnected = function () {
+  return true;
+};
+
+MetamaskInpageProvider.prototype.isMetaMask = true;
+
+// util
+
+function logStreamDisconnectWarning(remoteLabel, err) {
+  var warningMsg = 'MetamaskInpageProvider - lost connection to ' + remoteLabel;
+  if (err) warningMsg += '\n' + err.stack;
+  console.warn(warningMsg);
+}
+
+function noop() {}

dist/setup-iframe.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var Iframe = require('iframe');
+var createIframeStream = require('iframe-stream').IframeStream;
+
+module.exports = setupIframe;
+
+function setupIframe(opts) {
+  opts = opts || {};
+  var frame = Iframe({
+    src: opts.zeroClientProvider || 'https://wallet.metamask.io/',
+    container: opts.container || document.head,
+    sandboxAttributes: opts.sandboxAttributes || ['allow-scripts', 'allow-popups', 'allow-same-origin']
+  });
+  var iframe = frame.iframe;
+  iframe.style.setProperty('display', 'none');
+  var iframeStream = createIframeStream(iframe);
+
+  return iframeStream;
+}

dist/setup-provider.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var setupIframe = require('./setup-iframe.js');
+var MetamaskInpageProvider = require('./inpage-provider.js');
+
+module.exports = getProvider;
+
+function getProvider(opts) {
+  if (global.web3) {
+    console.log('MetaMask ZeroClient - using environmental web3 provider');
+    return global.web3.currentProvider;
+  }
+  console.log('MetaMask ZeroClient - injecting zero-client iframe!');
+  var iframeStream = setupIframe({
+    zeroClientProvider: opts.mascaraUrl
+  });
+
+  var inpageProvider = new MetamaskInpageProvider(iframeStream);
+  return inpageProvider;
+}

dist/setup-widget.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var Iframe = require('iframe');
+
+module.exports = function setupWidget() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  var iframe = void 0;
+  var style = '\n    border: 0px;\n    position: absolute;\n    right: 0;\n    top: 0;\n    height: 7rem;';
+  var resizeTimeout = void 0;
+
+  var changeStyle = function changeStyle() {
+    iframe.style = style + (window.outerWidth > 575 ? 'width: 19rem;' : 'width: 7rem;');
+  };
+
+  var resizeThrottler = function resizeThrottler() {
+    if (!resizeTimeout) {
+      resizeTimeout = setTimeout(function () {
+        resizeTimeout = null;
+        changeStyle();
+        // 15fps
+      }, 66);
+    }
+  };
+
+  window.addEventListener('load', function () {
+    if (window.web3) return;
+
+    var frame = Iframe({
+      src: opts.host + '/proxy/widget.html' || 'https://wallet.metamask.io/proxy/widget.html',
+      container: opts.container || document.body,
+      sandboxAttributes: opts.sandboxAttributes || ['allow-scripts', 'allow-popups', 'allow-same-origin', 'allow-top-navigation'],
+      scrollingDisabled: true
+    });
+
+    iframe = frame.iframe;
+    changeStyle();
+  });
+
+  window.addEventListener('resize', resizeThrottler, false);
+};