Augur -Updated details+ New devlopment update
Welcome to the future of forecasting
Augur combines the magic of prediction markets with the power of a decentralized network to create a stunningly accurate forecasting tool - and the chance for real money trading profits
Get rewarded for your knowledge and insight
Augur is a prediction market platform that rewards you for correctly predicting future real-world events.
Predict the outcome of real-world events
You make your predictions by trading virtual shares in the outcome of events happening in the real-world. If you think Hillary Clinton will be elected President, the Yankees will win the World Series, or Leonardo DiCaprio will win another Oscar, then you'll buy shares in those outcomes. If you buy shares in the correct outcomes, you'll win real money profits.
Earn real-money trading profits
The prices of the shares you trade in any event adds up to one dollar - so if you buy a share at even odds it will cost you 50 cents. If you end up being right, you'll get back one dollar for every share you bought. If you're wrong then you've lost the money used to buy your shares. As with any market, the price of shares fluctuates over time. As more people buy shares in an outcome, the price of that outcome will rise while the price of other outcomes will fall. This gives you further opportunities for profit - by buying low and selling high, before the final result of the market is known.
Stunningly accurate forecasts on any topic
Augur's prediction markets provide powerful predictive data - you can think of the current market price of any share in any market as an estimate of the probability of that outcome actually occurring in the real world. For example, a share priced at 64 cents has a 64% probability of happening. The accuracy of prediction markets rests in the idea of the "The Wisdom of the Crowd". This states that the average prediction made by a group is superior to that made by any of the individuals in that group. Markets are the perfect way to aggregate this collective wisdom - which is made up of all the information, analysis and opinion held by members of the group. With these individuals buying and selling shares in the outcome of real-world events, based on their personal knowledge and opinion, the market prices reach an equilibrium that reflect the opinion of the entire group. Prediction markets have proven to be more accurate at forecasting the future than individual experts, surveys or traditional opinion polling. They provide real-time predictive data and are traded using real money - which incentivises market participants to reveal what they think will happen, rather than what they hope will happen. Traders are putting their money where their mouths are.
Decentralization: Augur's secret weapon
Existing on a decentralized network gives Augur a unique edge over other prediction markets.
No central servers
Augur is a decentralized platform built on the Ethereum blockchain - which means no central servers that can be switched off.
Create your own markets
Using Augur, anyone, anywhere in the world can quickly and easily create a prediction market asking a question about anything. As a market creator you'll provide some initial funding for the market and in return receive half of all trading fees collected during the lifetime of that market.
Augur's fees are set by users, and are vastly lower compared to traditional trading and betting platforms.
In centralized markets, one person determines the final market outcomes - which means there can be mistakes or outright manipulation. With Augur, we'll have thousands reporting on market outcomes using a one-of-a kind consensus based system and a unique token called REPutation. As a reporter, you'll report on events every two months and, in return, receive half of all fees in the system multiplied by the percent of REP you own. The full scoop on REP
Safe, automated payments
All funds are stored in smart contracts - eliminating counterparty risk and allowing fast, automated payments to winning traders. Depositing and withdrawing funds are also completely automated using the blockchain. With no human intervention required, there's no human error.
Try Augur now...for free!
After months of development we are pleased to release the beta version of Augur. This early version showcases the core features of our prediction market platform. We're still actively developing the software and working on design, but we'd love to hear your honest and unfiltered feedback about our work so far
React / CSS & LESS / Node / DevOps / Bitcoin & Ethereum Augur is an open source decentralized prediction market built on Ethereum. By combining the magic of prediction markets with the power of a decentralized network, we’re able to create a stunningly accurate forecasting tool that can be used by anyone in the world. We’re looking for somebody who has built web trading interfaces before, ideally for a large scale site. We want you to be fluent in React, and have an intuitive understanding of how trading should work. It's a huge bonus if you’ve previously lead a small team of people doing just that. You’d be contributing to Augur and AURC, in which we encourage you to explore initially if interested. Please leave us your LinkedIn, GitHub, and one recommendation (with explanation) for how to improve Augur.
Augur Development Update – Nov 16
This past week has been focused on improving the new market UI and polishing up functionality related to reporting. We’re starting to expand our internal testing group, and have been receiving valuable feedback from everyone involved.
If you want to help test upcoming features or stay up to date on daily testing, please join us on Slack in the channel #betatesting.
We have our classic Augur shirts for sale on Bitcoin.com now, too!
Augur shirts are now available on the BitcoinCom store!
November 15, 2016
- Removed checkboxes from sidebar.
- Fixed market selector isExpired property calculation, distinguished it from isOpen.
- Added result (reported outcome / proportion correct) object field to market(s) selectors.
- For Airbitz logins, private keys are now stored in an Airbitz wallet instead of using the Airbitz dataKey as the Ethereum private key. (This change only affects Airbitz accounts.)
November 14, 2016
- Scalar market order books now display “truncated” share quantities for very large quantities of millishares and microshares.
- Market preview tooltips now display non-truncated values for very large numbers.
- Categorical outcomes are now correctly rounded to the nearest integer (on eventResolution contract).
- Added check to make sure event is on the specified branch before penalizing (on consensus contract). Resolves the edge case of penalization of a reporter who is otherwise caught up when there are no events in a period.
- Added reporting proportion correct value to getMarketInfo array (on compositeGetters contract).
- Added event outcome to getMarketsInfo (on compositeGetters contract).
- Fixed a bug causing some reports to throw hash-mismatching errors during the reveal-report action.
- Failed reveal report actions now render correctly on the transactions page.
- Fixed a bug that sometimes caused the login button to be incorrectly disabled.
November 13, 2016
- Finished refactoring and thoroughly unit testing reporting timing methods (checkPeriod et al) in augur.js.
- Fixed/updated augur.js reporting-sequence integration tests to work properly with the refactored reporting tools.
- Fixed error on Reporting detail page.
- Fixed warning on trade (market detail) page.
November 12, 2016
- Added rescaling logic for categorical and scalar reports to augur.js fixReport and (new) unfixReport methods, and updated event / report loaders in UI accordingly.
- Full reset of network 9000 (test chain) contracts.
November 11, 2016
- Merged augur-core develop into master branch.
- Changed tick size to tenths on trade page.
- Added highlighting of the matching side of the order book when user clicks buy/sell.
- Fixed abnormally high CPU utilization on markets listing page.
- The trade page for scalar markets now properly displays the unit selection drop-down menu. The share amounts on the page are updated automatically when a new unit is chosen.
- Fixed scalar market labels (no longer improperly labeled as categorical markets).
November 10, 2016
- Added the first big batch of trading unit tests for the main augur repository.
- Your reported outcome is now displayed in bright red text when you have committed, but not yet revealed, your report. It displays a tooltip telling you that you must remember to log back in to reveal your report. (After the report is revealed, the reported outcome text reverts to a normal color.)
- Began refactoring the monolithic checkPeriod method in augur.js. Set up mocks and stubs for unit testing.
November 9, 2016
- Fixed the My Reports (Portfolio) display.
- Added reporting cycle information (cycle number and how many cycles ago) to the My Reports display.
- Added a red thumbs-down “unethical” icon to the My Reports display. This appears by your reported outcome if you report a market unethical.
- Removed the fees collected column from My Reports, since this information is not yet accessible.
- Fixed the Ask / Ask Q. headers (switched positions).
- Improved load-events-with-submitted-report workflow: fixed penalize log-lookup, load event/report data from the reports state instead of the blockchain (where possible), and removed not-yet-implemented backend function calls.
- Added minValue, maxValue, and numOutcomes to the getMarketsInfo (compositeGetters contract) return array, and updated augur.js bindings. augur.js now assigns a type field (scalar, binary, categorical) to each market object in getMarketsInfo.
Check back next week for our latest developments!
– The Augur Teamhttps
Augur Development Update: Dec-2016
The primary focus of the past two weeks has been unit testing, reporting, and various UI clean up. The beta is now running on Ropsten testnet, while the private instance still runs on our own chain. The technical updates below outline the day to day changes pushed to Augur. We’re working on merging Augur with AURC, which will be a great productivity increase for development when completed.We will be expanding our controlled testing group soon – if you’d like to join, drop us a line on Slack!The grey and purple classic Augur hoodies are now for sale on Bitcoin.com
The @AugurProject hoodie is now available in grey and purple on the @BTCTN store! #augur https://store.bitcoin.com/products/augur-hoodie …
November 30, 2016
- Added human-readable “label” and “description” fields to static API data. Added “label maker” to augur-core API maker script.
- The following things are now included in the auto-generated transaction display: formatted label, description, timestamp, and gas fees.
- Added a “no-relay” list to the UI, which has the names of methods for which the transaction relay should not be triggered. This will allow the old manually-constructed “transactions” to peacefully coexist with relay-generated transactions in the transaction display.
November 29, 2016
- Attached the initial transact payload and full Ethereum network response data objects to the txRelay callback argument in ethrpc.
- Percentage reporting on correct outcome is now only displayed for binary markets, since we do not presently have access to this information for categorical and scalar markets.
- Fixed an array indexing error in getMarketInfo function on the compositeGetters contract.
- Reports are now revealed in parallel (up to 5 at a time).
- Registered sell error codes for the shortAsk method. This fixes the bug where a short ask order would correctly fail (due to orders being “crossed”), but the transactions display would incorrectly show the short ask as successful.
- Removed deprecated callbacks from augur.js.
- Fixed augur.js sendEther method to correctly include an onFailed callback.
November 28, 2016
- The checkPeriod function now only looks up chain data on initial loading and when the reporting cycle phase changes.
- Removed code related to the market data refresh timer, which is no longer used.
- Added a generic hook for transaction callbacks to ethrpc. The UI (or augur.js) can now register a transaction relay function that is automatically called any time any transaction is sent, succeeds, or fails.
November 27, 2016
- Added answer-in-description reporting test markets for first 4 cycles on root branch. (Example description: “Binary Reporting Test Market (Cycle 1): correct answer is Yes”)
- New testnet (Ropsten) genesis file is now bundled with augur.js.
- Fixed proportion-correct display on closed-market detail page and My Reports page.
- Fixed market result outcome name lookup for closed markets.
- The augur.js penaltyCatchUp sequence now calls closeMarket for all markets associated with the penalized event (instead of just extra markets beyond the first). This may be a temporary fix, depending on how penalizeWrong on-contract method is changed.
November 26, 2016
- Fixed new-branch first-reporting-cycle edge case on collectFees contract: collectFees method now always returns a value.
- Renewed augur.net wildcard SSL certificate (for eth2/3/9000 servers).
- Fixed trade page warning about minLimitPrice/maxLimitPrice types.
- Removed the block number restriction on best bid/ask order tracking on trades contract. Best bid/ask now represent the best prices in any block, for a given market and outcome. (The block number restriction is no longer necessary since the crossed-orders check simply returns an error for the later-arriving order, which is not placed on the book.)
November 25, 2016
- Event IDs retrieved during composite lookups (getMarketInfo, batchGetMarketInfo, and/or getMarketsInfo) are now uniformly formatted.
- Added market/event ID parser method to the static API data of several augur.js wrappers.
- Combined first and second reporting test sequences into one method.
- Default HTTP and websocket hosted node URLs are now attached to the ethrpc (augur.rpc) object / editable by the consumer.
November 24, 2016
- Restructured augur.js tests: moved unit tests and integration tests to separate folders.
- Updated UUID versions and package name in keythereum and augur.js.
- Updated middleware Travis CI builds to only run on updates to the master branch.
- Various fixes to augur UI unit tests.
- Merged Sprinkle’s mega-PRs! (These include fixes/improvements made over the past week.)
November 23, 2016
- Added the ability to auto-populate a trade ticket by selecting any order present in either the outcomes list or order book.
- Expanded test coverage of the Augur API buy, sell, and shortAsk trade methods.
November 22, 2016
- Visual indication of ‘own’ orders within a market outcome’s order book.
- Improved min/max bound handling for both shares and limit price when creating a trade order.
- Auto highlight behavior change to order book on market view.
- Improvements to the scalar share denomination label handling.
- General improvements to Augur.js trade unit tests.
- Improved test coverage of Augur.js ‘buy’ method.
- Added test coverage for the Augur.js ‘sendReputation’ method.
November 21, 2016
- Expanded and refined test coverage of the place trade action.
- Updated and added additional test coverage related to the market data and outcome trade components.
- Continued styling improvements to the market view.
- Bug fix related to the counts presented in both the header and footer navigational items.
- Improved state handling surrounding the outcome trade side selection.
- Safari and Mobile Safari specific UI fixes.
- Expanded and added additional selector shape coverage for market data and outcome trade selectors respectively.
November 18, 2016
- General responsive improvments including:
- Improvements to market view components to be fully responsive.
- Improvements to the markets view compoenents’ existing responsiveness.
- Various miscellaneous UI responsiveness adjustments + improvements.
- Improved UX of header and footer navigation.
- Inclusion of additonal swipe event to handle show/hide of side bar.
November 17, 2016
- The trades contract now tracks the best bid and ask price within each block, and the buy/sell functions on the buy & sell shares contract verifies that incoming orders do not cross any previous orders in the same block. (That is, it makes sure that bids do not exceed the best ask price and vice versa.) If a make that would result in a crossed order is found, the later arriving order is not created, and an appropriate error message is relayed to the user.
- Better handling of mobile touch events, especially pertaining to nav reveal/hide swipe events.
- Additional responsive UI improvements.
- Expanded and refined testing coverage of the short sell trading functionality.
As always, feel free to reach out with questions, comments or concerns and check back next week for our most recent progress.
– The Augur Team
Augur Front-End Technical Update – Dec 7th
The Augur UI React Components repository and the Augur repository have been merged! It currently resides within the 1281-aurc-merge branch, soon to be the master Augur branch. Documentation has been updated to include running an Ethereum node locally, as well as Yarn build instructions. With the repos merged together, we expect a significant increase in development speed.Contracts are now deployed on the Ropsten testnet for app.augur.net – while private.augur.net is still running on our own private chain. If you experience rejected transactions on app.augur.net due to the Ropsten testnet, you’re welcome to use our private chain for testing. Reporting and revealing edge cases are continuing to be smoothed out and addressed.We will soon be releasing a checklist of actions and functionality to be formally tested on the Augur platform. This will be apart of the expansion within our controlled testing groups.
With the recent hacks of Augur affiliates, please be sure you are hardening your security. Read Kraken’s blog post about how to properly setup your 2FA, secure your phone line, and setup recovery options if you haven’t already. Check your email across HaveIBeenPwned to confirm you don’t have active leaked passwords out in the wild. Consider storing your crypto on something like a Ledger Nano S (which supports all ERC-20 token types). Reduce your attack surface as much as possible. The attacks have nothing to do with the Ethereum blockchain or the Augur project itself, they are all on individuals
Augur Front-End Technical Update:
December 6, 2016
- Use last block gasLimit to set raw transaction gasLimit, if available.
- Removed conditional call to collectFees contract from submitReport: this call was not working correctly and (if fixed) would bring additional complications with it, so decoupling these functions seems like the better solution.
- Fixed first-reporting-cycle collectFees bug.
- Reversed order of UI calls to collectFees and revealReports in checkPeriod; collectFees is now called first.
- Added a filter that listens for market closings, and calls claimProceeds when events happen.
- Fixed the outcome name lookup of binary markets for reveal-reports.
December 5, 2016
- Added an optional timestamp argument to getCurrentPeriod and getCurrentPeriodProgress.
- Added explicit penalizeWrong and closeMarket wrappers to augur.js.
- Fixed penalizationCatchup call condition and added onSent/onSuccess callbacks to augur.js combined reporting functions.
- Moved payout augur.js functions to separate module.
- Fixed sender reference errors in payout functions.
- Added manual message updates to checkPeriod and claimProceeds functions.
- Removed account trades from localStorage.
- Removed duplicate address field (id) from loginAccount.
- Full contract re-upload on both network 9000 (private chain) and network 3 (public chain).
- Manually editing transaction display messages now disables automatic (return value-based) messaging transaction relay updates.
December 4, 2016
- Reputation faucet now correctly sets fees collected for the new reporter.
- Fixed sender address references in on-contract payout functions.
- Fixed condition under which Reporting catch-up function is called, instead of comparing event reports to the consensus (penalizeWrong).
- The UI now uses the current block timestamp to set Reporting cycle position.
- Removed duplicate address field from UI login account state.
- Removed account trades data from localStorage.
December 3, 2016
- Fixed a bug causing report period to be unassigned during commit report.
- Fixed filters (blockchain listeners) on non-root branches.
- Cash balances are now correctly displayed and updated on non-root branches.
- Last outcome price selector now directly uses the outcomes data state instead of the markets selector.
- Added contract method return value to transaction relay (auto-generated) display panels.
December 2, 2016
- Fixed reporting edge case where all markets in a reporting cycle have 0 volume.
- Assign reputation faucet starting report period depending on whether user accesses faucet during the first or second half of the current reporting cycle.
- Negative prices are now handled correctly during both trade and short sell.
- Updated geth.js start/stop package and tests.
- Added each-market-type order maker convenience method to augur.js reputation testing tools.
- Improved display of long messages in transaction display.
December 1, 2016
- Added more thorough unit tests for the trading UI.
- Uploaded Augur contracts to the new Ethereum public test network (“Ropsten”). Also moved the Augur faucet and public geth node (eth3.augur.net) to Ropsten. app.augur.net and augur-dev.firebaseapp.com are now configured to use the new Ropsten contracts. local.augur.net will also use Ropsten if you are not running a local Ethereum node. For users that prefer to remain on our private chain (network 9000), we are planning to maintain private.augur.net for the remainder of the beta test. Users of private.augur.net should be aware that the network 9000 blockchain is reset on a semi-regular basis, often without any public announcement/warning, and when this happens, all your private chain Ether, Reputation, and trading shares are also reset.
- Fixed market description display and links back to the trade page on the transactions page.
- Fixed bug causing cancel order transactions to appear twice in the transactions display.
- Significantly extended timeout in augur.js requests module to avoid ETIMEDOUT errors when attempting to request ETH from the faucet. The timeout is now set to a large value (999999) which should not be reached unless the user is experiencing a connection problem.
- Significantly extended nginx timeouts for eth1.augur.net. It turns out that the CORS errors occasionally generated by the faucet are not true CORS errors; it is actually an nginx timeout which is (mis-)identified as a CORS error. The timeout is now set to a large value (999999) which should not be reached unless the user is experiencing a connection problem.
Reputation 101 – A Guide to Augurs REP
What is Reputation ($REP)?
Reputation is the token behind Augur, and can be thought of as the “score” of an individual participant within Augur. Reputation is not an investment, but rather a tool necessary to make Augur work. The vast majority of Augur participants will never hold, see, or need to use Reputation. However, it’s extremely important to understand how Reputation works in order to fully grasp the Augur platform.Reputation tokens are limited to a fixed supply of 11,000,000, of which 80% was sold in our public token sale last year for a collective ~$5,300,000. Those who hold Reputation are expected to report accurately on the outcome of randomly selected events within Augur every few weeks. If holders fail to report accurately on the outcome of an event, or attempt to be dishonest – the Augur system redistributes the bad reporters Reputation to those who have reported accurately during the same reporting cycle.It’s important to note that you do not need Reputation to use Augur. Reputation is only used by reporters to report on the outcomes of events. Regular participants making bets on the platform will use Ether, or any other Ethereum sub currency. We hope to see the utilization of stable-coins in the future for settlement of markets.
What are the benefits of owning $REP?
By owning Reputation and participating in the accurate reporting on the outcomes of events, you are entitled to a portion of Augurs market fees. Each Reputation token entitles you to 1 / 22,000,000 of Augurs total market fees. The more Reputation you own and report correctly with, the more in fees you will collect. The Repulator Calculator made by an Augur community member will give you a rough estimate of expected earnings.
How do I purchase $REP?
If you missed out on purchasing during the token sale, you can still get your hands on some REP. Reputation is now sold on a number of third party crypto exchanges and markets, including Poloniex, Kraken, Bittrex, Gatecoin, and ShapeShift.Please be careful and weary of OTC trades in Slack groups, Bitcoin forums, etc. It’s suggested to purchase through an exchange for the increased safety of your trade. If you are looking to purchase a large amount, it’s recommended that you get in contact with an Augur team member and we can help point you in the right direction.
How do I safely store my $REP?
It is highly recommended that you store your Reputation in an offline, cold storage solution. Please do not leave large crypto holdings on centralized exchanges. Nor should you have a backup of your private key in your email, on your desktop, in your Google Drive, etc.The Ledger Nano S is a great hardware wallet solution, supporting all ERC-20 Ethereum token types. Your Reputation will be safe on one of these. We hope to have Augur support Ledger integration, meaning you can participate on Augur without ever having Reputation leave your Ledger.If you have any questions regarding Reputation, please contact us at [email protected].
Augur Development Update:
The team has been making great progress in the past two weeks. With our build process now using hot reload and having our two main repositories merged, we’re seeing a significant increase in the deployment process. We’re working on wrapping up the improved transaction display, reading all data from the blockchain instead of local storage. This will allow for more detailed transaction logs, as well as portability of your Augur account between browsers and devices.There are 15 remaining issues to address within the backend security review, 7 being actual code improvements, and 8 being code review. The security audits can begin after the 7 remaining code improvements. We expect this to begin sometime soon after the holidays. More details will be released in the coming updates!We also published Reputation 101: A Guide to Augurs REP, giving a simple overview of what REP is, where to purchase, how to store it, etc. Laura Shin of Forbes has written an overview of the recent hacks and another piece on tips to securing your accounts. Please remember to lock down your digital accounts / currencies.If you have any questions regarding our progress, the recent hacks, or how to stay secure – feel free to reach out to us at [email protected]
December 21, 2016
- Fixed reported outcome processing in event logs.
- Fixed reported outcome processing in converted transactions.
- Updated converted transaction messaging.
- Added market links to converted transactions for reporting.
- Added as-needed async market loading to the front-end transaction converter.
- Removed extra salt from commit-report encryption.
- Generic log filter parameters now include a branch ID field. Reporting contract event definitions now include an indexed branch parameter.
- Event validity bonds now have the correct label.
December 20, 2016
- The UI now processes logs using a comprehensive logs-to-transactions converter.
- Listeners for incoming reporting and payout events have been added to the UI.
- Included market creation fee and validity bond fields with market creation logs.
- The bond message font size has been fixed, so that it matches other transaction display items.
- The create market binding in augur.js now properly handles logged arrays.
- Added generic getLogs method to augur.js getLogs takes the event name as an argument, and supports nested indexing.
- The augur.js filters module has custom event parsing for all (non-logReturn) logged events.
- An enhancement to the development workflow (HMR – Hot Module Reload) was not functioning properly and required some reconfiguration to properly handle live changes. With the fixes in place, modules now update in real time, removing the requirement to either refresh the browser or restart the development server.
- Refined the UX surrounding the trade order creation process. Previously, the price would remain static if a value had been input, even when switching sides. The price will now update automatically to the best available price based on available orders whenever the trade side is changed.
- Placing a trade no longer automatically navigates you to the transactions view, but leaves you on the market view.
December 19, 2016
- Reported outcome processing in event logs in augur.js now provides the correct outcome values for all reports.
- Modified the penalize event log to include an indexed event ID field.
- Heroku builds (app.augur.net) were failing due to changes encompasses within the migration to a unified code base and webpack as the primary bundler. Resolved those issues and deployed an updated build. Subsequent builds will be automatic upon pushes to master.
December 16, 2016
- The log_add_tx event API now includes a timestamp field.
- Trade log objects now include an augur.js-generated sequence number.
- Market links now work correctly in transactions generated from trade logs.
- The new build system now works correctly on Linux.
- Fixes/improvements to Windows builds.
- Now allow someone to jus send fees to a market.
- Weight reports on a market based on how many fees it had paid through events as opposed to outstanding shares [which are somewhat proxies for each other].
December 15, 2016
- Several fixes/improvements to the new build system.
- Fixed several visual and messaging bugs in transactions auto-generated from trade logs.
- Added Snapcraft file to augur repository.
- Removed deprecated files associated with the old market update timer (market-data-age and market-data-updater).
- Fixed missing property error thrown during market creation.
- Fixed hot-module-reload.
- Market descriptions now display properly in the transactions display.
December 14, 2016
- Merged the augur-ui-react-components (AURC) repository into the augur (UI) repository. AURC is now deprecated; all UI development will take place in the augur repository.
- Added support for yarn (in addition to npm); see updated README for details.
- Migrated build system from a collection of ad hoc scripts to webpack.
- Added hot-module-reload (HMR) support to the build system. HMR propagates changes to the source code to the browser automatically, without requiring a page refresh.
December 13, 2016
- Auto-update trades converted to transactions for trades with matching hashes.
- Event unit testing progress.
- Implemented hotjar tracking for augur-dev.firebaseapp.com and app.augur.net.
December 12, 2016
- Fixed trade converted to transaction total cost and returns messages.
- Automatically convert incoming bids/asks and trade cancellation logs (from loadAccountTrades) to transactions formatted for display during the trade data update action. Bids, asks, and cancel transactions are now loaded directly from the blockchain.
- Removed deprecated market-data-age and market-data-updater selectors.
- Added total return per share calculation to trade transaction conversion.
- Restructured bids/asks and cancels objects to match trade logs structure.
December 11, 2016
- Added bids/asks and cancel log getters to modules/logs.
- Added account bids/asks and cancels data to loadAccountTrades.
- Automatically convert incoming trade logs (from loadAccountTrades) to transactions formatted for display during the trade data update action. Trade transactions are now loaded directly from the blockchain (so your trade history is portable across browsers).
December 10, 2016
- Added timestamp to log_add_tx and log_cancel.
- Added timestamp to complete sets logs.
- Added basic trade transaction reconstruction from logs to update-account-trades-data.
- Added takerFee, makerFee, transactionHash, and timestamp fields to account trade return value.
- Renamed tradeid -> trade_id in getMarketPriceHistory for consistency.
- Added trade ID to getMarketPriceHistory results.
December 9, 2016
- Added isIndeterminate field to getReport default return.
- Removed redundant (and broken) getMarketTrades method from augur.js. Please use getMarketPriceHistory instead, a function that is not broken and retrieves the same information.
- All fixed-point fields in the log_fill_tx event logs are now auto-converted to regular (stringified) numbers. Note that log_fill_tx and log_add_tx are the only two filters where fixed-point conversions is automatically performed.
- Updated load-report and load-reports tests.
December 8, 2016
- Indeterminate reports now load and reveal correctly for all three market types.
- Fixed outcome name displays in reveal report transactions.
- The no-report callback argument for getReport wrapper now uses the same object structure as the unfixReport function.
– The Augur Team
# Augur Front-End Update – Dec 28th ![0_1483020456826_augurholiday.jpg](https://i.imgur.com/FMDLaIm.jpg) December 28, 2016 Tom Kysar Comments 0 Comments Happy holidays from the Augur Team! Our developers have been keeping a rigorous development schedule, even with the holidays in full force. If you’d like more frequent technical updates than the blog posts, remember to check the login message page on Augur or join the #github channel on our Slack. The updates logged in these posts are always derived from our GitHub commits. On contract updating: there will be three ways in which it can happen. The first being a key that can unilaterally update contracts (as in the beginning a malicious update by us is less likely than a bug that needs to be fixed quickly) that also has a function for the key to disable itself, and another where reporters can vote to disable the key. The second being a key that can make updates, but reporters have the chance to veto it within N timeframe (with the respective functions to disable this as well). Lastly, reporters will be able to vote on updates within the regular reporting cycle. Next week we plan on publishing a set of walkthroughs / guides for testing the platform, along with a tutorial for securing your $REP with a Ledger Nano S. Technical Updates: December 28, 2016 1.Refactored loadMarketsInfo: moved branch ID filtering and created market info loading into separate functions. 2.Do not delete outcomes property of marketsData. 3.When retrying log conversion, use augur.getMarketInfo directly instead of loadMarketsInfo to avoid branch ID filtering. 4. Converted indeterminate constants to BigNumbers; updated comparisons in fix/unfixReport. 5.Added more payout tests around claimMarketsProceeds. December 27, 2016 1.2Fixed the ethicality displayed in converted transaction logs. 2.Rounded off converted Reputation percents for display. 3.Serialized log-to-transaction conversions. 4.Refactored the winning positions lookup done in order to claim trading proceeds from closed markets. December 26, 2016 1.Refactored the gigantic switch in the generic log-to-transactions converter into a collection of small, composable, testable subroutines. 2.The status-and-message display data is now organized separate from the main Transaction component, in a new TransactionMessage component. December 25, 2016 1.Removed the (unused) reporting period branch Reputation balance from the collectedFees log. 2.Added a check of whether market has already been closed (winning outcomes already set) both before and after the closeMarket function is called from augur.js. 3.Reporting cycle bar is now displayed at the top of the transactions page as well as the markets page. 4.Removed unused reporting outcome display block. 5.Load reporting history before branch sync (for logged in users). 6.Added a special startup sequence to init-augur to allow semi-automated multi-user/single-machine reporting tests. 7.Fixed payout lookup parameters in the account trade history log-loader. 8.Used async.eachLimit instead of async.each in all log loaders to keep from overwhelming the receiving RPC server. 9.Registration timestamps are now only recorded during the initial Airbitz account creation, not ordinary logins. 10.Added an event-to-market lookup table to the front-end data store. 11.Ad hoc balance and balance changes messaging in the transaction component have been replaced by a new balances array in the data field of any transaction that alters one or more balances. 12.Each transaction conversion will now only retry once, if the required market data is not available. 13.The fillOrder function now uses the correct side of order book. December 24, 2016 1.Added minimumTradeSize parameter to buy, sell, and shortAsk on contract and in augur.js. 2.Fixed event validity bond calculation on the createMarket contract. 3.Added a client-side (augur.js) method to calculate the validity bond, so that this can be displayed to the market creator prior to creating the market. 4.Added event validity bond calculation to step 5 of create market; added new arguments to step 5 of create market: period length, base reporters, number of events created in the past 24 hours, number of events in this reporting period. 5.Removed unnecessary field renaming in filters API: sender/owner are no longer changed to maker/taker in log_fill_tx, 6.log_add_tx, and log_cancel. Logs and filters now behave consistently and use the same field names everywhere. (In augur.js, the augur.filters formatters are now used to parse logs in modules/logs.js.) 7.Added getBaseReporters lookup to loadBranch (in augur.js), and added getPast24 and getNumberEvents lookups to syncBranch (in the UI). These values are attached to the branch state in the UI. 8.Log-lookup callback arguments are now consistent, and take an error as the first callback argument. 9.Replaced most special-purpose log-lookup methods with calls to augur.getLogs. A lot of semi-repeated code in modules/logs in augur.js has been removed as a result of this. 11.Added registration log loader to the front-end. 12.Removed deprecated code associated with market data updater timestamps. 13.Price time series construction now uses logged timestamp instead of converting from block number. Removed onSuccess calculations from collectFees, since values are now pulled from the event log. 14.Check if transaction already has status success before running onSuccess relay. 15.The total amount of reputation reporting for the cycle is now displayed correctly in the collect fees transaction panel. 16.The fillOrder action now updates market trades data and price history automatically. December 23, 2016 Added single-order add/remove/fill actions and used for targeted, no-RPC order book updates from filters. Offloaded trades and bids/asks update logic in trade process methods onto filters. Adjustments to the NPM scripts to improve the messaging during command execution. The reporting form is now encompassed within a tab in the market view rather than being a discrete view. This is so that users may continue to trade and so that reporters can reference relevant market data. The header in the markets view now updates to indicate when you are on the favorites or pending reports views. A slight adjustment to the Augur logo so that it remains centered in the header. Previously the nav items would push the logo off center. December 22, 2016 Converted maker trade transactions now have distinct messaging from normal (taker) trade transactions. Removed unnecessary registration filter. Refactored load-account-trades into composable loaders: deposit-withdraw, bids-asks, create-market, account-trades, and reporting. Placing a trade no longer automatically navigates you to the transactions view, but rather will leave you on the market view. Added final deleteTransaction call to trade process actions. Fees for maker trades no longer incorrectly display the taker fee. The trade inputs were incorrectly reporting invalid values via the hover title. This is now fixed, along with a custom value incrementer implemented on the input. The app is now a fu As always, feel free to reach out to us at [email protected] and join our Slack! – The Augur Team
Augur Front-End Update – Jan 4th
Happy new year from all of us at Augur!
I think Jack said it best here
The front-end is progressing forward week over week, and we’re collecting great feedback from our users and community members. The final phases of preparation for security audits are underway. An announcement will be made when they begin with all relevant information.
Be sure to check out Joey on the latest episode of the BlockChannel podcast discussing both Augur and Ethereum!
“If you’re big into finance or Wall St trading, this episode will likely get you salivating to give Augur a try this summer.” -BlockChannel
January 4, 2017
- Moved the in-progress display logic for order cancellation to the transaction relayer. Removed manual transaction display updates from cancel transactions.
- Added a single order selector (selects an order from the order book using its order ID AKA trade ID) to the bids-asks module.
January 3, 2017
- The front-end orderbook data store is now properly updated by the trade (log_fill_tx) and bid/ask (log_add_tx) filters.
- Only show balances in payout transaction display once the transaction has completed.
- Fixed winning outcome shares selection for categorical markets.
- Transaction messaging now distinguishes between in-progress transactions (present tense) and completed transactions (past tense).
- Added a new log (fundedAccount) to the faucets contract, so that fundNewAccount transactions are logged and can be loaded into transaction history.
January 2, 2017
- Streamlined the conditional fund-new-account and registration timestamp actions during login and registration.
- Moved the in-progress display logic for new account funding and timestamping to the transaction relayer.
- Verify that user has a winning position with greater than zero shares before calling the trading payout functions in augur.js.
- Moved the branch synchronization sequence specific to reporters to a separate action, and added a check for non-zero REP balance prior to dispatching this action.
- Logging in to an existing account now triggers free account funding if any balances are zero, instead of only checking if the account’s “ether” balance is zero.
- Importing an account from file now (conditionally) triggers funding and registration timestmap actions.
- Reordered loadLoginAccountDependents actions: registration timestamp lookup now happens before updateAssets.
- Added allAssetsLoaded method to the balances selector.
- Added fundNewAccount the transaction relayer.
- The default transaction constructor now allows custom message and description fields.
- The updateAssets callback now only fires once, after all assets are loaded.
- The FUND_ACCOUNT header text in the transactions display is now “Fund Account”.
January 1, 2017
- Moved the in-progress display logic for market creation, trading payouts (claim-proceeds), registration, and REP transfers and approvals to the transaction relayer.
- All messaging callbacks have been removed from claimMarketsProceeds in augur.js.
- Trading payout receipts in augur.js are now parsed using the filters event message parser.
- Updates to the augur-abi middleware module: added negative number support to the format_int256 method, and added an unfix_signed method to unfix and wrap to negative if needed.
- Added status parameter to constructRelayTransaction; assign in-progress/success status depending on if blockHash is set.
- Gas fees and timestamps now display properly for all relayed transaction types.
- Fixed gasFees formatting for transactions that are manually updated by the front-end.
- Removed deprecated messaging callbacks from checkPeriod.
- Added a “closedMarket” log to the CloseMarket contract that includes the market ID, branch ID, and sender account address for the market being closed. The old closeMarket_logReturn filter in the front-end has been replaced with the new closedMarket filter.
- Changed the initial report value for scalar events to an empty string to fix an uncontrolled-to-controlled input warning generated by React.
- Removed register from no-relay list.
- Removed manual Reveal Report transaction messaging code.
- Replaced “in progress” transaction status text with “submitted”.
- Your account positions are now reloaded after claiming trading payouts.
December 31, 2016
- Fixed the “isUnethical” calculation in constructSubmittedReportTransaction and constructSubmittedReportHashTransaction.
- Added missing dispatch arguments to constructReportingTransaction cases.
- Added report styling and unethical report “thumbs-down” icon to the Transaction component.
- The buildDescription function inside the Transaction component has been replaced with a new TransactionDescription component.
- Moved report ethicality display into separate ReportEthics component, and replaced ethics displays in My Report and Transaction with ReportEthics component. Removed report ethicality display logic from formatReportedOutcome.
- Attached id (market ID), minValue, amd maxValue properties to the market info objects fetched by getMarketInfo, getMarketsInfo, and batchGetMarketInfo in augur.js.
- Fixed two React warnings: 1) Added a new hidePrefix property to the ValueDenomination component and used it instead of conditionally displaying the freeze prefix value. 2) Changed the default null state values in the ReportForm component to undefined.
- In the branch synchronization sequence, getPenalizedUpTo and getCollectedFees are now only called if the user is logged in.
- Added a long dash (—) display in the “end date” column of My Reports if the end date is not available.
- Outcomes reported as both Indeterminate and Unethical are now displayed correctly in relayed Commit Report transactions.
- All manual commitReport transaction create/update/delete actions have been replaced by the transaction relay.
- Added a report encryption wrapper to the front-end.
- Indeterminate reports are now correctly converted to hexadecimal strings in augur.js fixReport method.
- Converted main trade logged-transaction loop to async.forEachOfSeries for proper getMarketInfo callback closure.
- Added initial check if “from” field matches login account address before processing relayed transactions.
- Fixed a reassignment error in place-trade.
- Filled in collectFees front-end transaction relayer.
- Added a check for the second half of the reporting period to the collectFees block of the composite reporting synchronization / updating methods in augur.js.
- The relayed transaction gasFees field now is included in filtered/converted transactions, if it is available (in-memory).
December 30, 2016
- Moved collectFees logic to augur.js: fee collection now handled automatically by augur.checkPeriod.
- The UI sync-branch-with-blockchain logic now looks up the last report cycle penalized and and the fee collection status of the cycle being checked for penalties. Both of these fields are now attached to the branch data store and available in the front-end.
- Filled in switch cases for submitReport, submitReportHash, penalizeWrong, and penalizationCatchup in the front-end part of the transaction relayer.
December 29, 2016
- Fixed/updated all downstream actions from or calling to bid, ask, and short ask.
December 28, 2016
- Replaced deprecated bid, ask, and short ask transaction-related code with simple calls to augur.js. All transaction display updating and messaging is now handled automatically by the transation relay and filters.
- Added possible events that can be logged by a method call to API maker script.
- Added error / null return checks to load-then-retry-conversion callbacks.
- Refactored trading log-to-transaction conversions.
– The Augur Team
Augur Development Update Jan 11th
This past week we addressed many bug fixes and tweaks around the app, along with improved unit testing and the near completion of a new system for transaction relaying. A large part of the user actions within the UI have been simplified and refactored, removing nearly 15,000 lines of code. This will be pushed within the next day, and then it’s onto skinning the remaining pages within the front-end. Joey is working on three remaining tasks before security audits: the contract updating functionality, a new trading system that handles worst case loss appropriately, and changing the system to allow event creation during forks. Progress is continuing to be made, and if you’d like a real time day by day of what we’re working on, come join us in Slack
January 10, 2017
- Added an optional “trade-group ID” parameter to all on-contract trading functions: buy, sell, short_sell, shortAsk, and trade, as well as the log_add_tx, log_fill_tx, and log_short_fill_tx events. Also added support for trade group ID in augur.js and the front-end. Trade group ID is a UUID assigned to each trade by the front-end, and is used to track (after-the-fact) which trades were placed as part of the same trade group or “meta-trade” in the UI.
- Updated reveal-reports, load-reports, commit-report, logout, place-trade, short-sell, and trade tests. All previously existing tests have now been updated for the transaction changes!
- Refactored place-trade: the “taker actions” (placeBuy, placeSell, and placeShortSell) are now in a separate file, take-order.
- Added Buffer support to the serialize utility in augur.js.
- The unit test suite for augur.js has been significantly expanded.
- Added loginWithMasterKey to augur.js accounts unit tests.
- Renamed the “web” submodule of augur.js to “accounts”. The old reference will continue to work for the time being.
January 9, 2017
- Added unit tests for the new winning-positions selector.
- Updated price-time-series and claim-proceeds unit tests.
- Changed scrollbars to auto-display when needed.
- Adjusted tooltip padding.
January 8, 2017
- The cash contract now fires a sentCash event when the send or sendFrom functions complete successfully. Supporting code has been added to the front-end listeners, the filters event formatter, and the transaction relay to listen for, parse, and automatically show on the transactions page.
- In-progress transaction messaging for closing out complete sets, “send” funds transactions (ether, real ether, and reputation), and initial order book generation is now handled entirely by the transaction relayer. (Note: initial order book generation is currently not exposed in the UI.)
- Simplified the transactions module by removing two unnecessary methods (updateExistingTransaction and processTransactions).
January 7, 2017
- Removed extraneous description fields from augur.js wrapper functions. Descriptions are now handled by the relayer.
- Added isShortAsk parameter to on-contract sell function and its associated log_add_tx event. The log_add_tx and log_short_fill_tx filters in augur.js autoconvert isShortAsk to a boolean value.
- Fixed final numMarketsToLoad value for descending loadMarkets.
- Added always-in-progress flag to relayed commitTrade transactions.
- Removed duplicate trading fees display in bid/ask/shortAsk transactions.
- Added isShortAsk field to relayed shortAsk transactions.
- Fixed short sell and short ask messaging. Added log_short_fill_tx as a separate relayed transaction label.
- Simplified trade simulation setup by inlining the trade and short sell “transaction” objects. Removed unused add-short-sell-transaction and add-trade-transaction files.
January 6, 2017
- The Transaction component no longer has separate commit-to-buy/sell types. These types now simply use the trade type the user is committing to.
- The transaction relayer now automatically fills in all fields for commit-trade, trade, and short-sell transactions by using the new, more detailed trade info fields attached to the tradeCommitment data store.
- Default “scaffolding” transaction updates have been removed from the relayer.
- Fixed in-progress vs completed messages for log_fill_tx.
- Assignment to the gasFees field now works correctly for relayed and logged trading transactions.
- Removed unnecessary dispatches from placeTrade and its subroutines.
- Added trade arguments and orders to the tradeCommitment datastore.
- The initial funding transaction log is now loaded alongside the registration timestamp transaction log.
- Replaced the ugly monster header with a “regular” header in the transactions view.
January 5, 2017
- The messaging for trade, short_sell, and commitTrade transactions is now handled by the transaction relayer. Deprecated manual transsaction messaging for these functions have been removed.
- Refactored place-trade: removed dispatcher from placeAsk, placeBid, placeShortAsk, and parametrizeOrder functions, and moved these functions to trade/actions/make-order.
- Simplified the selectScalarMinimum function and moved it to market/selectors/market.
January 4, 2017
- Replaced manual transaction processors for trades (buy/sell); refactored and simplified placeTrade.
- Simplified default message generator in registerTransactionRelay.
- Removed unused disableAutoMessage transaction property.
- Fixed bond object in constructMarketCreatedTransaction; fixed constructMarketTransaction parameters; moved marketCreated label out of constructMarketTransaction group.
- Consolidated create market actions into submitNewMarket; removed manual create market transaction updates.
- Fixed adjusted-maker-fee calculation in constructLogAddTxTransaction.
- Added gasFees field to trading transactions in constructRelayTransaction.
- Added missing arguments to cancel in contructRelayTransaction.
– The Augur Team
Augur Front-End Update – Jan 18th
Some quick updates from this past week, our current status was summarized quite well here on Reddit. We’ve gotten the team together this week to meet up and plan our roadmap for the following months. The front-end user interface is ready for security audits, with the remaining tasks revolving around re-skinning, and updating the middleware plumbing that interacts with it.
We are working on brining in two more people (one designer, and one on-boarding specialist) that used to work with Intrade / TradeSports. The timeline for a full launch is currently looking like this summer, with real money bug bounty markets coming a few months prior to that.
Joey did an interview with Automata, hosted by John Southurst and Daniel Carwey, talking about the 2017 plans for Augur and what’s to come. Be sure to check it out below!
New developments are happening every week, be sure to join us in Slack for the latest news, or to contribute to the community discussion
January 18, 2017
- A command queue and mutex is now used by ethrpc to handle multiple outgoing RPC requests during the initial socket (websocket or IPC socket) connection.
- Fixed a bug caused by over-zealous log-getter removal from augur.js.
January 17, 2017
- Expanded augur.js unit testing suite.
- Progress on the inline close position functionality in the UI.
January 16, 2017
- The market ID field in the marketCreated log is now indexed.
- Improved the efficiency of market price history lookups: the price history getter now looks up the market creation block first and uses this to set the lower-bound of the log lookup.
- Removed the “mutable” flag for createMarket and createSingleEventMarket from their static API data. The return values from these functions are no longer state-dependent, so they can be used directly.
- Moved the augur-contracts “errors” JSON file to the ethrpc repository, and updated augur.js to support this change. ethrpc is now independent of the augur-contracts module.
- Completed ethereumjs-connect refactoring.
- Replaced the ethereumjs-connect semi-functional integration tests with unit tests, resulting in significantly increased test coverage (from 68% to 98%).
- Updated augur.js connection code for compatibility with ethereumjs-connect 2.0.
- The augur-contracts module now attaches raw API data to its exported object.
January 15, 2017
- Started ethereumjs-connect refactoring.
- Eliminated ethereumjs-connect dependence on the augur-contracts module.
January 14, 2017
- Refactored sync-blockchain and separated sync methods from the update-blockchain action.
- Moved update-branch and sync-branch actions to the branch module.
- Restructured sync-branch tests: assertions, selectors, and state are now specified inside each test case.
January 13, 2017
- Fixed a trade ID formatting bug that was causing some trades to show up twice on the transactions page.
- All contracts have been reuploaded on Ropsten (network 3) as well as our private testing chain (network 9000). Transaction history is now “portable”: it will still be viewable even if you login on a different browser or computer!
- The upgraded transactions subsystem is now merged into the master branch!
- The bytes-to-utf16 conversion function in augur-abi now supports numeric inputs (BigNumber or JS numbers).
- Added a parity check to bytes_to_utf16 to fix a bytearray conversion error from augur-abi.
- Simplified loginWithMasterKey method in the augur.js accounts submodule, and removed placeholder (constant) salt/password/IV values.
January 12, 2017
- Indentation is now uniform (2 spaces) across the following repositories in the AugurProject Github group: augur, augur.js, augur-abi, augur-contracts, and ethrpc.
- Updated the default network ID from 2 to 3 across middleware repositories.
- The “price” field is now used as a fallback for “fullPrecisionPrice” for scalar price adjustments when the latter field is not present.
- Fixed messaging for maker of order taken by short sell transaction.
- Saved log.shares in transaction.data.shares for payout transactions.
- Used tradeCommitment for relayed short_sell order lookup.
- Removed memoization from selectWinningPositions.
- The addOrder function now works properly when the market order book is initially empty.
- Added an initial existence check to sent* logs-to-transactions conversions.
- Fixed an old reference to the “shares” property of a trade (should be “amount”) in the price history totals calculation.
January 11, 2017
- Changed the getOutcome and getUncaughtOutcome returns types in augur-contracts static API data to “number”.
- Added unfixReport conversion step to getMarket(s)Info callbacks in augur.js.
- Reporter assets are now updated prior to reporter-only synchronization with the blockchain state.
- Fixed penalizationCatchup NaN error.
- Split two oversized files in the transactions module (register-transaction-relay and convert-logs-to-transactions) into 3 smaller files each.
- All unit tests in the front-end are now compliant with the transaction relay (i.e., the new transactions subsystem).
– The Augur Team
Augur Front-End Update – January 26th
Skinning of the remaining front-end pages is underway. Our authentication system has been refactored and skinned, along with the footer and a few other pages around the app. The authentication system is receiving one more pass through this week, as this is a security critical part of the front-end (it engages with your private key). Our full testing suite will be pushed next week, which will cover all functions within AugurJS.
The front-end is making steady progress. We’ve pulled any lingering issues down from GitHub as we switched to an internal management board some time ago. A snapshot of the remaining front-end issues progress is pictured below:
We pushed a few updates regarding the
trading system and transactions, so please let us know if you see
anything out of the ordinary when placing orders or navigating
throughout Augur. Bug reports are best reported in our #betatesting channel on Slack.
The backend and contracts are still in their final phases before
audits, and we will keep everyone updated on the status of them.
Finally, if you’ve been thinking of getting a Ledger Nano S to secure your REP, we’ve published a guide on how to do so. Let us know if there are any remaining questions or parts you’d like to see expanded.
January 25, 2017
- Completed a simplification refactor to authentication views (Sign Up, Login, Import). Styling is in-process.
January 24, 2017
- Moved updateTradesInProgress trading actions post-processing to a new augur.js function, calculateTradeTotals.
- Moved placeTrade loop-thru-trading actions to new executeTradingActions function in augur.js.
- Added optional doNotMakeOrders parameter to executeTradingActions, placeTrade, placeBuy, placeSell, and placeShortSell functions.
- Fixed selectOrder references.
- Fixed isShortAsk parameter formatting in sell function.
January 23, 2017
- Increased augur.js unit test coverage by about 10%.
- Fix to a double header bug in OS X Safari when scrolling.
January 21, 2017
- augur.js minified build now works correctly.
January 19, 2017
- Moved (almost) all trading logic from UI to augur.js.
- Added license link to footer.
- Added popover text for long outcome names in market preview panels.
– The Augur Team
Some updates this week include the addition of snitching on reporters, a
Docker container, and the near completion of a new sign up / sign in
process. For snitching, if you know the report and salt of another user
during the commit phase of the current reporting cycle, you can snitch
on them and they will lose all their active Reputation. This is done to
make it as difficult as possible for reporters to collude with one
There is also an Augur Area 51 StackExchange
that needs 43 more followers, and 37 more questions with a score of 10
or higher to move to the next phase of its proposal. The proposal is for
Augur to have its own StackExchange, similar to the Ethereum one. All contribution is encouraged and appreciated!
January 31, 2017
- Added “snitch” tab to market detail page, where if you know the report and salt of another user during the commit phase of the current reporting cycle, you can snitch on the other reporter and they will lose all their active Reputation. (The reason for this is to make it as hard as possible for Reporters to collude with each other.)
- Added fixReport and extra parameters to slashRep wrapper.
- Attach eventID field to marketInfo object for getMarketInfo.
- Removed newafterrep field from penalize filter.
- Always call callback after checking close extra markets, even if market(s) already closed.
- Only show rep penalization in penalize logs.
- Added slash rep info to report-form component.
- Attached onSubmitSlashRep to market selector.
- Added branch parameter to market view.
- Added slash-rep action to reports module.
- Fixed scalar report entry instructions.
- Added loadMarketsInfo to claimProceeds callback.
- Fixed order type references.
- Fixed portfolio.openOrders type (side) references.
- Added cancel-open-orders-in-closed-markets action to user-open-orders module.
- Added cancelOpenOrdersInClosedMarkets action to claimProceeds.
- Attached openOrders property to portfolio selector.
- Added open-orders selector to user-open-orders module.
January 29, 2017
- Added useHostedNodeFallback prop, disable/enableHostedNodeFallback functions to ethrpc, and integrated these functions into the initial augur.js/ethereumjs-connect connection sequence. Hosted node fallback can now be disabled simply by setting “hostedNodeFallback” to false in the front-end env.json configuration file.
- Trade simulations feePercent is now always positive.
- Fixed addOrder when orderbook is empty.
- Adds Dockerfile and instructions.
- Added within-order remaining-cash/-shares decrease in relayed transaction messages.
January 28, 2017
- Added negative signs to bid/buy/shortSell simulated actions.
- Use static max value/amount for trade commit messaging.
- Fixed scalar price calculation in trade log transaction constructors.
- Fixed calculated trade amount for relayed buy trades in scalar markets.
- Reporting test setup time 900 for multi-user tests.
- Use send instead of sendFrom for cash (eth) transfers initiated by user.
- Fixed short-sell total cost calculated from logs.
- Return transaction array for short-sell relayed transactions.
- Separate trade (array) relay transaction handler from others.
January 27, 2017
- Fixed simulated short sell cost calculation.
- Added isShortSell=true to tradeCommitmentCallback in executeTrade.
- Added getOrderBookChunked method to modules/compositeGetters.
- Put default orderbook chunk size (100) into constants.js.
- Fixed short-sell total cost calculated from logs.
- Return transaction array for short-sell relayed transactions.
- Separate trade (array) relay transaction handler from others.
- Trade commitment isShortSell field distinguishes between sell and short-sell for relayed commitTrade transactions.
- Order existence check in select-order-book (fixes no-order error for 3rd party logs).
- Moved chunked getOrderBook logic from load-bids-asks to augur.js.
- Fixed trade log reprocessing error.
January 26, 2017
- Added chunking parameters to get_trade_ids; call increaseTagPopularity in modifyParticipantShares.
- Added tags contract to data_api with basic setters/getters for tag popularity.
- Fixed array concatenation in getTradingActions.
– The Augur Team
Augur Front-End Update – February 8th
The new login, sign up, and import account pages have been completed and merged this past week. This will allow for a significantly cleaner authorization process.
The new trading system on the contract end has been implemented, and removes a lot of complexity out of the UI/client. There are still a few remaining tasks to get through within the contracts before audits begin.
We’re also working on a new home page for the Augur app. Highlighted in detail on the February 3rd update by Jack, the first tag defined during market creation will now be the “primary tag” or “topic” for the market. The initial home page will be a display of the most popular tags, rather than a list of all markets. A rough sketch of what this will look like can be seen here.
This will improve the on-page performance with loading of the markets, allow for on-chain searching of the tags, and hopefully provide a more intuitive experience for users.
In my opinion, it is more intuitive than the landing page we have now. Users may not have a particular market they want to trade in when they come to Augur, but I think the vast majority will have a topic in mind: users that are interested trading politics are probably different overall than users that want to trade financials, or sports, etc. I further think that average volumes will probably be quite different between topics (e.g., financials might be an order of magnitude more popular than politics), and I think that a user interested in political markets might be turned off if the initial display was composed entirely of financial markets. “Oh, looks like just stocks and stuff,” they would think, and then leave. Similarly if the most popular markets happen to all be horse races, or sports, or celebrity gossip, etc. In short, I think a landing page structured around topics instead will be an overall improved UX for users that want to browse, or are not exactly sure of the market they want to use. (For reference, although the focus is of course somewhat different, bet365 is a good example of a site that first displays “topics” to users.) – Jack
Feel free to let us know your thoughts in our Slack!
February 7, 2017
- Renamed data_api/tags.se contract to data_api/topics.se and updated function names for “primary tag” to “topic”.
- The getTopicsInfo(Chunked) wrapper functions in augur.js now return objects (where the keys are topic names and values are popularities) instead of arrays. The topics selector in the front-end converts the stored topics object to a sorted array.
- Added sender address check to log_short_fill_tx listener.
- Added increase(Market)TopicPopularity actions and reducer; call increaseMarketTopicPopularity in fillOrder.
February 5, 2017
- The transaction relay in ethrpc now automatically adds the transaction hash the onFailed callback argument when it is available (usually only for transactions with mutable returns).
- Default hosted nodes in ethrpc are now (temporarily) using network 9000, due to severe congestion on Ropsten.
- Added placeAskAndShortAsk to placeSell sequence, to makeOrder, and to placeTrade sequence and tests.
- Trade and short-sell receipt parsing are now handled by dedicated methods in augur.js.
- The final trading callback for multi-action sequences now always fires at the correct time.
- Added logic to delete trade/short_sell transaction on empty trade to constructRelayTransaction. This fixes an error where sometimes simultaneous trades would both appear as “successful”, but only one trader would actually get the shares from the trade.
- Sell complete sets has been disabled in the front-end, since this will be handled automatically by the contracts in the (upcoming) updated contract version.
February 4, 2017
- Replaced orderBooks object with getOrderBooks function in placeTrade and subroutines.
- Added new modifyOrderBook module: makes local changes to order book.
- Fixed fullPrecisionPrice/price order in adjustScalarOrder.
- For orders filled by the user, call fillOrder in constructRelayTransaction instead of log_fill_tx callback.
- Refactored market order book updating functions: these functions now call to modifyOrderBook functions in augur.js, and replace the existing order book, instead of updating it.
February 3, 2017
- Report and Snitch tabs on market detail page now use isReportTabVisible market selector property to determine visibility.
- Reporting markets listing filter now works correctly.
- Scalar market outcome input box now displays correctly in the Snitch tab.
- The first tag defined during market creation is now the “primary
tag” or “topic” for the market. A new contract, data_api/tags.se, now
tracks the “popularity” of each tag, defined (for simplicity) as the sum
of the volume of all markets that share a particular primary tag. (This
crude metric will be fine-tuned through user testing.) The initial
landing page will be a display of the most popular tags, rather than a
list of all markets. Here is a sketch of what this will look like. There are a few advantages of this approach:
- The initial page load will be faster, since all markets will not be downloaded immediately.
- Tags are stored as “short strings” (i.e., normal 256-bit integers) on contract, so it is possible to search for them on-chain; that is, without first downloading all the tags either to the browser or to a persistent datastore. (Market/event descriptions, by contrast, are bytearrays that are not limited to 256 bits, so on-chain search is too slow to be practical.)
February 2, 2017
- Re-uploaded all Augur contracts to the Ropsten testnet (network 3) and our private test chain (network 9000).
February 1, 2017
- Added the ability to ‘close’ an existing market position. This action will determine if a position can be either fully or partially closed based on the current order book state and will attempt to do so at the best available price.
- Snitch (slashRep) messaging now displays correctly.
- Fixed reporterIndex reference in slashRep function.
- Fixed eventID reference in slashedRep log and added a timestamp.
- Added missing doNotMakeOrders and tradeCommitLockCallback arguments to placeShortSell from placeSell.
- Added arguments lengthcheck to the first if statement in augur.js bindContractMethod.
- Updated/removed expired events from “canned markets” list.
– The Augur Team
Augur Front-End Update – February 15th
The new home page sketched last week is being finished up. While there are still some styling changes to be made, Sprinkle has given us a preview below:
Each market will have a main topic used for categorization. Markets will load for each individual topic as they’re viewed, in comparison to loading every market on the main page. This will enhance Augurs performance & speed.
The authentication code has been refactored, removing any interaction with private keys in the client. This reduces the surface area of code that needs to be audited within the UI.
Our StackExchange proposal has moved onto the next phase, Commitment, where we will need 100 users with 200+ reputation committing to Augur. After the this phase, we move into our own public beta. Suggestions for building reputation are posting in the BitcoinEthereum, and Monero exchanges.
As always, join our Slack with any questions!
February 15, 2017
- Markets that are in the process of being loaded now are flagged with an “isLoading” property, to avoid duplicate get-market-info requests to augur.js.
- Removed unused selectedOutcome selector, action, and reducer.
- Fixed derived key references in the front-end.
- Refactored report-encryption module and added unit tests.
February 14, 2017
- Refactored the register module in augur.js and removed its unused methods.
- Moved checkPeriodLock to syncReporterData.
- Fixed in-progress relay display.
- Removed unused fundNewAccount callback from loadAccountData.
- Added loadRegisterBlockNumber action to fundNewAccount callbacks.
- Used displayLoginMessageOrMarkets in init-augur.
February 13, 2017
- Added enum like construct for current RPC status. This should improve readability by removing the magic numbers, without breaking backwards compatibility.
- Added docker support. This makes it so the tests can be run inside docker, to minimize local environment and compatibility issues and allow for turn-key development. The readme has been updated with instructions on how to run the tests from inside Docker.
- Update loginAccount during setupAndFundNewAccount to avoid UI side effects.
- Fixed loadAccountDataFromLocalStorage position in loadAccountData sequence.
- Use loginAccount state instead of account parameter in display-login-message.
- Consolidated fundNewAccount calls in loadAccountData; split functions in load-account-data into separate files.
- Removed conditional fundNewAccount/registerTimestamp callbacks from login, register, login-with-airbitz, and import-account actions.
- fundNewAccount action no longer accepts a callback.
- Expanded augur.Register.register wrapper and renamed to loadRegisterBlockNumber.
- Moved savePersistentAccountToLocalStorage to new save-persistent-account auth action.
February 12, 2017
- Updated check-filters script.
- Combined loadFullAccountData and loadLoginAccountDependents functions.
- Fixed sentCash event label in the front-end listeners.
February 11, 2017
- Fixed manage Airbitz account button display.
- Refactored loadLoginAccount in auth module.
- Cleanup of auth cruft in components.
February 10, 2017
- Removed “name” from importAccount, login, and register actions / augur.js calls.
- Fixed importAccount loginID.
- Replaced loginID argument of login with keystore. Removed loginID and name properties from account object.
- Renamed loadLocalLoginAccount to setAccountObject in augur.js.
- Removed unused onSubmitClosePosition prop from market selector.
- Refactored import-account.
- Fixed keystore reference in account export.
- Removed extra base58Encode.
- Fixed loginID calculation argument.
- Fixed loadFullAccountData error message.
- Refactored login action; moved displayLoginMessageOrMarkets and loadFullAccountData to load-login-account.
- Refactored load-login-account actions for augur.js/loginAccount data split.
- Set height for mobile logo.
- Removed account-settings (no longer contains relevant properties).
February 9, 2017
- Added on-chain topic search to augur.js.
- Added topic (first tag) as an indexed parameter to the marketCreated event on the createMarket contract.
- Updated account references in loadLoginAccountDependents.
- Refactored register actions in auth module.
- Removed duplicate data in state.loginAccount and augur.accounts.account in augur.js.
February 8, 2017
- Fix to account registration action that was causing initial funding to fail.
– The Augur Team
The new landing page for the main app has been completed and deployed!
Markets are sorted by popularity, and market creators set a main topic
used for categorization. Additional market tags are used as optional
keywords during search.
A bunch of tasks have been cleaned up this week (detailed below), along with the addition of Google Translate. Google is employing neural machine translation this year with translate, and translation is expected to get significantly better. More details can be read here.
We’re working on updating the Augur.net landing page, as well as the implementation of ShapeShift for deposits / withdraws and the Coinbase buy button for Bitcoin and Ether. Our testing suite is nearing 88% coverage, progressing week over week. Joey is finishing up writing tests for the backstops, along with other final tasks around the contracts.
Join our SlackStackExchange proposal
February 22, 2017
- Refined the build process for augur + reduced the overall build weight via removal of unneeded fonts.
February 21, 2017
- The formatTag function in augur.js now trims whitespace from tags before converting to int256.
- Fixed checkbox component check icon.
- Fixed thumbs-down icon on transactions page.
- Removed updateTopicPopularity action from marketCreated listener callback.
- Fixed market link in create market transaction display.
- Google Translate is now integrated with the front-end.
- Topics and tags are now displayed as-is in the front-end (no trimming or forced case changes).
- Market creation now separates “topic” (first tag; required) and “keywords” (other tags).
- Resolved issue related to the display of icons on the topics view.
February 20, 2017
- The formatTag function in augur.js now trims whitespace from tags before converting to int256.
- The loadEventsWithSubmittedReport action has been entirely removed, as the data loaded was duplicated by loadReportingHistory. The transaction constructors invoked by loadReportingHistory now populate the eventsWithSubmittedReport data store.
- Icofonts are now available for use in the front-end, in addition to the font-awesome icons.
- Fixed topics page redirect.
- Multi-case topic strings are now handled correctly.
- “Hero” topics now have the same font size as other topics on mobile.
- Updated market creation to require a ‘Topic’. Keywords are still optional.
February 19, 2017
- Fixed order book generation in canned-markets script.
- Initial refactoring of ethrpc to add proper unit tests (with TestRPC) and robust websocket / IPC socket reconnection.
- Added websocket support to TestRPC.
- Added motion design for when a topic’s volume has either increased or decrease.
- Constrained width of topics view.
February 18, 2017
- The automatic order book generation function “generateOrderBook” in augur.js now works correctly.
- Edited the topics and keywords for “canned markets” so they are reasonably good examples.
- Added more icon-topic associations to the front-end.
February 17, 2017
- The default “landing page” for the Augur app is now the Topics page! Instead of displaying all markets, the user is now greeted with a list of topics (such as Politics, Science, Sports, etc.) which are sorted by popularity. Clicking on a topic brings up all markets with that topic. (The user can still browse all markets simply by clicking on “Markets” in the navbar.)
- Report commit locks are now indexed by event ID.
- Market volume is now subtracted from topic popularity when the market closes.
February 16, 2017
- Added report-commit-lock to avoid double report submission.
- Fixed market-without-description error during new market creation.
- Updated createEvent, createMarket, createSingleEventMarket labels to match augur-core, and relabeled branchId to branchID in getMarket(s)Info object.
- Markets no longer have a description separate from their underlying event description.
- Updated “unfixReport” to “unfixRawReport” in several places in the UI to match augur.js.
- The loadMarketsInfo/loadAccountTrades loop post-claimMarketsProceeds now works correctly.
- Reported outcome is now calculated correctly for scalar/categorical events for both log-lookups and “big getter” lookups.
- Split unfixReports into unfixRawReports, unfixReports, isIndeterminateReport, and isScalarSpecialValueReport.
- Fixed register block number lookup in augur.js.
– The Augur Team