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
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.
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.
- 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
- Converted indeterminate constants to BigNumbers; updated comparisons in fix/unfixReport.
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