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.

Low fees

Augur's fees are set by users, and are vastly lower compared to traditional trading and betting platforms.

Crowdsourced reporting

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

UI Engineer

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 onSlack in the channel #betatesting.

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.

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.

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.

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

Technical updates:

November 30, 2016

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.

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.

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 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.

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.

Security Reminder:

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.

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]

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.

December 9, 2016

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.

# 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

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

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.

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.

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.

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.

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.

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 15, 2017

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!

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.

Augur Front-End Update – February 1st

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 another.

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!

Technical updates:

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.

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.

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!

Technical Updates:

February 7, 2017

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.

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.

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

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.

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!

Technical Updates:

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.

February 8, 2017

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.

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.

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.

Augur Front-End Update – March 1st

We’re working on finishing up the re-skin
of the create market pages this week. Our testing suite is nearing 95%
coverage, and expect this to be finished up in the next few weeks. The
new landing page has also been receiving some good feedback, and we encourage you to send us your thoughts.

Our remaining front-end issues are
slimming down, with majority of the remaining tasks being related to
skinning. Our standalone Ethereum key management library, keythereumKeythereum
is a small, isolated, but important piece of code – so it seemed like a
natural place to start our audits. We’ll be expanding the audit to
include the contracts and the other relevant parts of the middleware
over the coming weeks.

Joey wrapped up some miscellaneous bugs
this week, along with the addition of a function allowing more trades to
be executed on-chain with backup trades if some were already filled.
Also, instead of having to commit to specific orders, you now just
commit to a market, outcome, or direction while doing the trade commit
and reveal. He will be also speaking at the MIT Bitcoin Expo next week, so be sure to say hi if you’re in the area!

Augur Front-End Update – March 15th

You will be able to preview your market
in real time, and view the order book as you enter the initial
liquidity. As creating a market is one of our core features, we felt is
was important to spend extra time on this process to ensure its user
experience. Let us know what you think, and keep an eye out for it on
the main app within the next few days!

We finished changes to Ethrpc and
integrated them into Augur. Ethrpc is now more resilient to running in
adverse conditions when nodes come and go. It also now does a better job
at sticking to one Ethereum node, rather than jumping around at
runtime. We’ve been working with a new developer, Micah, to improve our
core infrastructure and reliability.

Our StackExchange proposal is now at 55%! Please share it with your friends, and help us have our own StackExchange by launch.

HOW TO CREATE A GOOD MARKET ON AUGUR

In Augur, there are three different types of markets that can be created – binary (yes/no), multiple choice, and scalar. While anyone can create a market on Augur, it’s important to put the time and effort in learning how to create a goodmarket on Augur.

Event Question

Augur Development Update – April 12th

Most of the past week has been spent
adding & updating tests for transaction actions, as well as updating
Keythereum with the feedback we’ve received from auditors. Keythereum’s
audit will be complete this week, and we will have a post-mortem
summary for next weeks update.

The Legder plumbing has been built, and
the UI integration will be worked on this week. You will be able to use
your Ledger to log into Augur and insure your REP/ETH are stored
securely. Next on the integration task list is uPort, and the
transactions display for re skinning.

We’re working on updating our FAQ and making a new Reddit megathread, and fielding feedback / opinions here. Please let us know if there is anything specific you want covered.

Current checklist for the upcoming few
weeks is to have the remaining middle wear audited (ethrpc, etc), and
get the contracts shipped off to be looked at. You can follow the
development of the code review for the contracts on the augur-core develop branch. All the audits will have a summary upon completion with the findings and fixes from our auditors.

Technical Updates:

April 11, 2017

Added basic Legder support (no UI) – all the main plumbing.

Fixed bug in market payouts in augur-core.

Miscellaneous fixes from code reviewing in augur-core.

April 10, 2017

Added tests for loadDataForReportingTransaction action.

Cleaned up remaining links to the welcome view title.

Added unroll_array function in augur-abi.

April 9, 2017

Fixed import paths in augur.js.

Added unit tests for filters/add-filter in augur.js.

Moved to using redux for handling state in augur.js – redux-style store without redux.

Use buffer to concatenate in encrypt / decrypt, both now return buffers in keythereum.

Augur Development Update – May 17th

Most of the past weeks progress has been
around reviewing the contracts. New features are not being added right
now, tests are being written and unnecessary / complex features are
being removed. A write up will be coming with the completion of this
review. The trading contracts will be the first contracts ready to be
audited.

Testing for the Augur client is complete
and the security sensitive parts are next on the list to have audited.
SmartContractSolutions has a team of engineers that started this past
Monday on reviewing and trying to break the Ethereum Serpent compilersticked Reddit thread for a log of the major remaining tasks and auditing progress.

The account page re skin is still underway, with further updates this upcoming week.

A reminder that Joey is speaking at
Consensus and TokenSummit next Tuesday and Thursday, try and catch his
panels if you’re attending! Reach us below if you have any questions, or
would like to contribute.