Overview

Augur is a decentralized prediction market platform that runs on Ethereum. For a detailed, high-level explanation of how Augur works, please refer to the Augur whitepaper.

If you want to use or help test Augur, please install the Augur App. If you want to use our cutting-edge development client, this is maintained at https://dev.augur.net. However, be warned – we push changes here pretty rapidly, so it can be a bit buggy!

Augur has its own dedicated Stack Exchange, which allows anyone to ask questions about Augur and get answers to those questions. It’s a great resource to find the answers for questions you might have that aren’t answered directly in these documents. Additionally, you can chat with us on Discord. If you’d like to join the conversation, just go to invite.augur.net and sign up. Most questions are best asked in the #dev or #general channels.

Getting Started

If you would like to help develop Augur, you’ll need to build the client from source. To do this, first install version 8 of Node.js (note that the version number is important), and Git.

Next, clone the Augur UI GitHub repository by opening a terminal window and typing:

$ git clone https://github.com/AugurProject/augur-ui.git

Navigate to the newly created augur-ui folder by running:

$ cd augur-ui

Once this has been done, Augur’s dependencies will need to be installed. This can be done using npm or yarn. Both methods are detailed in the next sections.

If you plan on submitting a pull request to the Augur Project, please be sure to read through the Contributing section of these documents before submitting the request.

Using NPM

Node.js comes with a built in package manager called npm. (Again, please note that version 8 of Node.js is required for Augur.) npm is used to install dependencies for Augur, build the Augur project from source code, run tests, and start a web server to host Augur, among other things. To install Augur’s dependencies using npm, run the following command:

$ npm install

To build Augur from the source code, run:

$ npm run build

After building Augur from the source files, a local web server will need to be started. This can be done using the following command:

$ npm start

To enable hot-reloading (which automatically loads changes made locally), run the following instead of npm start:

$ npm run dev

Doing this is an easy way to do some hacking on the Augur source code and see the changes reflected in real time.

Now open a web browser and go to http://localhost:8080. This should load Augur’s most popular categories page.

Congratulations, you’re ready to start hacking!

Using Yarn

Some people prefer to use yarn instead of npm. To use yarn, execute the following command to install the Augur dependencies:

$ yarn

To build Augur from the source code, run:

$ yarn build

After building, the following command will start a local web server:

$ yarn start

To enable hot-reloading for development purposes, run the following instead of yarn start:

$ yarn dev

Finally, open a web browser and go to http://localhost:8080. This should load Augur’s most popular categories page.

Congratulations, you’re ready to start hacking!

Architecture

Augur is designed to work with a locally-running Ethereum node; however, if one is not available, Augur can be configured to use a hosted Ethereum node instead. A hosted Ethereum node is one that is hosted on a public server by the Augur development team. The sections below explain a bit about each setup and provide a diagram of what’s going on under the hood.

Local Ethereum Node

Running a local Ethereum node, such as Geth, while using Augur provides the best performance and overall experience. This is because Augur sends RPC requests to a hosted Ethereum node takes more time than sending them to a local node. To use a local Ethereum node with Augur, either download and run the Augur app locally, or simply visit https://dev.augur.net, which is configured to automatically talk to a local node, if present.

Note to Geth users: Since Geth’s RPC server uses regular (unencrypted) HTTP, the Augur app must also use regular HTTP to communicate with a local Geth node.

Hosted Ethereum Node

Since many users may not wish to go to the trouble of running a full Ethereum node solely to use Augur, the Augur development team maintains a public Ethereum node on the Rinkeby test network at rinkeby.ethereum.nodes.augur.net, which is used automatically by https://dev.augur.net.

Trading

Augur allows anyone to create an openly tradable Market about any upcoming event. Augur maintains an Order Book for each of the Markets created. Any trader can place or take an Order on the Market’s Order Book. When placing a trade, that trade request will be Filled immediately if there is an Order on the Order Book that will fulfill it. If there is no matching Order, or if the trade request can only be partially Filled, the remainder of what wasn’t filled of the trade will be placed on the Order Book as an Order. Order Creators may cancel their Order to remove it from the Order Book. Orders are executed on a “first come, first served” basis.

The Augur UI offers users the best prices first when displaying the Order Book on each Market page. Orders are never executed at a worse price than the limit price set by the trader, however they can settle for better than the limit price. Orders can also be partially filled. The UI will automatically include multiple backup/fallback Orders to attempt to fill the Order in the event that the best Order was filled before the transaction was sent. These backup/fallback Orders are always within the limit price set by the trader.

Trading Example

Let’s use an example Yes/No Market trading on the “super big event” coming up. For this example, we want to go long on Yes. We would submit a trade request to buy 100 Shares of Yes with a limit price of 0.5 ETH, which will cost 50.0 ETH plus gas used to send the transaction.

If there are Orders on the Order Book that match our request for 100 Shares of Yes at a price of 0.5 ETH, or cheaper, then Augur will fill those Orders. We will now own 100 Shares of Yes and we will have lost 50.0 ETH plus gas cost.

If no Order is available on the Order Book that would partially or completely fill our trade request then a Bid Order would be placed on the Order Book. Whenever an Order is placed on the Order Book something of value is escrowed by the Market. In our example, the value we are giving to the Market to place our bid would be our 50.0 ETH. If we were attempting to sell Shares that we currently owned then we would escrow the Shares instead of ETH. If we cancel our Order we can get our 50.0 ETH back, the only currency lost would be the gas used to pay to place the trade and cancel the trade. When a Filler decides to fill our Order on the Order Book, we will get our 100 shares of Yes transferred to us.

For more information on how to trade using the Augur API, check the trade section of the Transaction API.

Settlement Fees Explained

Creating a Market costs a small amount of ETH. Without some incentive people won’t create Markets as they get nothing in return for the ETH they spent to create it. Augur solves this problem by allowing Market Creators to set a Creator Fee for their Market. The Creator Fee must be between 0 and 50 percent, and cannot be changed once a Market is created. In addition to the Market Creator Fee, Market Creators can profit via spread by providing liquidity to the Markets they create.

Augur also extracts Fees to help support the Reporting System known as the Reporting Fee. Settlement Fees refer to both the Creator Fee and the Reporting Fee combined. Unlike the Creator Fee, the Reporting Fee isn’t set by the Market Creator. Instead, it is set by an off-Augur price feed. Once the REP price is known, Augur can calculate the REP Market cap and the appropriate Reporting Fee to ensure the security of the Reporting System.

The Augur contracts will track the Open Interest of all Markets passively as people interact with Augur, which allows Augur to always have access to the Open Interest numbers. Once the Open Interest and REP market caps are known Augur can then determine wether the Reporting Fee is too high or too low. Augur then calculates the new Reporter Fee using the following formula:

current_reporting_fee * (augur_open_interest * 7.5 / rep_market_cap)

The Reporting Fee will be updated once every 7 days, or once every Fee Window. If updates were to occur too frequently, the Market will not have time to adjust to the new fees. If we update too infrequently, then we are at risk of the security model becoming invalid due to a sudden growth in Augur that isn’t yet accounted for by the fee system.

Settlement Fees are extracted anytime Settlement occurs and Shares are destroyed. This can happen for two reasons:

• Selling a Complete Set
• Redeeming shares for the finalized outcome in a Finalized Market

Selling a Complete Set can be thought of as exiting your market Position. Complete Sets are a set of Shares for each Outcome. Complete Sets are priced differently for each Market, and are determined by the Number of Ticks, which represents all possible price points, or Ticks, for a Market as well as the amount of attoETH it costs to purchase a Complete Set for the Market. If you own a set of Shares in each Outcome, you can Settle those Shares and receive ETH back for their value minus Settlement Fees.

Calculating Trades

In this section we break down all potential trade situations and their expected result. There are two types of Orders, Bid Orders (requesting to buy) and Ask Orders (requesting to sell). In our examples below we will go over all the potential trade possibilities around Bid Orders and Ask Orders. Orders are placed on the Order Book by Order Creators and contain four important details: The Creator of the Order, the price of the Order, The amount of Shares or ETH escrowed, and the Outcome we plan to trade on. The price can be any value between 0 and the Number of Ticks. The calculations below use num_shares as the number of Shares the Order is requesting, price as the price per Share for the Order, outcome for the Outcome our Order is trading on, num_ticks as the Number of Ticks, and fee_rate as the Settlement Fees extracted during the Settlement of Shares.

The Formulas for determining how much opening a Long Position or Short Position costs are as follows:

Cost of Opening a Long Position(open_long_position_cost):

num_shares * price

Cost of Opening a Short Position(open_short_position_cost):

num_shares * (num_ticks - price)

The formulas for determining the payout and the fees required to be paid by each side of an Order are as follows:

Total payout for closing a Long Position(total_payout_closing_long):

num_shares * price / num_ticks

Total payout for closing a Short Position(total_payout_closing_short):

num_shares * (num_ticks - price) / num_ticks

Fees paid for closing a Long Position(long_position_fees):

total_payout_closing_long * fee_rate

Fees paid for closing a Short Position(short_position_fees):

total_payout_closing_short * fee_rate

Below are some more examples of specific order situations and their results:

Bid Order Trading

Ask Order Trading

Reporting

Once a Market’s underlying event occurs, the Outcome must be determined in order for the Market to Finalize and begin Settlement. Outcomes are determined by Augur’s Decentralized Oracle, which consists of profit-motivated Reporters, who simply report the actual, real-world Outcome of the event. Anyone who owns REP may participate in the Reporting and Disputing of Outcomes. Reporters whose Reports are consistent with consensus are financially rewarded, while those whose Reports are not consistent with consensus are financially penalized.

Fee Windows

Augur’s reporting system runs on a cycle of consecutive 7-day long Fee Windows. A Reporting Fee collected by Augur during a given Fee Window are added to the Reporting Fee Fee Pool for that Fee Window. At the end of the Fee Window, the Reporting Fee Pool is paid out to REP holders who participated in that reporting process. Reporters receive rewards in proportion to the amount of REP they Staked during that Fee Window. Participation includes: Staking during an Initial Report, Disputing a Tentative Outcome, or purchasing Participation Tokens.

Participation Tokens

During any Fee Window, REP holders may purchase any number of Participation Tokens for an equivalent amount of REP. At the end of the Fee Window, they may redeem their Participation Tokens for the same amount of REP, plus a proportional share of the Fee Window’s Reporting Fee Pool. If there were no actions (e.g., submitting a Report or Disputing a Report submitted by another user) needed of a Reporter, the Reporter may purchase Participation Tokens to indicate that they showed up for the Fee Window. Just like Staked REP, Participation Tokens may be redeemed by their owners for a pro rata portion of fees in this Fee Window.

It is important that REP holders are ready to participate in Market resolution in the event of a Fork. The Participation Token provides an incentive for REP holders to monitor the platform at least once per week, and, thus, be ready to participate if the need arises. Even REP holders who do not want to participate in the reporting process are incentivized to check in with Augur once per 7-day Fee Window in order to buy Participation Tokens and collect fees. This regular, active checking in will ensure that they will be familiar with how to use Augur, will be aware of Forks when they occur, and thus should be more ready to participate in Forks when they happen.

Market State Progression

Augur Markets can be in seven different states after creation. The potential states, or “phases”, of an Augur Market are as follows:

• Pre-Reporting
• Designated Reporting
• Open Reporting
• Waiting for the Next Fee Window to Begin
• Dispute Round
• Fork
• Finalized

The relationship between these states can be seen in the figure below:

Pre-Reporting State

The Pre-Reporting or trading phase is the time period that begins after trading has begun in the Market, but before the Market’s event has come to pass. Generally, this is the most active trading period for any given Augur Market. Once the event end date has passed, the Market enters the Designated Reporting Phase (state a in the figure above).

Designated Reporting State

When creating a Market, Market Creators are required to choose a Designated Reporter and post a No-Show Bond. During the Designated Reporting Phase (state a in the figure above), the Market’s Designated Reporter has up to three days to Report on the Outcome of the event. If the Designated Reporter fails to Report within the allotted 3 days, the Market Creator forfeits the No-Show Bond, and the Market automatically enters the Open Reporting Phase (state b in the figure above).

If the Designated Reporter submits a Report on time, then the No-Show Bond is returned to the Market Creator. The Designated Reporter is required to post the Designated Reporter Stake on its Reported Outcome, which it will forfeit if the Market finalizes to any Outcome other than the one they Reported. As soon as the Designated Reporter submits its Report, the Market enters the Waiting for the Next Fee Window to Begin Phase (state c in the figure above), and the Reported Outcome becomes the Market’s Tentative Outcome.

Open Reporting State

If the Designated Reporter fails to Report within the allotted 3 days, the Market Creator forfeits the No-Show Bond, and the Market immediately enters the Open Reporting Phase. As soon as the Market enters the Open Reporting Phase, anyone can report the Outcome of the Market. When the Designated Reporter fails to Report, the first Reporter who Reports on the Outcome of a Market is called the Market’s First Public Reporter.

The Market’s First Public Reporter receives the forfeited No-Show Bond in the form of Stake on their chosen Outcome, so they may claim the No-Show Bond only if their Reported Outcome agrees with the Market’s Final Outcome.

The First Public Reporter does not need to Stake any of their own REP when Reporting the Outcome of the Market. In this way, any Market whose Designated Reporter fails to Report is expected to have its Outcome reported by someone very soon after entering the Open Reporting Phase.

Once an Initial Report has been received from the Initial Reporter (whether it was the Designated Reporter or First Public Reporter), the Reported Outcome becomes the Market’s Tentative Outcome, and the Market enters the Waiting for the Next Fee Window to Begin Phase (state c in the figure above).

Waiting for the Next Fee Window to Begin State

Once the market receives its Initial Report it enters the Waiting for the Next Fee Window to Begin Phase (state c in the figure above). During this phase, Reporting for the Market is on hold until end of the current Fee Window. Once the next Fee Window begins, the Market enters the Dispute Round Phase.

Dispute Round State

The Dispute Round (state d in the figure above) is a 7-day period, during which any REP holder has the opportunity to Dispute the Market’s Tentative Outcome. (At the beginning of a Dispute Round, a Market’s Tentative Outcome is the outcome that will become the Market’s Final Outcome if it is not successfully disputed by REP holders.) A Dispute consists of Staking REP (referred to as Dispute Stake in this context) on an Outcome other than the Market’s current Tentative Outcome. A Dispute is successful if the total amount of Dispute Stake on some Outcome meets the Dispute Bond size required for the current round. The Dispute Bond sizes are chosen in such a way to ensure a fixed ROI of 50% for Reporters who successfully dispute false Outcomes. Details for how the Dispute Bond size is computed can be found in the Dispute Bond glossary entry.

The Dispute Bonds need not be paid in their entirety by a single user. The Augur platform allows participants to crowdsource the Dispute Bonds. Any user who sees an incorrect Tentative Outcome can Dispute that Outcome by Staking REP on some Outcome other than the Tentative Outcome. If any Outcome (other than the Tentative Outcome) receives enough Dispute Stake to fill its Dispute Bond, the current Tentative Outcome will be successfully Disputed.

In the case of a successful Dispute, the Market will either undergo another Dispute Round or it will enter the Fork Phase (state e in the figure above). If the size of the filled Dispute Bond is greater than the Fork Threshold, then the Market will enter the Fork Phase. If the size of the filled Dispute bond is less than the Fork Threshold, then the newly chosen Outcome becomes the Market’s new Tentative Outcome, and the Market undergoes another Dispute Round.

All Dispute Stake is held in escrow during the Dispute Round. If a Dispute Bond is unsuccessful, then the dispute Stake is returned to its owners at the end of the Dispute Round. If no Dispute is successful during the 7-day Dispute Round, the Market enters the Finalized State (state f in the figure above), and its Tentative Outcome is accepted as the Final Outcome. A Market’s Final Outcome is the Tentative Outcome that passes through a dispute Round without being successfully Disputed, or is determined via a Fork. Augur’s contracts treat Final Outcomes as truth and pay out accordingly.

All unsuccesful Dispute Stake is returned to the original owners at the end of every Dispute Round. All successful Dispute Stake is applied to the Outcome it championed, and remains there until the Market is Finalized (or until a Fork occurs in some other Augur Market). All Dispute Stake (whether successful or unsuccessful) will receive a portion of the Reporting Fee Pool from the current Fee Window.

Fork State

The Fork Phase is a special state that lasts up to 60 days. Forking is the Market resolution method of last resort; it is a very disruptive process and is intended to be a rare occurrence. A Fork is caused when there is a Market with an Outcome with a successfully filled Dispute Bond of at least 2.5% of all REP. This Market is referred to as the Forking Market.

When a Fork is initiated, a 60-day Forking Period begins. Disputing for all other non-Finalized Markets is put on hold until the end of this Forking Period. The Forking Period is much longer than the usual Fee Window because the platform needs to provide ample time for REP holders and service providers (such as wallets and exchanges) to prepare. A Fork’s Final Outcome cannot be Disputed.

Every Augur Market and all REP tokens exist in some Universe. REP tokens can be used to Report on Outcomes (and thus earn fees) only for Markets that exist in the same Universe as the REP tokens. When Augur first launches all Markets and all REP will exist together in a Genesis Universe.

When a Market Forks, new Universes are created. Forking creates a new Child Universe for each possible Outcome of the Forking Market (including the Invalid Outcome). For example, a Yes/No Market has 3 possible Outcomes: A, B, and Invalid. Thus a Yes/No Forking Market will create three new Child Universes: Universe A, Universe B, and Universe Invalid. Initially these newly created Universes are empty: they contain no Markets or REP tokens.

When a Fork is initiated, the Parent Universe becomes permanently Locked. In a Locked Universe, no new Markets may be created. Users may continue trading Shares in Markets in Locked Universes, and Markets in a Locked Universe may still receive their Initial Reports. However, no Reporting rewards are paid out there, and Markets in Locked Universes cannot be Finalized. In order for Markets or REP tokens in the Locked Universe to be useful, they must first be migrated to a Child Universe.

Holders of REP tokens in the Parent Universe may migrate their tokens to a Child Universe of their choice. This choice should be considered carefully, because migration is one-way; it cannot be reversed. Tokens cannot be sent from one sibling Universe to another. Migration is a permanent commitment of REP tokens to a particular Market Outcome. REP tokens that migrate to different Child Universes ought to be considered entirely separate tokens, and exchanges ought to list them as such.

When a Fork is initiated, all REP Staked on all non-Forking Markets is unstaked so that it is free to be migrated to a Child Universe during the Forking Period.

Whichever Child Universe receives the most migrated REP by the end of the Forking Period becomes the Winning Universe, and its corresponding Outcome becomes the Final Outcome of the Forking Market. Un-Finalized Markets in the Parent Universe may be migrated only to the Winning Universe and, if they are un-Finalized and have received an Initial Report, are reset back to the Waiting for the Next Fee Window to Begin Phase.

There is no time limit on migrating tokens from the Parent Universe to a Child Universe. Tokens may be migrated after the Forking Period, but they will not count towards the determination of the Winning Universe. To encourage greater participation during the Forking Period, all token holders who migrate their REP within 60 days of the start of a Fork will receive 5% additional REP in the Child Universe to which they migrated. This reward is paid for by minting new REP tokens.

Reporters that have Staked REP on one of the Forking Market’s Outcomes cannot change their position during a Fork. REP that was Staked on an Outcome in the Parent Universe can be migrated only to the Child Universe that corresponds to that Outcome. For example, if a Reporter helped fulfill a successful Dispute Bond in favor of Outcome A during some previous Dispute Round, then the REP they have Staked on Outcome A can only be migrated to Universe A during a Fork.

Sibling Universes are entirely disjoint. REP tokens that exist in one Universe cannot be used to Report on events or earn rewards from Markets in another Universe. Since users presumably will not want to create or trade on Markets in a Universe whose Oracle is untrustworthy, REP that exists in a Universe that does not correspond to objective reality is unlikely to earn its owner any fees, and therefore should not hold any significant market value.

Therefore, REP tokens migrated to a Universe which does not correspond to objective reality should hold no market value, regardless of whether or not the objectively false Universe ends up being the Winning Universe after a Fork.

Recall from the section on the Dispute Round State that any Stake successfully disputing an Outcome in favor of the Market’s Final Outcome will receive a 50% ROI on their Dispute Stake.

In the event of a Fork, any REP Staked on any of the Market’s false Outcomes should lose all economic value, while any REP Staked on the Market’s true Outcome is rewarded with 50% more REP (via newly minted REP) in the Child Universe that corresponds to the Market’s true Outcome (regardless of the Outcome of the Fork). Therefore, if pushed to a Fork, REP holders who Dispute false Outcomes in favor of true Outcomes will always come out ahead, while REP holders who Staked on false Outcomes will see their REP lose all economic value.

Finalized State

A Market enters the Finalized State (state f in the figure above) if it passes through a 7-day Dispute Round without having its Tentative Outcome successfully Disputed, or after completion of a Fork. The Outcome of a Fork cannot be Disputed and is always considered final at the end of the Forking Period. Once a Market is Finalized, traders can Settle their Positions directly with the Market. When a Market enters the Finalized State, we refer to its chosen Outcome as the Final Outcome.

Designated Reporting Details

During the creation of a Market, a Market Creator must assign a Designated Reporter. Designated Reporting is designed to be a quick way to bring about a Market Resolution. This is pleasing to Traders who want to Settle their Shares and collect their earnings as soon as possible after a Market’s End Time has passed. The Designated Reporting Phase begins immediately following the End Time of a Market. The result of Designated Reporting is still Challengeable with a Dispute Bond so if the Designated Reporter does incorrectly Report the Outcome of the Market, it can be adjudicated by Dispute Rounds. With the dispute system in place, we don’t actually lose any security or truth as an incorrect Tentative Outcome for a Market can be Challenged.

The Designated Reporting Phase lasts a maximum of three (3) days and ends immediately when the Designated Reporter submits their Report and the Tentative Outcome is set for the Market.

If the Designated Reporter fails to Report within the Designated Reporting Phase, the Market Creator forfeits the No-Show Bond, and the Market is moved into the Open Reporting Phase. The No-Show Bond is then used to add to the REP Staked by the First Public Reporter.

If the Designated Reporter does successfully Report within the Designated Reporting Phase, the No-Show Bond is refunded to the Market Creator immediately and the Market enters the Dispute Round Phase, which lasts for seven (7) days. During this 7-day period, any REP holder can Stake REP on an outcome other than the Tentative Outcome and receive a proportionate amount of Participation Tokens in return. The Participation Tokens allow the holder to collect fees at the end of the current Fee Window. The Staked REP goes toward filling the Dispute Bond for the Outcome on which it was Staked. If that outcome gets enough REP Staked on it to fill the Dispute Bond size, that Outcome becomes the new Tentative Outcome, and the Market returns to the Waiting for the Next Fee Window to Begin Phase (or Forks if the Outcome gets more than the Fork Threshold Staked on it). If the Market is left unchallenged for the duration of the Dispute Round Phase, then the Market’s Tentative Outcome becomes the Final Outcome and the Market is considered Finalized, allowing the Settlement of Shares.

Fee Window Details

Fee Windows continually occur and last for seven (7) days. During a Fee Window, any REP holder is able to Stake REP on any Outcome other than the Tentative Outcome. By doing so, they receive an equal number of Participation Tokens in return, and the REP they Stake goes toward to a Dispute Bond to Challenge the Tentative Outcome of the Market. In order to earn fees as a REP holder in the current Fee Window, users need to participate in the Market’s Dispute Round in some way, such as submitting a Designated Report or First Public Report, Disputing the Tentative Outcome (i.e., staking on an outcome other than the Tentative Outcome), or simply purchasing Participation Tokens directly.

Any fees collected by Augur during a given Fee Window are added to a Reporting Fee Pool for that Fee Window. The Reporting Fee Pool is used to reward REP holders who participate in Augur’s reporting process. At the end of the Fee Window, the Reporting Fee Pool is paid out to holders of Participation Tokens in proportion to the Staked REP they hold.

Markets are placed into the next available Fee Window once the Designated Reporter or First Public Reporter submits a Report. For example, if a Market’s Designated Report is submitted at 12:00 AM EST on January 3rd, 2053 and a Fee Window was just started on January 1st 2053, the Market would move into the next Fee Window that would be starting on January 8th, 2053, or 7 days since the start of the January 1st Window.

Any REP holder can participate in a Fee Window. In fact, in some cases, someone without any REP is able to successfully Report on Markets in the Open Reporting Phase. This case only occurs when the Market’s Designated Reporter fails to Report during the Designated Reporting Phase. In this situation, the first person to submit a Report can do so and Stake 0 REP on the Report. This is the true because the No-Show Bond is added to the First Public Reporter’s Stake, so in this case the Stake can be 0 as it will get the bond added to it. (The First Public Reporter must still pay the gas cost to submit the Report.) This creates a race to be the First Public Reporter so as to attempt to get free REP from reporting correctly and earning the No-Show Bond.

API Overview

augur.js is a JavaScript SDK that is the developer-facing component of Augur’s middleware. It is the recommended way to interact with Augur from a custom application, and it can be used to query for information about Augur’s Markets and interact with Augur’s back-end Solidity smart contracts, which can be found in the augur-core repository.

The documentation for augur.js is divided into four sections: the Simplified API, the Call API, the Transaction API, and the Events API. The Simplified API provides general information about Markets within Augur, and many of its functions require a connection to an Augur Node. The Call and Transaction APIs provide direct mappings to Augur’s smart contract functions via the augur.api object. The Call API uses eth_call to make “get” requests for information stored on the blockchain. The Transaction API uses eth_sendTransaction to make “set” requests to the blockchain in order to modify the blockchain’s information in some way, like creating a new Order on the Order Book. The Events API enables listening for certain logged events and searching for them. The Call, Transaction, and Events APIs do not require a connection to an Augur Node. Each of these four components of augur.js is covered in greater detail in their respective sections below.

This API Overview section explains how to add augur.js to a custom application and how to connect it to an Ethereum node and an Augur Node. It also covers how augur.js’ account management works, how numbers should be used in augur.js, how to load and create Markets, and debugging options.

Augur Node

Anyone wishing to query for information about Augur’s markets will need to use the augur.js Simplified API, which requires a connection to an Augur Node for many of its functions. Augur Node is a standalone application that scans the Ethereum blockchain for all Augur event logs and stores them to a SQLite or PostgresSQL database.

Instead of looking up information about Augur-related events directly on the Ethereum blockchain, the Simplified API sends query requests to an Augur Node’s database. This is because looking up information directly on the blockchain can be a slow and difficult process, especially when sorting is required. For example, to run a query for all Markets created by a specific user, sorted by volume and limited to 100 results, would require scanning the blockchain for all Market creation events by that user, saving the results locally, querying each Market to obtain its volume, saving those results locally, and then sorting the Markets created by the user and discarding everything after the first 100 results. This would require a large number of RPC requests and would take a long time to complete.

To alleviate this problem, the Simplified API executes queries by submitting an RPC request to an Augur Node that is either running locally or remotely (hosted). The Augur Node then runs the request against its database and returns the result. This allows queries to be run on Augur much more quickly than would otherwise be possible.

It should be noted that batch RPC calls are not supported yet on incoming requests to Augur Node, and therefore batch RPC calls currently are not supported by augur.js.

To set up a local Augur Node, follow the instructions described in the Augur Node GitHub repository. Once a local Augur Node is running (or if the WebSocket address of a hosted node is known), a connection to it can be established by specifying the WebSocket address as shown by the JavaScript sample code in the Getting Started with augur.js section.

Getting Started with augur.js

// After installing, just require augur.js to use it.
var Augur = require('augur.js');
var augur = new Augur();

var ethereumNode = { 
  httpAddresses: [
    "http://127.0.0.1:8545", // local HTTP address for Geth node
    "https://rinkeby.augur.net/ethereum-http" // hosted http address for Geth node on the Rinkeby test network
  ],
  wsAddresses: [
    "ws://127.0.0.1:8546", // local WebSocket address for Geth node
    "wss://rinkeby.augur.net/ethereum-ws" // hosted WebSocket address for Geth node on the Rinkeby test network
  ]
  // ipc addresses can also be specified as:
  // ipcAddresses: [ ... ]
};
// To connect to a hosted Augur Node instead of a local Augur Node, substitute its WebSocket address below.
var augurNode = "ws://127.0.0.1:9001"; // local WebSocket address for an Augur Node

// Attempt to connect to a local Ethereum node
// If that fails, fall back to the hosted Ethereum node
augur.connect({ ethereumNode, augurNode }, function (err, connectionInfo) { /* ... */ });
// example connectionInfo object:
{
  augurNode: "ws://127.0.0.1:9001",
  ethereumNode: {
    contracts: {
      Controller: "0xb1772d9e581e5a245ff429cca3e06c57d567c58c",
      Universe: "0xaa88b74da9e08d44c996f037ce13cb2711053cea",
      Augur: "0xdddc5d40979660308e8017d048b04782f17af4af",
      OrdersFinder: "0x01f2aba090b5fa26a64ea9e5afd32f6aab6ba3df",
      LegacyReputationToken: "0x59c98505653f68e8cc2a0ac1e84380a0393fd04e",
      CancelOrder: "0x4c0f599bdd8f9eac10cdfd152c3110ea9b803088",
      Cash: "0x5754d0bcb36b7f30999199031d1f323c4079d58d",
      ClaimTradingProceeds: "0xe408a58ff3eb050f39728fc45644f64e8e379e3d",
      CompleteSets: "0xb51a3aab3d5009f21cd9b47ae856aa780460b78c",
      CreateOrder: "0x19ef3d62d49e95e1b92c1fe12986a24a42c4f3c3",
      FillOrder: "0x57972b23e4e97cf33b456d292411308b1053d835",
      Order: "0x86416fd9eb6ca7797f799ccc2e08a4da4083ac17",
      Orders: "0x452cbdba8559a9b0199bb15105a42fc7ae373983",
      OrdersFetcher: "0xc9d0126e1aa921056af5981016904690ad73c0d3",
      ShareToken: "0x5c8b3117b65af65405980f3700542c03709a6436",
      Trade: "0x8d0677ee9f5330fd65db56da6c31711fd6810434",
      TradingEscapeHatch: "0x867d606553c3fc24b35e3b02d228dc1647786f88"
    },
    abi: {
      events: { /* ... */ },
      functions: { /* ... */ }
    },
  }
}

The easiest way to install augur.js is using npm:

$ npm install augur.js

Alternatively, this can be done using yarn, as follows:

$ yarn add augur.js

Once augur.js has been installed, it will need to be connected to an Ethereum node and an Augur node. These can be running locally or remotely (hosted).

To connect to the desired Ethereum node and Augur node, call the function augur.connect as shown to the right. Upon doing so, augur.js will iterate through the list of addresses provided in the ethereumNode argument and attempt to connect to each one until a successful connection is established or all attempts have failed. The Ethereum node may have multiple HTTP, WebSocket, or IPC addresses specified as arrays. The connection will be chosen automatically based on a preference of IPC > WS > HTTP. Note: if there is a global web3 object present, such as that injected by MetaMask, that global web3 will be automatically used in preference to any other connections available. So, if you’re using MetaMask, make sure it’s connected to the right network!

Similarly, augur.js will attempt to use the augurNode parameter to connect to an Augur Node. However, augurNode may only be specified as a single-address string, not as an object containing an array of addresses.

The Augur development team hosts Augur Nodes and Ethereum nodes on the Ethereum test networks. The addresses for these hosted nodes are as follows:

dev.augur.net Augur Node (WSS): wss://dev.augur.net/augur-node
dev.augur.net Ethereum Node (HTTPS): https://rinkeby.augur.net/ethereum-http
dev.augur.net Ethereum Node (WSS): wss://rinkeby.augur.net/ethereum-ws

Kovan Augur Node (WSS): Must connect to a locally-running augur-node (e.g., ws://127.0.0.1:9001)
Kovan Ethereum Node (HTTPS): https://kovan.augur.net/ethereum-http
Kovan Ethereum Node (WSS): wss://kovan.augur.net/ethereum-ws

Rinkeby Augur Node (WSS): wss://rinkeby.augur.net/augur-node
Rinkeby Ethereum Node (HTTPS): https://rinkeby.augur.net/ethereum-http
Rinkeby Ethereum Node (WSS): wss://rinkeby.augur.net/ethereum-ws

Ropsten Augur Node (WSS): Must connect to a locally-running augur-node (e.g., ws://127.0.0.1:9001)
Ropsten Ethereum Node (HTTPS): https://ropsten.augur.net/ethereum-http
Ropsten Ethereum Node (WSS): wss://ropsten.augur.net/ethereum-ws

srt.augur.net Augur Node (WSS): Must connect to a locally-running augur-node (e.g., ws://127.0.0.1:9001)
srt.augur.net Ethereum Node (HTTPS): https://srt.augur.net/ethereum-http
srt.augur.net Ethereum Node (WSS): wss://srt.augur.net/ethereum-ws

The Augur development team does not host any Augur Nodes or Ethereum nodes for the Ethereum main network. However, a list of these nodes that are hosted by trusted community members can be found at https://predictions.global/augur-public-ethereum-nodes.

In the example on the right, the first connection that will be tried is http://127.0.0.1:8545, which is a local Ethereum node being run using the Geth client. If a connection to the local Geth node cannot be established, the next provided address will be tried. In this case, we have provided a single hosted node on the Ethereum Rinkeby test network (rinkeby.ethereum.nodes.augur.net) as another attempt to make after the local Geth node. If a connection is successfully established, then the vitals object will be returned; otherwise an error message will be returned.

It should be noted that Augur’s back-end Solidity smart contracts are deployed from the perspective of augur.js, which means that augur.js contains a list of Augur’s smart contract addresses in the file augur.js/src/contracts/addresses.json.

The each group of addresses in the file maps to an Ethereum network ID or to the network ID of a local Ethereum node in a Docker image:

• 1 - Main network
• 3 - Ropsten test network
• 4 - Rinkeby test network
• 19 - Thunder network
• 42 - Kovan test network
• 101 - Network ID for a local node (used when running Docker image dev-node-geth in augur.js)
• 102 - Network ID for local node (used when running Docker image dev-pop-geth in augur.js)
• 103 - Network ID for local node (used when running Docker image dev-pop-normtime-geth in augur.js)
• 104 - Network ID for local node (used when running Docker image dev-pop-geth-45 in augur.js)
• 8995 - Network ID for local node (used when running Docker image dev-node-parity in augur.js)

The file augur.js/src/contracts/addresses.json is generated by the script augur-core/source/libraries/ContractCompiler.ts in the augur-core repository.

Augur’s smart contract ABIs are generated and output to augur-core/output/contracts/abi.json in the augur-core repository by the script augur-core/source/libraries/ContractCompiler.ts. For further details on Augur’s smart contracts and their compiling/deployment process, please refer to the README file in the augur-core repository.

Numbers

It is strongly recommended that all numerical input values be passed into Call API functions and Transaction API functions as hexadecimal strings. This is because these API functions are direct bindings to the functions on Augur’s smart contracts, and passing in very large numbers in decimal form can result in the functions on Augur’s smart contracts failing.

The Simplified API functions, however, automatically convert numerical input values to hexadecimal form before passing them into Augur’s smart contracts.

For the Simplified API, there are three acceptable ways to pass numerical inputs:

• primitive JS numbers (e.g., 1010101): ok for integers, but use strings for floating point numbers (see below)

• stringified numbers (e.g., "1010101")

• hexadecimal strings (e.g., "0xf69b5")

Floating-point (decimal) values should be passed to augur.js as strings (e.g., instead of 0.07, use "0.07"), for reasons described in enormous detail elsewhere.

Initial Market Loading

To get a list of all Markets, first call augur.markets.getMarkets. More detailed market info (including prices) for each market can then be loaded using augur.markets.getMarketsInfo. augur.markets.getMarketsInfo does not return the Open Orders for the Market; to get the Open Orders, call augur.trading.getOrders.

Debugging Options

augur.rpc.setDebugOptions({ broadcast: true });
augur.api.Universe.getCurrentFeeWindow();
// example output:
packaged: {
  from: "0x56ddb80fe4e5aa05182d794526ab1eff78c90688", 
  to: "0xa1d76546015cfe50183497ca65fcbd5c656f7813", 
  data: "0x6235eef3", 
  gas: "0x2fd618", 
  returns: "address"
}
Blockchain RPC to http://127.0.0.1:8545 via SyncTransport with payload: 
{
  "id":429,
  "jsonrpc":"2.0",
  "method":"eth_call",
  "params":[{"from":"0x56ddb80fe4e5aa05182d794526ab1eff78c90688",
             "to":"0xa1d76546015cfe50183497ca65fcbd5c656f7813",
             "data":"0x6235eef3",
             "gas":"0x2fd618"},
             "latest"]
}
"0x54d134699764375417e4b5dda1e2ac62f62e9725"

augur.rpc.setDebugOptions({ connect: true });
augur.connect({ 'ethereumNode': { http: "http://rinkeby.augur.net:8545", ws: "ws://rinkeby.augur.net:8546" }, 'augurNode': "ws://127.0.0.1:9001"}, function (err, vitals) { console.log(err); console.log(vitals); });
// example output:
connecting to augur node... 
{ 
  augurNode: "ws://127.0.0.1:9001",
  ethereumNode: { http: "http://rinkeby.augur.net:8545", ws: "ws://rinkeby.augur.net:8546" }
}
connecting to ethereum node... 
{ 
  augurNode: "ws://127.0.0.1:9001",
  ethereumNode: { http: "http://rinkeby.augur.net:8545", ws: "ws://rinkeby.augur.net:8546" }
}
connected to augur
Web3: not connected
Sync: http://rinkeby.augur.net:8545
HTTP: http://rinkeby.augur.net:8545
WS: ws://rinkeby.augur.net:8546
IPC: not connected
connected to ethereum
{
  augurNode: "ws://127.0.0.1:9001",
  ethereumNode: {
    abi: {events: {...}, functions: {...}},
    blockNumber: "0x133773",
    coinbase: null,
    contracts: {...},
    gasPrice: 20000000000,
    networkId: "4",
    rpc: {...}
  }
}

augur.rpc.setDebugOptions({ tx: true });
augur.api.Universe.getOrCacheMarketCreationCost({
  onSent: function (result) {...},
  onSuccess: function (result) {...},
  onFailed: function (result) {...}
});
// example output:
payload transact: 
{
  constant: false,  
  from: "0x40485264986740c8fb3d11e814bd94cf86012d29"
  name: "getOrCacheMarketCreationCost"
  params: [],
  returns: "uint256",
  send: true,
  to: "0xa282b625053e80da550098fdb325a8ece6dfe8ac"
}
callReturn: 10000000006000000
txHash: 0x26f731c948568d9c0a4983fa134431f3fba0c68248f95d35536c9157cafa785a

The function augur.rpc.setDebugOptions allows several debugging options to be enabled:

• broadcast - When set to true, this enables printing of verbose, low-level information related to sending/receiving transactions, such as the transaction JSON that gets sent out over the wire, incoming eth_subscription messages, etc.

• connect - When set to true, this enables printing of the result of the initial connection of ethrpc to the underlying Ethereum node, as well as which endpoints are connected, on which protocols

• tx - When set to true, this enables printing of information related to transaction construction/submission/confirmation. This information includes the intermediate “transaction” object with human-readable parameters, the (best-guess) return value fetched from the follow-up eth_call when a transaction gets resubmitted, and the transaction hash once the transaction is submitted.

Simplified API

Accounts Functions

// Accounts Simplified API Examples:

augur.accounts.approveAugur({
  address: "0x0000000000000000000000000000000000000b0b", 
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function(result) { console.log(result); },
  onSuccess: function(result) { console.log("Approval was successful."); },
  onFailed: function(result) { console.log("Approval failed due to error:", result); }
});
// example output:
"Approval was successful."

augur.accounts.getAccountTransferHistory({
  account: "0x0000000000000000000000000000000000000b0b",
  token: null,
  isSortDescending: false
}, function (error, result) {
  console.log(result);
});
// example output:
[
  {
    transactionHash: "0x00000000000000000000000000000000000000000000000000000000deadbeef",
    logIndex: 0,
    creationBlockNumber: 1400000,
    blockHash: "0x1400000",
    creationTime: 1506473474,
    sender: " 0x0000000000000000000000000000000000000b0b",
    recipient: " 0x000000000000000000000000000000000000d00d",
    token: " 0x0100000000000000000000000000000000000000",
    value: "10",
    symbol: "shares",
    marketId: " 0x0000000000000000000000000000000000000001",
    outcome: 0,
    isInternalTransfer: 0,
  },
  {
    transactionHash: "0x00000000000000000000000000000000000000000000000000000000d3adb33f",
    logIndex: 0,
    creationBlockNumber: 1400001,
    blockHash: "0x1400001",
    creationTime: 1506473500,
    sender: " 0x000000000000000000000000000000000000d00d",
    recipient: " 0x0000000000000000000000000000000000000b0b",
    token: " 0x0100000000000000000000000000000000000000",
    value: "2",
    symbol: "shares",
    marketId: " 0x0000000000000000000000000000000000000001",
    outcome: 0,
    isInternalTransfer: 1,
  },
  {
    transactionHash: "0x00000000000000000000000000000000000000000000000000000000deadb33f",
    logIndex: 1,
    creationBlockNumber: 1400001,
    blockHash: "0x1400001",
    creationTime: 1506473500,
    sender: " 0x0000000000000000000000000000000000000b0b",
    recipient: " 0x000000000000000000000000000000000000d00d",
    token: " 0x7a305d9b681fb164dc5ad628b5992177dc66aec8",
    value: "47",
    symbol: "REP",
    marketId: null,
    outcome: null,
    isInternalTransfer: 0,
  }
]

augur.accounts.approveAugur(p)

Internally, Augur uses an ERC-20 token called Cash as a wrapper for ETH. Many of Augur’s transactions require Augur to be able to spend Cash on behalf of the account executing the transaction. However, the account must first approve Augur to spend that amount of Cash on its behalf. This function calls the function augur.api.Cash.approve to approve Augur to spend up to augur.constants.ETERNAL_APPROVAL_VALUE Cash on behalf of the account. augur.constants.ETERNAL_APPROVAL_VALUE is equal to 2^256 - 1, or the maximum amount of Cash that can be approved. This value is used so that augur.api.Cash.approve does not have to be called multiple times in order to execute multiple transactions.

Parameters:

• p (Object) Parameters object.
  • p.address (string) Ethereum address of the account making the approval.
  • p.meta (Meta) <optional> Authentication metadata for raw transactions.
  • p.onSent (function) Called if/when the transaction is broadcast to the network.
  • p.onSuccess (function) Called if/when the transaction is sealed and confirmed.
  • p.onFailed (function) Called if/when the transaction fails.

Returns:

• Does not return a value.

augur.accounts.getAccountTransferHistory(p, callback)

Returns the token transfers made to or from a specific Ethereum address.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.account (string) Ethereum address of the account for which to get transfer history, as a 20-byte hexadecimal string.
  • p.token (string) <optional> Contract address of the token contract by which to limit the history results, as a 20-byte hexadecimal string.
  • isInternalTransfer (boolean) <optional> When set to true, only trade/order transfers will be returned; otherwise, all transfers for the account are returned. (This is not perfectly accurate, as it is possible for a trade and a non-trade/order-related transfer to appear in the same transaction. This can occur if done via a smart contract, which performs a standard transfer and a trade in the same transaction.) Defaults to false.
  • p.earliestCreationTime (number) <optional> Earliest timestamp, in seconds, at which to truncate history results. (This timestamp is when the block on the Ethereum blockchain containing the transfer was created.)
  • p.latestCreationTime (number) <optional> Latest timestamp, in seconds, at which to truncate history results. (This timestamp is when the block on the Ethereum blockchain containing the transfer was created.)
  • p.sortBy (string) <optional> Field name by which to sort transfer history.
  • p.isSortDescending (boolean) <optional> Whether to sort transfers in descending order by sortBy field.
  • p.limit (number) <optional> Maximum number of transfers to return.
  • p.offset (number) <optional> Number of transfers to truncate from the beginning of the history results.
• callback (function) Called after the account transfer history has been retrieved.

Returns:

• (Array.<AccountTransfer>) Array representing the account’s transfer history.

Assets Functions

// Assets Simplified API Examples:

augur.assets.sendEther({
  etherToSend: "0.001",
  from: "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
  to: "0x40485264986740c8fb3d11e814bd94cf86012d29",
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function(result) { console.log(result); },
  onSuccess: function(result) { console.log(result); },
  onFailed: function(result) { console.log(result); }
});

augur.assets.sendReputation({
  universe: "0x1f732847fbbcc46ffe859f28e916d993b2b08831",
  reputationToSend: "0.001",
  _to: "0x40485264986740c8fb3d11e814bd94cf86012d29",
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function(result) { console.log(result); },
  onSuccess: function(result) { console.log(result); },
  onFailed: function(result) { console.log(result); }
});

augur.assets.sendEther(p)

Sends Ether to a specified Ethereum address.

Parameters:

• p (Object) Parameters object.
  • p.etherToSend (string) Amount of Ether to send, as a base-10 string.
  • p.from (string) Ethereum address of the sender, as a 20-byte hexadecimal string.
  • p.to (string) Ethereum address of the recipient, as a 20-byte hexadecimal string.
  • p.meta (Meta) <optional> Authentication metadata for raw transactions.
  • p.onSent (function) Called if/when the transaction is broadcast to the network.
  • p.onSuccess (function) Called if/when the transaction is sealed and confirmed.
  • p.onFailed (function) Called if/when the transaction fails.

Returns:

• Return value cannot be obtained because Ethereum nodes discard transaction return values.

augur.assets.sendReputation(p)

Sends REP to a specified Ethereum address. This function will trigger a TokensTransferred event if the REP is successfully sent.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) The universe of Reputation to use.
  • p.reputationToSend (string) Amount of Reputation to send, as a base-10 string.
  • p._to (string) Ethereum address of the recipient, as a 20-byte hexadecimal string.
  • p.meta (Meta) <optional> Authentication metadata for raw transactions.
  • p.onSent (function) Called if/when the transaction is broadcast to the network.
  • p.onSuccess (function) Called if/when the transaction is sealed and confirmed.
  • p.onFailed (function) Called if/when the transaction fails.

Returns:

• Return value cannot be obtained because Ethereum nodes discard transaction return values.

Augur Node Functions

// Augur Node Simplified API Examples:

augur.augurNode.connect(
  "ws://127.0.0.1:9001",
  function(error, wsTransport) {
    if (error) {
      console.log(error);
    } else {
      console.log("Connected to Augur Node!");
      console.log("WebSocket transport:");
      console.log(wsTransport);
    }
  }
);
// example output:
"Connected to Augur Node!"
"WebSocket transport:"
{
  address: "ws://127.0.0.1:9001",
  awaitingPump: false,
  backoffMilliseconds: 1,
  connected: true,
  disconnectListeners: { ... },
  maxRetries: 0,
  messageHandler: ƒ dispatchJsonRpcResponse(err, jsonRpcResponse),
  nextListenerToken: 1,
  reconnectListeners: { ... },
  timeout: 100,
  webSocketClient: { ... }
  workQueue: [],
}

augur.augurNode.disconnect();
// This function does not return a value.

augur.augurNode.getSyncData(
  function(error, result) {
    console.log(result);
  }
);
// example output:
{
  addresses: {
    Controller: "0x392be0a9d1ab1bde2931c2ddf1d722f9e13b6085",
    Universe: "0x1f732847fbbcc46ffe859f28e916d993b2b08831",
    Augur: "0x852684b374fe03ab77d06931f1b2831028fd58f5",
    OrdersFinder: "0x01f2aba090b5fa26a64ea9e5afd32f6aab6ba3df",
    LegacyReputationToken: "0x097c198dcc997086d1555ad9ae6f52375cfb58d0",
    CancelOrder: "0x389c0b3f0d51cfba9e4d214712a1142f5685814d",
    Cash: "0xd2ee83a8a2a904181ccfddd8292f178614062aa0",
    ClaimTradingProceeds: "0x8aa774927fb928ee1df0d0d3f94c8217658e0bce",
    CompleteSets: "0xbf749b00e42751dba8e0872e66d3ba854f6c2632",
    CreateOrder: "0xdadc071ecc3b7e97b139d2ef692defdc398c8211",
    FillOrder: "0x0c77f6af7b3b5fed8ca980414a97c62da283098a",
    Order: "0x4811d582f64e68e657bec21834012af38ef093bc",
    Orders: "0x1ba5cf0ce546bf7d7943c4d4fb21ea59f6bb0eee",
    OrdersFetcher: "0xb9f2cf78542de87ba7542d92e2937d0eedec5feb",
    ShareToken: "0x925bee44fec28deb228d2251e1a9d32f7c73ebed",
    Trade: "0x0dec7fd04933b8673cef99b64978113065b03926",
    TradingEscapeHatch: "0x157a8998f5470a2be3917aab31d334109f56c30c"
  },
  augurNodeVersion: "7.1.5",
  highestBlock: {
    hash: "0x9c1a28be182d755a053f4efe35f04558a318ea6ea925f827a7de8a30d5d23f58",
    number: 10019,
    timestamp: 1531977999,
  },
  isSyncFinished: true,
  lastProcessedBlock: {
    hash: "0x2dd3a600f9678a8a57b320e00b483502feb0d75977c10f0ec02ba86d6c455dab",
    number: 10013,
    timestamp: 1530856121,
  },
  netId: "102",
  net_version: "102",
  version: "6.1.4",
}

augur.augurNode.submitRequest(
  "getMarkets",
  {
    universe: "0x02149d40d255fceac54a3ee3899807b0539bad60",
    search: "category: Ethereum OR tags: ETH"
  },
  function(error, result) {
    console.log(result);
  }
);
// example output:
[
  "0x98c189f9254b5729eb870688f812b83ebd116798",
  "0xa47f967c4806d34859ec93013be5ebc4d68f3a64",
  "0xfa26157e03f05ca681997e63db25af1a95239243"
]

augur.augurNode.subscribeToEvent(
  "TokensTransferred",
  function(error, result) {
    console.log(error);
    console.log(result);
    console.log("Tokens transferred!");
  },
  function(error, subscriptionId) {
    console.log("Subscribed to event! Subscription ID:", subscriptionId);
  }
);
// example output:
"Subscribed to event! Subscription ID: 8cac9a4b-f5b8-4fb1-be50-5aa16dc99e67"

augur.augurNode.unsubcribeFromEvent(
  "8cac9a4b-f5b8-4fb1-be50-5aa16dc99e67",
  function(error) {
    if (!error) {
      console.log("Unsubscribe successful!");
    }
  }
);
// example output:
"Unsubscribed from 8cac9a4b-f5b8-4fb1-be50-5aa16dc99e67"
"Unsubscribe successful!"

augur.augurNode.unsubscribeFromAllEvents(
  function() {
    console.log("Unsubscribed from all events!");
  }
);
// example output:
"Unsubscribed from 32a81c04-8b35-47fa-a6d0-b12a34145108"
"Unsubscribed from a6354b5d-64a7-49db-acd9-ff56dcc54b4d"
"Unsubscribed from all events!"

augur.augurNode.connect(augurNodeUrl, callback)

Establishes a connection to an Augur Node.

Parameters:

• augurNodeUrl (string) WebSocket URL of an Augur Node to connect to.
• callback (function) Called after attempting to connect to an Augur Node.

Returns:

• (WsTransport) WebSocket transfer object containing information about the WebSocket connection to the Augur Node.

augur.augurNode.disconnect()

Disconnects augur.js from the Augur Node it is currently connected to. (To disconnect from the Ethereum node it is currently connected to, use augur.disconnect.)

Parameters:

• This function does not accept any parameters.

Returns:

• This function does not return a value.

augur.augurNode.getContractAddresses(callback)

This function has been deprecated in favor of augur.augurNode.getSyncData.

augur.augurNode.getSyncData(callback)

Returns the version and contract address set from an Augur Node. Also returns information about the highest blockchain block and the last processed blockchain block.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• callback (function) Called after the Augur Node information has been retrieved.

Returns:

• (SyncData) An object containing the information from Augur Node.

augur.augurNode.submitRequest(method, params, callback)

Submits an RPC request to an Augur Node.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• method (string) Method name to call.
• params (Object) Parameters to pass into method.
• callback (function) Called once the Augur Node responds to the RPC request.

Returns:

• (Data type can vary based on the method being called.) Result from the RPC request.

augur.augurNode.subscribeToEvent(eventName, subscriptionCallback, onComplete)

Listens to an Augur Node for when a specific event occurs.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• eventName (string) Type of event to listen for.
• subscriptionCallback (function) Called whenever the Augur Node detects a new occurrence of the specified event.
• onComplete (function) Called after attempting to set up the subscription to listen on the Augur Node.

Returns:

• (string) ID of the subscription that was created.

augur.augurNode.unsubscribeFromEvent(subscriptionId, callback)

Stops the specified subscription from listening on an Augur Node.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• subscriptionId (string) Subscription ID to stop listening.
• callback (function) Called after attempting to stop the subscription from listening on the Augur Node.

Returns:

• This function does not return a value.

augur.augurNode.unsubscribeFromAllEvents(callback)

Stops the current subscriptions from listening on an Augur Node.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• callback (function) Called after attempting to stop all subscriptions from listening on the Augur Node.

Returns:

• This function does not return a value.

Connect Function

// Connect Simplified API Examples:

augur.connect({
  ethereumNode: {
    httpAddresses: [
      "http://127.0.0.1:8545", // local HTTP address for Geth node
      "https://rinkeby.ethereum.nodes.augur.net" // hosted HTTP address for Geth node on the Ethereum Rinkeby test network
    ],
    wsAddresses: [
      "ws://127.0.0.1:8546", // local WebSocket address for Geth node
      "wss://ws9000.augur.net" // hosted WebSocket address for Geth node
    ]
  },
  augurNode: "ws://127.0.0.1:9001" // local WebSocket address for an Augur Node
}, function (error, connectionInfo) {
  console.log(connectionInfo);
});
// example output:
connecting to augur-node: ws://127.0.0.1:9001
connecting to ethereum-node: {"httpAddresses":["http://127.0.0.1:8545","https://rinkeby.ethereum.nodes.augur.net"],"wsAddresses":["ws://127.0.0.1:8546","wss://websocket-rinkeby.ethereum.nodes.augur.net"]}
connected to augur
Web3: not connected
Sync: http://127.0.0.1:8545
HTTP: http://127.0.0.1:8545
WS: ws://127.0.0.1:8546
IPC: not connected
connected to ethereum
{
  augurNode: "ws://127.0.0.1:9001",
  ethereumNode: {
    abi: { ... },
    blockNumber: "0x184e24",
    coinbase: "0x40485264986740c8fb3d11e814bd94cf86012d29",
    contracts: { ... },
    gasPrice: 20000000000,
    networkId: "4"
    rpc: { ... }
  }
}

augur.disconnect();
// This function does not return a value.

augur.connect(connectOptions, callback)

Connects augur.js to an Ethereum node and an Augur Node.

Parameters:

• connectOptions (ConnectOptions) Options used to connect to an Ethereum node and an Augur Node.
• callback (function) <optional> Callback function.

Returns:

• (Object) Transport object containing information about the Augur Node and Ethereum node connections.

augur.disconnect()

Disconnects augur.js from the Ethereum node it is currently connected to. (To disconnect from the Augur Node it is currently connected to, use augur.augurNode.disconnect.)

Parameters:

• This function does not accept any parameters.

Returns:

• This function does not return a value.

Create Market Functions

// Create Market Simplified API Examples:
var _extraInfo = {
  resolutionSource: "https://www.espn.com",
  tags: ["college football", "football"],
  outcomeNames: ["Georgia", "Florida"],
  longDescription: ""
};
augur.createMarket.createCategoricalMarket({
  universe: "0x1f732847fbbcc46ffe859f28e916d993b2b08831",
  _endTime: 1540875600,
  _feePerEthInWei: 1193046,
  _denominationToken: "0xd2ee83a8a2a904181ccfddd8292f178614062aa0",
  _designatedReporterAddress: "0x01114f4bda09ed6c6715cf0baf606b5bce1dc96a",
  _outcomes: ["outcome1","outcome2"],
  _topic: "sports",
  _description: "Who will win the University of Georgia vs. University of Florida football game in 2018?",
  _extraInfo: JSON.stringify(_extraInfo),
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function (result) { console.log(result); },
  onSuccess: function (result) { console.log(result); },
  onFailed: function (result) { console.log(result); }
});
// example onSuccess output:
{
  "callReturn": "0xc841ee153e45e74074eae9685e815d08dee965eb",
  "blockHash": "0xf5aab811242a73fe433995fdf2212548385b81acef4d6e5634faec74014f39df",
  "blockNumber": 1657080,
  "from": "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
  "gas": "0x5b8d80",
  "gasPrice": "0x1a13b8600",
  "hash": "0xb55fa7c2e9d43fc9d11badb33f1d571539859059bdd7447594748733b112f7d2",
  "input": "0x59381d2e000000000000000000000000000000000000000000000000000000005c2aad7f0000000000000000000000000000000000000000000000000000000000123456000000000000000000000000d2ee83a8a2a904181ccfddd8292f178614062aa00000000000000000000000008fa56abe36d8dc76cf85fecb6a3026733e0a12ac73746f636b73000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000004d57696c6c2074686520446f77204a6f6e657320496e647573747269616c2041766572616765206578636565642032372c30303020617420616e7920706f696e7420647572696e6720323031383f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000085227b5c227265736f6c7574696f6e536f757263655c223a5c2268747470733a2f2f7777772e6d61726b657477617463682e636f6d2f696e76657374696e672f696e6465782f646a69615c222c5c22746167735c223a5b5c2253746f636b735c222c5c22444a49415c225d2c5c226c6f6e674465736372697074696f6e5c223a5c225c227d22000000000000000000000000000000000000000000000000000000",
  "nonce": "0x43",
  "to": "0x1f732847fbbcc46ffe859f28e916d993b2b08831",
  "transactionIndex": "0x0",
  "value": "0xa8c0ff92d4c000",
  "v": "0x2b",
  "r": "0x256cedf5b3ef2f49f6eef99d10ca53ba0484da0e9cbf4434bb3042f90fb376de",
  "s": "0x4161413a76a41468272e85ea7af8362393ea886f743b9882f42bea39fc6ec0b9",
  "timestamp": 1516925924,
  "gasFees": "0.022312465"
}

var _extraInfo = {
  resolutionSource: "https://forecast.weather.gov",
  tags: ["San Francisco", "weather"],
  longDescription: "",
  _scalarDenomination: "degrees Fahrenheit",
};
augur.createMarket.createScalarMarket({
  universe: "0x1f732847fbbcc46ffe859f28e916d993b2b08831",
  _endTime: 1530507600,
  _feePerEthInWei: 1193046,
  _denominationToken: "0xd2ee83a8a2a904181ccfddd8292f178614062aa0",
  _designatedReporterAddress: "0x01114f4bda09ed6c6715cf0baf606b5bce1dc96a",
  _minPrice: -10,
  _maxPrice: 120,
  _numTicks: 10,
  _topic: "temperature",
  _description: "High temperature (in degrees Fahrenheit) in San Francisco, California, on July 1, 2018",
  _extraInfo: JSON.stringify(_extraInfo),
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function (result) { console.log(result); },
  onSuccess: function (result) { console.log(result); },
  onFailed: function (result) { console.log(result); }
});
// example onSuccess output:
{
  "callReturn": "0x008f89903707dbaaed3c42202ec00a94673e96db",
  "blockHash": "0xfbb0b8ced5dab79a5ef58dd0eb45c28e5124832e5c27c0479ea8d6947fef4ed2",
  "blockNumber": 1657371,
  "from": "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
  "gas": "0x5b8d80",
  "gasPrice": "0x4a817c800",
  "hash": "0x7f52926eac45ec6483cc19b5da795b7425fd3caf191c3eeb208627f4ea0e43b9",
  "input": "0x72d61dfa000000000000000000000000000000000000000000000000000000005b39b1500000000000000000000000000000000000000000000000000000000000123456000000000000000000000000d2ee83a8a2a904181ccfddd8292f178614062aa00000000000000000000000008fa56abe36d8dc76cf85fecb6a3026733e0a12acffffffffffffffffffffffffffffffffffffffffffffffff7538dcfb761800000000000000000000000000000000000000000000000000068155a43676e00000000000000000000000000000000000000000000000000000000000000013d62074656d7065726174757265000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000001c00000000000000000000000000000000000000000000000000000000000000056486967682074656d70657261747572652028696e20646567726565732046616872656e686569742920696e2053616e204672616e636973636f2c2043616c69666f726e69612c206f6e204a756c7920312c203230313800000000000000000000000000000000000000000000000000000000000000000000000000000000007a227b5c227265736f6c7574696f6e536f757263655c223a5c22687474703a2f2f666f7265636173742e776561746865722e676f765c222c5c22746167735c223a5b5c2253616e204672616e636973636f5c222c5c22776561746865725c225d2c5c226c6f6e674465736372697074696f6e5c223a5c225c227d22000000000000",
  "nonce": "0x45",
  "to": "0x1f732847fbbcc46ffe859f28e916d993b2b08831",
  "transactionIndex": "0x0",
  "value": "0xa8c0ff92d4c000",
  "v": "0x2b",
  "r": "0xa8dee275a834a3dc9b2f36c0f7bb9564557d6943623013d772b966ce7045e029",
  "s": "0x14355beeb51c6565f923e2f2e4133261765cc6357a3d8038b18a4d25e874fec8",
  "timestamp": 1516930289,
  "gasFees": "0.0618542"
}

var _extraInfo = {
  resolutionSource: "https://www.nasdaq.com/symbol/msft",
  tags: [ "Stocks", "Microsoft" ],
  longDescription: ""
};
augur.createMarket.createYesNoMarket({
  universe: "0x1f732847fbbcc46ffe859f28e916d993b2b08831",
  _endTime: 1546300799,
  _feePerEthInWei: 1193046,
  _denominationToken: "0xd2ee83a8a2a904181ccfddd8292f178614062aa0",
  _designatedReporterAddress: "0x01114f4bda09ed6c6715cf0baf606b5bce1dc96a",
  _topic: "stocks",
  _description: "Will Microsoft stock (MSFT) be below $50 at any point during 2018?",
  _extraInfo: JSON.stringify(_extraInfo),
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function (result) { console.log(result); },
  onSuccess: function (result) { console.log(result); },
  onFailed: function (result) { console.log(result); }
});
// example onSuccess output:
{
  "callReturn": "0xc841ee153e45e74074eae9685e815d08dee965eb",
  "blockHash": "0xf5aab811242a73fe433995fdf2212548385b81acef4d6e5634faec74014f39df",
  "blockNumber": 1657080,
  "from": "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
  "gas": "0x5b8d80",
  "gasPrice": "0x1a13b8600",
  "hash": "0xb55fa7c2e9d43fc9d11badb33f1d571539859059bdd7447594748733b112f7d2",
  "input": "0x59381d2e000000000000000000000000000000000000000000000000000000005c2aad7f0000000000000000000000000000000000000000000000000000000000123456000000000000000000000000d2ee83a8a2a904181ccfddd8292f178614062aa00000000000000000000000008fa56abe36d8dc76cf85fecb6a3026733e0a12ac73746f636b73000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000004d57696c6c2074686520446f77204a6f6e657320496e647573747269616c2041766572616765206578636565642032372c30303020617420616e7920706f696e7420647572696e6720323031383f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000085227b5c227265736f6c7574696f6e536f757263655c223a5c2268747470733a2f2f7777772e6d61726b657477617463682e636f6d2f696e76657374696e672f696e6465782f646a69615c222c5c22746167735c223a5b5c2253746f636b735c222c5c22444a49415c225d2c5c226c6f6e674465736372697074696f6e5c223a5c225c227d22000000000000000000000000000000000000000000000000000000",
  "nonce": "0x43",
  "to": "0x1f732847fbbcc46ffe859f28e916d993b2b08831",
  "transactionIndex": "0x0",
  "value": "0xa8c0ff92d4c000",
  "v": "0x2b",
  "r": "0x256cedf5b3ef2f49f6eef99d10ca53ba0484da0e9cbf4434bb3042f90fb376de",
  "s": "0x4161413a76a41468272e85ea7af8362393ea886f743b9882f42bea39fc6ec0b9",
  "timestamp": 1516925924,
  "gasFees": "0.022312465"
}

augur.createMarket.getMarketCreationCost({
    universe: "0x1f732847fbbcc46ffe859f28e916d993b2b08831",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  designatedReportNoShowReputationBond: "0.174840291341145834",
  etherRequiredToCreateMarket: "0.025"
}

augur.createMarket.getMarketCreationCostBreakdown({
    universe: "0x1f732847fbbcc46ffe859f28e916d993b2b08831",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  designatedReportNoShowReputationBond: "0.174840291341145834",
  validityBond: "0.01",
}

augur.createMarket.getMarketFromCreateMarketReceipt(
  "0xa50c02cf3de82139fc6f66a9c1726f59b93b4a94725bddbf9ecae0c38edc4f06", 
  function (error, result) {
    console.log(result);
  }
);
// example output: 
"0x5e05e281a4564077985debdb91159a825a6774d3"

augur.createMarket.createCategoricalMarket(p)

Creates a Categorical Market in a specified Universe. This function will trigger a MarketCreated event and TokensTransferred event if the Market is created successfully.

This transaction will fail if:

• p._outcomes contains fewer than 2 outcomes or more than 8 outcomes.
• p._designatedReporterAddress is set to the null address.
• p._feePerEthInWei is greater than the maximum fee (0.5 ETH).
• p._endTime has already passed.
• The Universe is Forking.

NOTE: The account attempting to create the new market must have sufficient REP in order for the market to be created. This is also true when calling eth_estimateGas, which essentially does a trial run of the transaction to determine what the gas cost would be to actually run it.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Universe in which to create a Categorical Market.
  • p._endTime (number) Categorical Market expiration timestamp, in seconds.
  • p._feePerEthInWei (string) <optional> Amount of wei per ether settled that goes to the Market Creator, as a base-10 string.
  • p._denominationToken (string) Ethereum address of the token used as this Market’s currency.
  • p._designatedReporterAddress (string) Ethereum address of this Market’s Designated Reporter.
  • p._outcomes (Array.<string>) Array of names for all possible outcomes for the Market event.
  • p._topic (string) The topic (category) to which this Market belongs, as a UTF8 string. Note: This string is limited to 32-characters.
  • p._description (string) Description of the Market, as a UTF8 string.
  • p._extraInfo (ExtraInfo) <optional> Extra info which will be converted to JSON and logged to the chain in the MarketCreated event.
  • p.meta (Meta) <optional> Authentication metadata for raw transactions.
  • p.onSent (function) Called if/when the createCategoricalMarket transaction is broadcast to the network.
  • p.onSuccess (function) Called if/when the createCategoricalMarket transaction is sealed and confirmed.
  • p.onFailed (function) Called if/when the createCategoricalMarket transaction fails.

Returns:

• (Object) Object containing information about the Market creation transaction. The callReturn property of this object contains the Ethereum address of the Market that was created.

augur.createMarket.createScalarMarket(p)

Creates a Scalar Market in a specified Universe. This function will trigger a MarketCreated event and TokensTransferred event if the Market is created successfully.

This transaction will fail if:

• p._designatedReporterAddress is set to the null address.
• p._numTicks is less than 2.
• p._feePerEthInWei is greater than the maximum fee (0.5 ETH).
• p._endTime has already passed.
• The Universe is Forking.

NOTE: The account attempting to create the new market must have sufficient REP in order for the market to be created. This is also true when calling eth_estimateGas, which essentially does a trial run of the transaction to determine what the gas cost would be to actually run it.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Universe in which to create this market.
  • p._endTime (number) Market expiration timestamp, in seconds.
  • p._feePerEthInWei (string) <optional> Amount of wei per ether settled that goes to the Market Creator, as a base-10 string.
  • p._denominationToken (string) Ethereum address of the token used as this Market’s currency.
  • p._minPrice (string) Minimum display (non-normalized) price for this Market, as a base-10 string.
  • p._maxPrice (string) Maximum display (non-normalized) price for this Market, as a base-10 string.
  • p._designatedReporterAddress (string) Ethereum address of this Market’s Designated Reporter.
  • p._topic (string) The topic (category) to which this Market belongs, as a UTF8 string. Note: This string is limited to 32-characters.
  • p._description (string) Description of the Market, as a UTF8 string.
  • p.tickSize (string) <optional> The Tick size for this Market, as a base-10 string.
  • p._extraInfo (ExtraInfo) <optional> Extra info which will be converted to JSON and logged to the chain in the MarketCreated event.
  • p.meta (Meta) <optional> Authentication metadata for raw transactions.
  • p.onSent (function) Called if/when the createScalarMarket transaction is broadcast to the network.
  • p.onSuccess (function) Called if/when the createScalarMarket transaction is sealed and confirmed.
  • p.onFailed (function) Called if/when the createScalarMarket transaction fails.

Returns:

• (Object) Object containing information about the Market creation transaction. The callReturn property of this object contains the Ethereum address of the Market that was created.

augur.createMarket.createYesNoMarket(p)

Creates a Yes/No Market in a specified Universe. This function will trigger a MarketCreated event and TokensTransferred event if the Market is created successfully.

This transaction will fail if:

• p._designatedReporterAddress is set to the null address.
• p._feePerEthInWei is greater than the maximum fee (0.5 ETH).
• p._endTime has already passed.
• The Universe is Forking.

NOTE: The account attempting to create the new market must have sufficient REP in order for the market to be created. This is also true when calling eth_estimateGas, which essentially does a trial run of the transaction to determine what the gas cost would be to actually run it.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Universe in which to create a Yes/No Market.
  • p._endTime (number) Yes/No Market expiration timestamp, in seconds.
  • p._feePerEthInWei (string) <optional> Amount of wei per ether settled that goes to the Market Creator, as a base-10 string.
  • p._denominationToken (string) Ethereum address of the token used as this Market’s currency.
  • p._designatedReporterAddress (string) Ethereum address of this Market’s Designated Reporter.
  • p._topic (string) The topic (category) to which this Market belongs, as a UTF8 string. Note: This string is limited to 32-characters.
  • p._description (string) Description of the Market, as a UTF8 string.
  • p._extraInfo (ExtraInfo) <optional> Extra info which will be converted to JSON and logged to the chain in the MarketCreated event.
  • p.meta (Meta) <optional> Authentication metadata for raw transactions.
  • p.onSent (function) Called if/when the createYesNoMarket transaction is broadcast to the network.
  • p.onSuccess (function) Called if/when the createYesNoMarket transaction is sealed and confirmed.
  • p.onFailed (function) Called if/when the createYesNoMarket transaction fails.

Returns:

• (Object) Object containing information about the Market creation transaction. The callReturn property of this object contains the Ethereum address of the Market that was created.

augur.createMarket.getMarketCreationCost(p, callback)

Retrieves the No-Show Bond amount and total Ether required to create a new Market.

Note: This function will send a transaction if needed to create the current Fee Window.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Universe on which to create this Market.
• callback (function) Called after the Market creation cost has been looked up.

Returns:

• (MarketCreationCost) Costs of creating a new Market.

augur.createMarket.getMarketCreationCostBreakdown(p, callback)

Similar to augur.createMarket.getMarketCreationCost, but provides more detail about the ether costs required to create a new Market. These Ether costs are broken down by the gas cost paid to the First Public Reporter and the cost of the Validity Bond.

Note: This function will send a transaction if needed to create the current Fee Window.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Universe on which to create this Market.
• callback (function) Called when all Market creation costs have been looked up.

Returns:

• (MarketCreationCostBreakdown) Cost breakdown for creating a new Market.

augur.createMarket.getMarketFromCreateMarketReceipt(transactionHash, callback)

Uses a transaction hash to query an Augur Node for the address of the Market created by that transaction.

Parameters:

• transactionHash (string) Hash returned in the receipt of the transaction that created the Market, as a 32-byte hexadecimal string.
• callback (function) Called when all Market creation costs have been looked up.

Returns:

• (string) Ethereum contract address of the Market that was created in the transaction with the specified hash, as a 20-byte hexadecimal value.

Generate Contracts API Function

// No examples for Generate Contracts Simplified API

augur.generateContractApi(functionsAbi)

Generates a set of JavaScript bindings for the Solidity ABIs passed in.

Parameters:

• functionsAbi (Object) Parameters object.

Returns:

• (Array) Two-dimensional array of contracts APIs, keyed by contract name and function name.

Get Gas Price Function

// Get Gas Price Simplified API Example:
augur.getGasPrice(function (result) {
  console.log(result);
});
// example output:
1000000000

augur.getGasPrice(newGasPriceFunction)

Returns the current gas price.

Parameters:

• newGasPriceFunction (function) Callback function to be used to retrieve the current gas price. By default, ethrpc’s getGasPrice function will be called, and the result will be passed into this callback function.

Returns:

• (Number) Current gas price.

Markets Functions

// Markets Simplified API Examples:

augur.markets.getCategories({
  universe: "0x000000000000000000000000000000000000000b",
}, function (error, result) {
  console.log(result);
});
// example output:
[
  {
    "categoryName": "TEST CATEGORY",
    "nonFinalizedOpenInterest": "4.16",
    "openInterest": "4.16",
    "liquidityTokens": "16",
    "tags": [
      {"nonFinalizedOpenInterest": "0", "numberOfMarketsWithThisTag": 6, "openInterest": "0", "liquidityTokens": "6", "tagName": "test tag 1"},
      {"nonFinalizedOpenInterest": "0", "numberOfMarketsWithThisTag": 6, "openInterest": "0", "liquidityTokens": "6", "tagName": "test tag 2"},
      {"nonFinalizedOpenInterest": "0", "numberOfMarketsWithThisTag": 2, "openInterest": "0", "liquidityTokens": "2", "tagName": "Finance"},
      {"nonFinalizedOpenInterest": "0", "numberOfMarketsWithThisTag": 2, "openInterest": "0", "liquidityTokens": "2", "tagName": "Augur"},
      {"nonFinalizedOpenInterest": "0", "numberOfMarketsWithThisTag": 1, "openInterest": "0", "liquidityTokens": "1", "tagName": "politics"},
      {"nonFinalizedOpenInterest": "0", "numberOfMarketsWithThisTag": 1, "openInterest": "0", "liquidityTokens": "1", "tagName": "ethereum"},
      {"nonFinalizedOpenInterest": "0", "numberOfMarketsWithThisTag": 5, "openInterest": "0", "liquidityTokens": "5", "tagName": "tagging it"},
      {"nonFinalizedOpenInterest": "0", "numberOfMarketsWithThisTag": 5, "openInterest": "0", "liquidityTokens": "5", "tagName": "tagged it"},
    ]
  },
  {
    "categoryName": "TeSt CaTeGoRy",
    "nonFinalizedOpenInterest": "0",
    "openInterest": "0",
    "liquidityTokens": "1",
    "tags": [
      {
        "nonFinalizedOpenInterest": "0",
        "numberOfMarketsWithThisTag": 1,
        "openInterest": "0",
        "liquidityTokens": "1",
        "tagName": "tEsT tag 1",
      },
      {
        "nonFinalizedOpenInterest": "0",
        "numberOfMarketsWithThisTag": 1,
        "openInterest": "0",
        "liquidityTokens": "1",
        "tagName": "test tag 2",
      },
    ],
  },
]

augur.markets.getMarketPriceHistory({
  marketId: "0x0000000000000000000000000000000000000001",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  0: [
    {
      price: "5.5",
      amount: "0.2",
      timestamp: 1506474500,
    }, {
      amount: "2",
      price: "4.2",
      timestamp: 1509065474,
    },
  ],
}

augur.markets.getMarkets({
  universe: "0x000000000000000000000000000000000000000b",
  search: "category: Ethereum OR tags: ETH"
}, function (error, result) {
  console.log(result);
});
// example output:
[
  "0x98c189f9254b5729eb870688f812b83ebd116798",
  "0xa47f967c4806d34859ec93013be5ebc4d68f3a64",
  "0xfa26157e03f05ca681997e63db25af1a95239243",
]

augur.markets.getMarketsClosingInDateRange({
  universe: "0x000000000000000000000000000000000000000b",
  earliestClosingTime: 1506573450,
  latestClosingTime: 1506573470,
  limit: 10,
}, function (error, result) {
  console.log(result);
});
// example output:
[
  "0x0000000000000000000000000000000000000001",
]

augur.markets.getMarketsInfo({
  marketIds: [
    "0x0000000000000000000000000000000000000001",
    "0x0000000000000000000000000000000000000002",
  ],
}, function (error, result) {
  console.log(result);
});
// example output:
[
  0: {
    id: "0x0000000000000000000000000000000000000001",
    universe: "0x000000000000000000000000000000000000000b",
    marketType: "categorical",
    numOutcomes: 8,
    minPrice: "0",
    maxPrice: "1",
    cumulativeScale: "1",
    author: "0x0000000000000000000000000000000000000b0b",
    creationTime: 1506473474,
    creationBlock: 1400000,
    creationFee: "10",
    settlementFee: "0.04",
    reportingFeeRate: "0.02",
    marketCreatorFeeRate: "0.02",
    marketCreatorFeesBalance: "0",
    marketCreatorMailbox: "0xbbb0000000000000000000000000000000000001",
    marketCreatorMailboxOwner: "0x0000000000000000000000000000000000000b0b",
    initialReportSize: null,
    category: "TEST CATEGORY",
    tags: ["test tag 1", "test tag 2"],
    volume: "0",
    openInterest: "0",
    outstandingShares: "0",
    reportingState: "DESIGNATED_REPORTING",
    forking: 0,
    needsMigration: 0,
    feeWindow: "0x1000000000000000000000000000000000000000",
    endTime: 1506573470,
    finalizationBlockNumber: null,
    finalizationTime: null,
    lastTradeBlockNumber: 1506578,
    lastTradeTime: 1506573370,
    description: "This is a categorical test market created by b0b.",
    scalarDenomination: null,
    details: null,
    designatedReporter: "0x0000000000000000000000000000000000000b0b",
    designatedReportStake: "10",
    resolutionSource: "https://www.trusted-third-party.com",
    numTicks: "10000",
    tickSize: "0.0001",
    consensus: {
      isInvalid: false,
      payout: [
        "0",
        "10000",
      ],
    },
    outcomes: [{
      id: 0,
      volume: "100",
      price: "0.125",
      description: "outcome 0",
    }, {
      id: 1,
      volume: "100",
      price: "0.125",
      description: "outcome 1",
    }, {
      id: 2,
      volume: "100",
      price: "0.125",
      description: "outcome 2",
    }, {
      id: 3,
      volume: "100",
      price: "0.125",
      description: "outcome 3",
    }, {
      id: 4,
      volume: "100",
      price: "0.125",
      description: "outcome 4",
    }, {
      id: 5,
      volume: "100",
      price: "0.125",
      description: "outcome 5",
    }, {
      id: 6,
      volume: "100",
      price: "0.125",
      description: "outcome 6",
    }, {
      id: 7,
      volume: "100",
      price: "0.125",
      description: "outcome 7",
    }],
  },
  1: {
    id: "0x0000000000000000000000000000000000000002",
    universe: "0x000000000000000000000000000000000000000b",
    marketType: "yesNo",
    numOutcomes: 2,
    minPrice: "0",
    maxPrice: "1",
    cumulativeScale: "1",
    author: "0x0000000000000000000000000000000000000b0b",
    creationTime: 1506480000,
    creationBlock: 1400100,
    creationFee: "10",
    settlementFee: "0.04",
    reportingFeeRate: "0.02",
    marketCreatorFeeRate: "0.02",
    marketCreatorFeesBalance: "0",
    marketCreatorMailbox: "0xbbb0000000000000000000000000000000000002",
    marketCreatorMailboxOwner: "0x0000000000000000000000000000000000000b0b",
    initialReportSize: null,
    category: "TEST CATEGORY",
    tags: ["test tag 1", "test tag 2"],
    volume: "0",
    openInterest: "0",
    outstandingShares: "0",
    reportingState: "DESIGNATED_REPORTING",
    forking: 0,
    needsMigration: 0,
    feeWindow: "0x1000000000000000000000000000000000000000",
    endTime: 1506573480,
    finalizationBlockNumber: null,
    finalizationTime: null,
    lastTradeBlockNumber: 1506579,
    lastTradeTime: 1506573380,
    description: "This is a yesNo test market created by b0b.",
    scalarDenomination: null,
    details: null,
    designatedReporter: "0x0000000000000000000000000000000000000b0b",
    designatedReportStake: 10,
    resolutionSource: "http://www.trusted-third-party.com",
    numTicks: "10000",
    consensus: {
      isInvalid: false,
      payout: [
        "0",
        "10000",
      ],
    },
    outcomes: [{
      id: 0,
      volume: 1000,
      price: 0.5,
      description: "outcome 0",
    }, {
      id: 1,
      volume: "1000",
      price: "0.5",
      description: "outcome 1",
    }],
  }
]

augur.markets.getUnclaimedMarketCreatorFees({
  marketIds: [
    "0x0000000000000000000000000000000000000001",
    "0x0000000000000000000000000000000000000002"
  ]
}, function(error, result) {
  console.log(result);
});
// example output:
[
  0: {
    marketId: "0x0000000000000000000000000000000000000001",
    unclaimedFee: "0",
  },
  1: {
    marketId: "0x0000000000000000000000000000000000000002",
    unclaimedFee: "0",
  }
]

augur.markets.getCategories(p, callback)

Returns the Market Categories in a specific Universe.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Contract address of the Universe from which to retrieve the categories, as a 20-byte hexadecimal string.
• callback (function) Called after the categories have been retrieved.

Returns:

• (Array.<Category>) Array representing the categories in the specified Universe.

augur.markets.getMarketPriceHistory(p, callback)

Returns the prices and timestamps of a specific Market’s Outcomes over time.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.marketId (string) Market contract address for which to look up orders, as a 20-byte hexadecimal string.
• callback (function) Called after the price time-series has been received and parsed.

Returns:

• (MarketPriceTimeSeries) The Market’s price time-series, keyed by outcome ID.

augur.markets.getMarkets(p, callback)

Returns an array of Markets in a specific Universe.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Contract address of the Universe from which to get transfer history.
  • p.creator (string) <optional> Ethereum address of a Market Creator by which to filter the returned results, as a 20-byte hexadecimal string.
  • p.category (string) <optional> Market category by which to filter the returned results.
  • p.search (string) <optional> Query string used to determine which Markets are returned by augur.markets.getMarkets. By default, a full-text search will be performed on this string. However, it is also possible to search across specific market properties, by specifying marketId, category, tags, shortDescription, longDescription, resolutionSource, and scalarDenomination. For example, to search within market categories, p.search can be set to “category: ETH”. More complex queries can be formed using “AND” and “OR”. For example, setting p.search to “category: Ethereum OR tags: ETH” will search for all markets with the category “Ethereum” or the tag “ETH”.
  • p.reportingState (string|Array<string>) <optional> REPORTING_STATE (or array of REPORTING_STATEs) by which to filter the returned results.
  • p.feeWindow (string) <optional> Ethereum address of a Fee Window by which to filter the returned results, as a 20-byte hexadecimal string.
  • p.designatedReporter (string) <optional> Ethereum address of a Designated Reporter by which to filter the returned results, as a 20-byte hexadecimal string.
  • p.maxFee (number) <optional> Maximum trading Settlement Fee by which to filter the returned results, as a decimal number. (For example, if the desired maximum Settlement Fee is 1.0201%, maxFee should be set to 0.010201.)
  • p.maxEndTime (number) <optional> Maximum Market end time by which to filter Markets, as a Unix timestamp.
  • p.liquiditySortSpreadPercent (number) <optional> Must be included if and only if p.sortBy is set to “liquidityTokens”. Each Market has liquidityTokens defined for multiple Spread Percents. p.liquiditySortSpreadPercent determines which of these is included in markets result set.
  • p.enableInvalidFilter (boolean) <optional> If set to true, Markets detected as potentially Invalid will not be returned.
  • p.hasOrders (boolean) <optional> If set to true, only Markets having Open Orders on the Order Book will be returned. Defaults to false.
  • p.sortBy (string) <optional> Field name by which to sort the Markets.
  • p.isSortDescending (boolean) <optional> Whether to sort the Markets in descending order by sortBy field.
  • p.limit (number) <optional> Maximum number of Markets to return.
  • p.offset (number) <optional> Number of Markets to truncate from the beginning of the results.
• callback (function) Called after the Markets have been retrieved.

Returns:

• (Array.<string>) Array of Market addresses in the Universe, as hexadecimal strings.

augur.markets.getMarketsClosingInDateRange(p, callback)

Returns the Markets closing between a given time range in a specific Universe.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Contract address of the Universe from which to get the Markets, as a 20-byte hexadecimal string.
  • p.earliestClosingTime (number) Earliest Market close timestamp at which to truncate Market results, in seconds.
  • p.latestClosingTime (number) Latest Market close timestamp at which to truncate Market results, in seconds.
  • p.sortBy (string) <optional> Field name by which to sort the Markets.
  • p.isSortDescending (boolean) <optional> Whether to sort the Markets in descending order by sortBy field.
  • p.limit (number) <optional> Maximum number of Markets to return.
  • p.offset (number) <optional> Number of Markets to truncate from the beginning of the results.
• callback (function) Called after the Markets have been retrieved.

Returns:

• (Array.<string>) Array of closing Market addresses, as hexadecimal strings.

augur.markets.getMarketsInfo(p, callback)

Returns information about Markets that are stored on-contract. The returned result includes basic information about the Markets as well as information about each Market Outcome. It does not include Order Book information; however the function augur.trading.getOrders can be used to get information about Orders for the specified Market.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.marketIds (Array.<string>) Contract addresses of the Markets for which to get details, as hexadecimal strings.
• callback (function) Called after the Market info has been retrieved.

Returns:

• (Array.<MarketInfo>) Array of MarketInfo objects.

augur.markets.getUnclaimedMarketCreatorFees(p, callback)

Returns the amount of unclaimed Creator Fees in a set of Markets. Fees are only available on Finalized Markets.

Parameters:

• p (Object) Parameters object.
  • p.marketIds (Array.<string>) Contract addresses of the Markets for which to get unclaimed Creator Fees, as 20-byte hexadecimal values.
• callback (function) Called after the Market Creator Fee information has been retrieved.

Returns:

• (Array.<MarketCreatorFee>>) Array of MarketCreatorFee objects.

Reporting Functions

// Reporting Simplified API Examples:

augur.reporting.claimReportingFeesForkedMarket({
  redeemer: "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
  forkedMarket: {
    crowdsourcers: [
      {
        crowdsourcerId: "0xfc2355a7e5a7adb23b51f54027e624bfe0e23001",
        needsFork: true,
      },
      {
        crowdsourcerId: "0xfc2355a7e5a7adb23b51f54027e624bfe0e23002",
        needsFork: false,
      },
    ],

    initialReporter: {
      initialReporterId: "0xfd2355a7e5a7adb23b51f54027e624bfe0e23001",
      needsFork: false,
    },
  },
  estimateGas: false,
  onSent(result) { },
  onSuccess(result) { console.log(result); },
  onFailed(errors) { console.log(errors); },
});
// example output:
{
  successfulTransactions: {
    crowdsourcerForkAndRedeem: [ 
      "0xfc2355a7e5a7adb23b51f54027e624bfe0e23001",
    ],
    initialReporterForkAndRedeem: [],
    crowdsourcerRedeem: [ 
      "0xfc2355a7e5a7adb23b51f54027e624bfe0e23002",
    ],
    initialReporterRedeem: [
      "0xfd2355a7e5a7adb23b51f54027e624bfe0e23001",
    ],
  }
}

augur.reporting.claimReportingFeesNonforkedMarkets({
  "redeemer": "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Eb",
  "feeWindows": [],
  "nonforkedMarkets": [
    {
      "marketId": "0xbeb2f42f5f495c0581893117eb210e5e9666170e",
      "crowdsourcersAreDisavowed": false,
      "isFinalized": true,
      "crowdsourcers": [],
      "initialReporter": "0x072e9db2836dc569f6173a8d56a25dfd4cbacc1c"
    }
  ],
  "estimateGas": true,
  onSent(result) { console.log(result); },
  onSuccess(result) { console.log(result); },
  onFailed(errors) { console.log(errors); },
});
// example output:
{
  "successfulTransactions": {
    "disavowCrowdsourcers": [],
    "feeWindowRedeem": [],
    "crowdsourcerRedeem": [],
    "initialReporterRedeem": [
      "0x072e9db2836dc569f6173a8d56a25dfd4cbacc1c"
    ]
  }
}

augur.reporting.finalizeMarket({
  market: "0x0000000000000000000000000000000000000011",
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function(result) { console.log(result); },
  onSuccess: function(result) { console.log(result); },
  onFailed: function(result) { console.log(result); }
});
// This function does not return a value.

var secondsInFeeWindow = 604800;
var currentTimestamp = 1518648436;
augur.reporting.getCurrentPeriodProgress(secondsInFeeWindow, currentTimestamp);
// example output:
99.27843915343915

augur.reporting.getDisputeInfo({
  marketIds: [
    "0x0000000000000000000000000000000000000211",
    "0x0000000000000000000000000000000000000011",
  ],
  account: "0x0000000000000000000000000000000000000021",
}, function (error, result) {
  console.log(result);
});
// example output:
[
  {
    marketId: "0x0000000000000000000000000000000000000211",
    stakeCompletedTotal: "102",
    bondSizeOfNewStake: "204",
    stakes: [
      {
        payout: [
          "10000",
          "0",
        ],
        isInvalid: false,
        bondSizeCurrent: "204",
        stakeCurrent: "0",
        accountStakeCurrent: "0",
        accountStakeTotal: "0",
        stakeRemaining: "204",
        bondSizeTotal: "204",
        accountStakeCompleted: "0",
        stakeCompleted: "0",
        tentativeWinning: false,
      },
      {
        payout: [
          "0",
          "10000",
        ],
        isInvalid: false,
        accountStakeCompleted: "102",
        stakeCurrent: "0",
        stakeCompleted: "102",
        tentativeWinning: true,
      },
      {
        payout: [
          "5000",
          "5000",
        ],
        isInvalid: true,
        bondSizeCurrent: "204",
        stakeCurrent: "20",
        accountStakeCurrent: "0",
        accountStakeTotal: "0",
        stakeRemaining: "184",
        bondSizeTotal: "204",
        accountStakeCompleted: "0",
        stakeCompleted: "0",
        tentativeWinning: false,
      },
    ],
    disputeRound: 1,
  },
  {
    marketId: "0x0000000000000000000000000000000000000011",
    stakeCompletedTotal: "30102",
    bondSizeOfNewStake: "60204",
    stakes: [
      {
        payout: [
          "0",
          "2",
        ],
        isInvalid: false,
        bondSizeCurrent: "30000",
        stakeCurrent: "30000",
        accountStakeCurrent: "102",
        accountStakeTotal: "204",
        stakeRemaining: "0",
        bondSizeTotal: "40102",
        accountStakeCompleted: "102",
        stakeCompleted: "10102",
        tentativeWinning: false,
      },
      {
        payout: [
          "1",
          "1",
        ],
        isInvalid: true,
        accountStakeCompleted: "0",
        stakeCurrent: "0",
        stakeCompleted: "20000",
        tentativeWinning: true,
      },
    ],
    disputeRound: 3,
  },
]

augur.reporting.getDisputeTokens({
  universe: "0x000000000000000000000000000000000000000b",
  account: "0x0000000000000000000000000000000000000021",
  disputeTokenState: "UNFINALIZED",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  "0x0000000000000000001000000000000000000001": {
    disputeToken: "0x0000000000000000001000000000000000000001",
    marketId: "0x0000000000000000000000000000000000000011",
    payout0: "0",
    payout1: "2",
    payout2: null,
    payout3: null,
    payout4: null,
    payout5: null,
    payout6: null,
    payout7: null,
    isInvalid: false,
    balance: "17",
    winningToken: null,
    tentativeWinning: 0,
    claimed: false,
    reportingState: "CROWDSOURCING_DISPUTE",
  },
}

augur.reporting.getFeeWindowCurrent({
  universe: "0x000000000000000000000000000000000000000b",
  reporter: "0x0000000000000000000000000000000000000b0b",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  endTime: 1509670273,
  feeToken: "0x1230000000000000000000000000000000000000",
  feeWindow: "0x2000000000000000000000000000000000000000",
  feeWindowEthFees: "2000",
  feeWindowFeeTokens: "100",
  feeWindowId: 457,
  feeWindowParticipationTokens: "1000",
  feeWindowRepStaked: "1100",
  participantContributions: "102",
  participantContributionsCrowdsourcer: "0",
  participantContributionsInitialReport: "102",
  participantParticipationTokens: "30",
  participationTokens: "30",
  startTime: 1509065473,
  totalStake: "132",
  universe: "0x000000000000000000000000000000000000000b",
}

augur.reporting.getFeeWindows({
  universe: "0x000000000000000000000000000000000000000b",
  account: "0x0000000000000000000000000000000000000021",
  includeCurrent: true,
}, function (error, result) {
  console.log(result);
});
// example output:
{
  "0x1000000000000000000000000000000000000000": {
    startTime: 1506473473,
    endTime: 1506473515,
    balance: "100",
    expectedFees: "333.33333333333333333333",
  },
  "0x2000000000000000000000000000000000000000": {
    startTime: 1509065473,
    endTime: 1506473515,
    balance: "500",
    expectedFees: "909.09090909090909090909",
  },
}

augur.reporting.getInitialReporters({
  universe: "0x000000000000000000000000000000000000000b",
  reporter: "0x0000000000000000000000000000000000000b0b",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  "0x0000000000000000000000000000000000abe111": {
    amountStaked: "102",
    blockNumber: 1400100,
    initialReporter: " 0x0000000000000000000000000000000000abe111",
    isDesignatedReporter: 1,
    logIndex: 0,
    marketId: " 0x0000000000000000000000000000000000000019",
    redeemed: 0,
    repBalance: "4000000",
    reporter: " 0x0000000000000000000000000000000000000b0b",
    timestamp: 1506480000,
    transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000E00",
  },
  "0x0000000000000000000000000000000000abe123": {
    marketId: "0x0000000000000000000000000000000000000011",
    blockNumber: 1400100,
    logIndex: 0,
    timestamp: 1506480000,
    transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000E00",
    reporter: "0x0000000000000000000000000000000000000b0b",
    amountStaked: "102",
    initialReporter: "0x0000000000000000000000000000000000abe123",
    redeemed: 0,
    isDesignatedReporter: 0,
    repBalance: "2000",
  },
  "0x0000000000000000000000000000000000abe321": {
    marketId: "0x0000000000000000000000000000000000000211",
    blockNumber: 1400100,
    logIndex: 0,
    timestamp: 1506480000,
    transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000E00",
    reporter: "0x0000000000000000000000000000000000000b0b",
    amountStaked: "102",
    initialReporter: "0x0000000000000000000000000000000000abe321",
    redeemed: 0,
    isDesignatedReporter: 1,
    repBalance: "2000",
  },
}

augur.reporting.getReportingFees({
  universe: "0x000000000000000000000000000000000000000b",
  reporter: "0x0000000000000000000000000000000000000b0b",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  total: {
    unclaimedEth: "1200",
    unclaimedRepEarned: "0",
    unclaimedRepStaked: "391",
    unclaimedForkEth: "0",
    unclaimedForkRepStaked: "331",
    lostRep: "0",
    participationTokenRepStaked: "60",
    unclaimedParticipationTokenEthFees: "200",
  },
  feeWindows: [
    "0x1000000000000000000000000000000000000000",
  ],
  forkedMarket: {
    crowdsourcers: [
      {
        crowdsourcerId: "0x0000000000000000001000000000000000000006",
        needsFork: true,
      },
    ],
    initialReporter: {
      initialReporterId: "0x0000000000000000000000000000000000abe222",
      needsFork: true,
    },
    isFinalized: 1,
    marketId: "0x00000000000000000000000000000000000000f1",
    universe: "0x000000000000000000000000000000000000000b",
  },
  nonforkedMarkets: [
    {
      marketId: "0x0000000000000000000000000000000000000019",
      crowdsourcers: ["0x0000000000000000001000000000000000000003"],
      crowdsourcersAreDisavowed: false,
      initialReporter: "0x0000000000000000000000000000000000abe111",
      isFinalized: true,
      isMigrated: true,
      universe: "0x000000000000000000000000000000000000000b",
      unclaimedEthFees: "1000",
      unclaimedRepTotal: "331",
    },
  ],
}

augur.reporting.getReportingHistory({
  reporter: "0x0000000000000000000000000000000000000021",
  universe: "0x000000000000000000000000000000000000000b",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  "0x0000000000000000000000000000000000000011": {
    initialReporter: null,
    crowdsourcers: [
      {
        transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000D00",
        logIndex: 0,
        creationBlockNumber: 1400051,
        blockHash: "0x1400051",
        creationTime: 1506474500,
        marketId: "0x0000000000000000000000000000000000000011",
        feeWindow: "0x1000000000000000000000000000000000000000",
        payoutNumerators: ["0", "2"],
        amountStaked: "17",
        crowdsourcerId: "0x0000000000000000001000000000000000000001",
        isCategorical: false,
        isScalar: false,
        isInvalid: false,
        isSubmitted: true,
      },
    ],
  },
  "0x0000000000000000000000000000000000000019": {
    initialReporter: null,
    crowdsourcers: [
      {
        transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000D03",
        logIndex: 0,
        creationBlockNumber: 1400052,
        blockHash: "0x1400052",
        creationTime: 1506474515,
        marketId: "0x0000000000000000000000000000000000000019",
        feeWindow: "0x1000000000000000000000000000000000000000",
        payoutNumerators: ["10000", "0", "0", "0", "0"],
        amountStaked: "229",
        crowdsourcerId: "0x0000000000000000001000000000000000000003",
        isCategorical: false,
        isScalar: false,
        isInvalid: false,
        isSubmitted: true,
      },
    ],
  },
}

augur.reporting.getReportingSummary({
  feeWindow: "0x1000000000000000000000000000000000000000"
}, function (error, result) {
  console.log(result);
});
// example output:
{
  "AWAITING_FINALIZATION": 1,
  "DESIGNATED_REPORTING": 12,
  "CROWDSOURCING_DISPUTE": 2,
  "FINALIZED": 1,
  "PRE_REPORTING": 1,
}

augur.reporting.getStakeRequiredForDesignatedReporter({
    universe: "0x000000000000000000000000000000000000000b"
}, function (error, result) {
  console.log(result);
});
// example output:
"1.2345"

augur.reporting.claimReportingFeesForkedMarket(p)

Claims unclaimed Reporting Fees a user has in any InitialReporter/DisputeCrowdsourcer contracts of a specified Forked Market, or returns a gas estimate for claiming these fees if p.estimateGas is true.

The claiming process works as follows:

• For each InitialReporter/DisputeCrowdsourcer contract of the Forked Market in which the user has unclaimed fees:
  • If DisputeCrowdsourcer.fork/InitialReporter.fork has not been called:
    • Call DisputeCrowdsourcer.forkAndRedeem/InitialReporter.forkAndRedeem
  • Else:
    • Call DisputeCrowdsourcer.redeem/InitialReporter.redeem

Parameters:

• p (Object) Parameters object.
  • p.redeemer (string) Ethereum address attempting to redeem reporting fees, as a hexadecimal string.
  • p.forkedMarket (ClaimReportingFeesForkedMarket) Object containing information about the Forked Market in which the user has unclaimed fees in the current universe .
  • p.estimateGas (boolean) Whether to return gas estimates for the transactions instead of actually making the transactions.
  • p.meta (Meta) <optional> Authentication metadata for raw transactions.
  • p.onSent (function) Called if/when the transactions are broadcast to the network. (Currently used as a placeholder and not actually used by this function.)
  • p.onSuccess (function) Called if/when all transactions are sealed and confirmed.
  • p.onFailed (function) Called if/when all transactions have been attempted and at least one transaction has failed. Error message shows which transactions succeeded and which ones failed.

Returns:

• (ClaimReportingFeesForkedMarketResponse|ClaimReportingFeesForkedMarketGasEstimates) Object containing information about which contracts successfully had fees claimed from them, or a breakdown of gas estimates.

augur.reporting.claimReportingFeesNonforkedMarkets(p)

Claims unclaimed Reporting Fees a user has in the InitialReporter/DisputeCrowdsourcer contracts the specified non-Forked Markets or Participation Tokens of specified Fee Windows. Alternatively, it can return gas estimates for claiming these fees if p.estimateGas is true.

The claiming process works as follows:

• If a Forked Market exists in the current Universe:

  • For all non-Forked Markets in current Universe where the user has unclaimed fees in InitialReporter/DisputeCrowdsourcer contracts:
    • If the non-Forked Market is not Finalized and has not had its Crowdsourcers disavowed:
      • Call Market.disavowCrowdsourcers

• Once the above has been completed:

  • Call FeeWindow.redeem on all Fee Windows in the current Universe where the user has unclaimed Participation Tokens
  • For InitialReporter/DisputeCrowdsourcer contracts of non-Forked Markets:
    • Call DisputeCrowdsourcer.redeem
    • For InitialReporter contracts of non-Forked Markets:
      • If a Forked Market exists in the current Universe:
        • If the InitialReporter contract belongs to a Finalized Market, call InitialReporter.redeem
      • Else call InitialReporter.redeem

Parameters:

• p (Object) Parameters object.
  • p.redeemer (string) Ethereum address attempting to redeem reporting fees, as a hexadecimal string.
  • p.feeWindows (Array.<string>) Array of Fee Window Ethereum contract addresses, as hexadecimal strings.
  • p.nonforkedMarkets (Array.<ClaimReportingFeesNonforkedMarket>) Array of ClaimReportingFeesNonforkedMarket objects.
  • p.estimateGas (boolean) Whether to return gas estimates for the transactions instead of actually making the transactions.
  • p.meta (Meta) <optional> Authentication metadata for raw transactions.
  • p.onSent (function) Called if/when the transactions are broadcast to the network. (Currently used as a placeholder and not actually used by this function.)
  • p.onSuccess (function) Called if/when all transactions are sealed and confirmed.
  • p.onFailed (function) Called if/when all transactions have been attempted and at least one transaction has failed. Error message shows which transactions succeeded and which ones failed.

Returns:

• (ClaimReportingFeesNonforkedMarketsResponse|ClaimReportingFeesNonforkedMarketsGasEstimates) Object containing information about which contracts successfully had fees claimed from them, or a breakdown of gas estimates.

augur.reporting.finalizeMarket(p)

Finalizes a Market, meaning it sets the winning Payout Distribution Hash for the Market, redistributes REP Staked on non-winning Outcomes to REP holders who Staked on the winning Outcome, and distributes the Validity Bond based on whether the Market resolved as Invalid. Then, once the Post-Finalization Waiting Period has elapsed, users can Settle their Shares. This transaction will trigger a MarketFinalized event if the Market Finalized without any errors.

This transaction will fail if:

• The Initial Report has not been submitted.
• The Fee Window has not ended.
• The Market passed in is a Forked Market.

Parameters:

• p (Object) Parameters object.
  • p.market (string) Address of the Market to Finalize, as a hex string.
  • p.meta (Meta) <optional> Authentication metadata for raw transactions.
  • p.onSent (function) Called if/when the transaction is broadcast to the network.
  • p.onSuccess (function) Called if/when the transaction is sealed and confirmed.
  • p.onFailed (function) Called if/when the transaction fails.

Returns:

• This function does not return a value.

augur.reporting.getCurrentPeriodProgress(reportingPeriodDurationInSeconds, timestamp)

Returns the percentage of the current Fee Window that has elapsed.

Parameters:

• reportingPeriodDurationInSeconds (number) Number of seconds in a Fee Window.
• timestamp (number) <optional> Unix timestamp at which to check what percentage of the Fee Window has elapsed. (If not specified, the current Unix timestamp will be used.)

Returns:

• (number) Percentage of the current Fee Window that has elapsed.

augur.reporting.getDisputeInfo(p, callback)

Returns information about the Dispute Stake in a list of Markets.

Parameters:

• p (Object) Parameters object.
  • p.marketIds (Array.<string>) Array of Market Ethereum contract addresses, as 20-byte hexadecimal strings.
  • p.account (string) <optional> Ethereum address (as a 20-byte hexadecimal string) of a user by which to filter the returned results.

Returns:

• (Array.<StakeInfo>) Array of objects containing information about the Dispute Stake in the list of Markets.

augur.reporting.getDisputeTokens(p, callback)

Returns the Dispute Tokens owned by a specific user that are either unclaimed or are in Markets that have not been Finalized.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Contract address of the Universe in which to retrieve the Dispute Tokens, as a 20-byte hexadecimal string.
  • p.account (string) Contract address of the account for which to retrieve the Dispute Tokens, as a 20-byte hexadecimal string.
  • p.stakeTokenState (DISPUTE_TOKEN_STATE) <optional> Token state by which to filter results.
• callback (function) Called after the Dispute Tokens have been retrieved.

Returns:

• (Array.<DisputeToken>) Dispute Token details, keyed by Dispute Token ID.

augur.reporting.getFeeWindowCurrent(p, callback)

Returns information about the current Fee Window. If p.reporter is specified, this returned information will also include the total amount of attoREP the Reporter has Staked in the current Fee Window (this includes attoREP Staked in Initial Reports, as well as attoREP Staked in Dispute Crowdsourcers) and the amount of Participation Tokens the Reporter has purchased in the current Fee Window.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Ethereum contract address of the Universe in which the Fee Windows exist, as a 20-byte hexadecimal string.
  • p.reporter (string) <optional> Ethereum address of a Reporter for which to return the amount of attoREP they have Staked in the current Fee Window.
• callback (function) Called after the Fee Windows have been retrieved.

Returns:

• (FeeWindowCurrent) Object containing information about the current Fee Window.

augur.reporting.getFeeWindows(p, callback)

Returns the Fee Windows where a specific user has unclaimed Reporting Fees.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Ethereum contract address of the Universe in which the Fee Windows exist, as a 20-byte hexadecimal string.
  • p.account (string) Ethereum address of the user who has unclaimed Reporting Fees, as a 20-byte hexadecimal string.
  • p.includeCurrent (boolean) <optional> Whether to include the current Fee Window in the returned results.
• callback (function) Called after the Fee Windows have been retrieved.

Returns:

• (Object) Object containing UnclaimedFeeWindowInfo objects, indexed by the Ethereum address of each FeeWindow contract.

augur.reporting.getInitialReporters(p, callback)

Returns a list of InitialReporter contracts that a given Reporter has Staked REP in, along with how much attoREP was Staked and how much has been redeemed.

Parameters:

• p (Object) Parameters object.
  • p.reporter (string) Ethereum address of a Reporter who has Staked REP in InitialReporter contracts, as a 20-byte hexadecimal string.
  • p.universe (string) Ethereum address of the Universe in which the desired Initial Reporters exist.
  • p.redeemed (boolean) <optional> If true, the returned results will include only InitialReporter contracts where the Reporter has redeemed Staked REP; if false, the returned results will include only InitialReporter contracts where the Reporter has not redeemed Staked REP. If not specified, the results will include all InitialReporters in which the Repoter has Staked REP.
  • p.withRepBalance (boolean) <optional> Whether the InitialReporter contract has a balance greater than 0. If set to true, only InitialReporters with a balance greater than 0 will be returned.
• callback (function) Called after the InitialReporters have been retrieved.

Returns:

• (Object) Object containing InitialReporter objects, keyed by the Ethereum contract address of the InitialReporter.

augur.reporting.getReportingFees(p, callback)

Returns information about the unclaimed ETH and REP Reporting Fees a user has in a specific Universe.

Parameters:

• p (Object) Parameters object.
  • p.reporter (string) Ethereum address of the Reporter for which to retrieve Reporting Fees, as a 20-byte hexadecimal string.
  • p.universe (string) Contract address of the Universe in which to look up the Reporting Fees, as a 20-byte hexadecimal string.

Returns:

• (GetReportingFeesInfo) information about the unclaimed ETH and REP Reporting Fees a user has in a specific Universe.

augur.reporting.getReportingHistory(p, callback)

Returns information about the Reports submitted by a particular user. For Fee Windows that have ended, this includes the Final Outcome of the Market, whether the user’s Report matched that Final Outcome, how much REP the user gained or lost from redistribution, and how much the user earned in Reporting Fees.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.reporter (string) Ethereum address of the Reporter for which to retrieve reporting history, as a 20-byte hexadecimal string.
  • p.universe (string) <optional> Contract address of the Universe in which to look up the reporting history, as a 20-byte hexadecimal string. Either this parameter, the Market ID, or the Fee Window must be specified.
  • p.marketId (string) <optional> Contract address of the Market in which to look up the reporting history, as a 20-byte hexadecimal string. Either this parameter, the Universe, or the Fee Window must be specified.
  • p.feeWindow (string) <optional> Contract address of the Fee Window in which to look up the reporting history, as a 20-byte hexadecimal string. Either this parameter, the Universe, or the Market ID must be specified.
  • p.earliestCreationTime (number) <optional> Earliest timestamp, in seconds, at which to truncate history results. (This timestamp is when the block on the Ethereum blockchain containing the report submission was created.)
  • p.latestCreationTime (number) <optional> Latest timestamp, in seconds, at which to truncate history results. (This timestamp is when the block on the Ethereum blockchain containing the report submission was created.)
  • p.sortBy (string) <optional> Field name by which to sort the reporting history.
  • p.isSortDescending (boolean) <optional> Whether to sort the reporting history in descending order by sortBy field.
  • p.limit (number) <optional> Maximum number of reporting history reports to return.
  • p.offset (number) <optional> Number of reporting history reports to truncate from the beginning of the results.
• callback (function) Called when reporting history has been received and parsed.

Returns:

• (Object) Reporting history, keyed by Universe or Market ID. Each report is of type Report.

augur.reporting.getReportingSummary(p, callback)

Returns the number of Markets in various reporting phases. For a list of all reporting state descriptions, refer to the REPORTING_STATE type definition.

This function will fail if:

• A connection to an Augur Node has not been established.

Parameters:

• p (Object) Parameters object.
  • p.feeWindow (string) Contract address of the Fee Window for which to get the summary, as a 20-byte hexadecimal string.
• callback (function) Called after the reporting summary has been retrieved.

Returns:

• (Object) Summary of the number of Markets in each reporting phase, keyed by reporting phase.

augur.reporting.getStakeRequiredForDesignatedReporter(p, callback)

Returns the amount of REP a Designated Reporter must Stake when submitting a Designated Report in a given Universe.

Parameters:

• p (Object) Parameters object.
  • p.universe (string) Ethereum address of a Universe.
• callback (function) Called after Stake required has been retrieved.

Returns:

• (string) Amount of Stake required for the Designated Reporter on this Universe, as a base-10 string.

Trading Functions

// Trading Simplified API Examples:

augur.trading.calculateProfitLoss({
  trades: [{
    type: "buy",
    amount: "1",
    price: "2",
    maker: false,
  }],
  lastPrice: "2"
});
// example output:
{
  position: "1",
  meanOpenPrice: "2",
  realized: "0",
  queued: "0",
  unrealized: "0"
}

augur.trading.calculateTradeCost({
  displayPrice: "2",
  displayAmount: "10",
  numTicks: "10000",
  maxDisplayPrice: "10",
  minDisplayPrice: "0",
  orderType: 0,
});
// example output:
{
  "cost": "20000000000000000000",
  "onChainAmount": "10000000000000000",
  "onChainPrice": "2000"
}

augur.trading.claimMarketsTradingProceeds({
  markets: [
    "0x0000000000000000000000000000000000000001",
    "0x0000000000000000000000000000000000000002",
  ],
  _shareHolder: "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function(result) { console.log(result); },
  onSuccess: function(result) { console.log(result); },
  onFailed: function(result) { console.log(result); }
});
// example onSuccess output:
[
  "0x0000000000000000000000000000000000000001",
  "0x0000000000000000000000000000000000000002",
]

augur.trading.claimTradingProceeds({
  _market: "0x0000000000000000000000000000000000000001",
  _shareHolder: "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function(result) { console.log(result); },
  onSuccess: function(result) { console.log(result); },
  onFailed: function(result) { console.log(result); }
});
// This function does not return a value.

augur.trading.denormalizePrice({
  minPrice: "0",
  maxPrice: "2",
  normalizedPrice: "0.2",
});
// example output:
"0.4"

// selling: 5 bids, 1 from user, 2 with price too low
augur.trading.filterAndSortByPrice({
  singleOutcomeOrderBookSide: {
    0x1000000000000000000000000000000000000000000000000000000000000000: {
      amount: "2",
      fullPrecisionPrice: "0.6",
      owner: "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
    },
    0x2000000000000000000000000000000000000000000000000000000000000000: {
      amount: "1",
      fullPrecisionPrice: "0.5",
      owner: "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
    },
    0x3000000000000000000000000000000000000000000000000000000000000000: {
      amount: "3",
      fullPrecisionPrice: "0.7",
      owner: "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
    },
    0x4000000000000000000000000000000000000000000000000000000000000000: {
      amount: "42",
      fullPrecisionPrice: "0.4",
      owner: "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
    },
  },
  orderType: 1,
  price: "0.6",
});
// example output:
[
  {
    amount: "3",
    fullPrecisionPrice: "0.7",
    owner: "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
  }, {
    amount: "2",
    fullPrecisionPrice: "0.6",
    owner: "0x8fa56abe36d8dc76cf85fecb6a3026733e0a12ac",
  }
]

augur.trading.generateTradeGroupId();
// example output:
"0x80e8bdd8c5a8178a4ad29b31722f22c768135dff2709437c7a5ebd0a0ec475f1"

augur.trading.getBetterWorseOrders({
  marketId: "0x0000000000000000000000000000000000000001",
  outcome: 0,
  orderType: "buy",
  price: "0.65",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  betterOrderId: "0x1000000000000000000000000000000000000000000000000000000000000000",
  worseOrderId: "0x2000000000000000000000000000000000000000000000000000000000000000",
}

augur.trading.getOrders({
  marketId: "0x0000000000000000000000000000000000000001",
  universe: "0x000000000000000000000000000000000000000b",
  orderType: "buy",
  orderState: "OPEN",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  "0x0000000000000000000000000000000000000001": {
    0: {
      buy: {
        "0x1000000000000000000000000000000000000000000000000000000000000000": {
          orderId: "0x1000000000000000000000000000000000000000000000000000000000000000",
          shareToken: "0x0100000000000000000000000000000000000000",
          transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000A00",
          logIndex: 0,
          owner: "0x0000000000000000000000000000000000000b0b",
          creationTime: 1506473500,
          creationBlockNumber: 1400001,
          orderState: "OPEN",
          price: "0.7",
          amount: "1",
          originalAmount: "1",
          fullPrecisionPrice: "0.7",
          fullPrecisionAmount: "1",
          originalFullPrecisionAmount: "1",
          originalTokensEscrowed: "0.7",
          originalSharesEscrowed: "0",
          tokensEscrowed: "0.7",
          sharesEscrowed: "0",
        },
        "0x2000000000000000000000000000000000000000000000000000000000000000": {
          orderId: "0x2000000000000000000000000000000000000000000000000000000000000000",
          shareToken: "0x0100000000000000000000000000000000000000",
          transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000A01",
          logIndex: 0,
          owner: "0x000000000000000000000000000000000000d00d",
          creationTime: 1506473515,
          creationBlockNumber: 1400002,
          orderState: "OPEN",
          price: "0.6",
          amount: "2",
          originalAmount: "2",
          fullPrecisionPrice: "0.600001",
          fullPrecisionAmount: "2",
          originalFullPrecisionAmount: "2",
          originalTokensEscrowed: "1.200002",
          originalSharesEscrowed: "0",
          tokensEscrowed: "1.200002",
          sharesEscrowed: "0",
        },
        "0x5000000000000000000000000000000000000000000000000000000000000000": {
          orderId: "0x5000000000000000000000000000000000000000000000000000000000000000",
          shareToken: "0x0100000000000000000000000000000000000000",
          transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000A06",
          logIndex: 0,
          owner: "0x0000000000000000000000000000000000000b0b",
          creationTime: 1506473500,
          creationBlockNumber: 1400001,
          orderState: "OPEN",
          price: "0.73",
          amount: "1",
          originalAmount: "1",
          fullPrecisionPrice: "0.73",
          fullPrecisionAmount: "1",
          originalFullPrecisionAmount: "1",
          originalTokensEscrowed: "0.73",
          originalSharesEscrowed: "0",
          tokensEscrowed: "0.73",
          sharesEscrowed: "0",
        },
      },
    },
    1: {
      buy: {
        "0x3000000000000000000000000000000000000000000000000000000000000000": {
          orderId: "0x3000000000000000000000000000000000000000000000000000000000000000",
          shareToken: "0x2000000000000000000000000000000000000000",
          transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000A02",
          logIndex: 0,
          owner: "0x000000000000000000000000000000000000d00d",
          creationTime: 1506473515,
          creationBlockNumber: 1400002,
          orderState: "OPEN",
          price: "0.6",
          amount: "2",
          originalAmount: "2",
          fullPrecisionPrice: "0.6",
          fullPrecisionAmount: "2.0000001",
          originalFullPrecisionAmount: "2.0000001",
          originalTokensEscrowed: "1.20000006",
          originalSharesEscrowed: "0",
          tokensEscrowed: "1.20000006",
          sharesEscrowed: "0",
        },
      },
    },
  },
}

augur.trading.getPositionInMarket({
  address: "0x25ff5dc79a7c4e34254ff0f4a19d69e491201dd3",
  market: "0x2221185d7f125b84ac4a1837a0688d2bb58e8491",
  tickSize: "0.0001",
}, function (error, result) {
  console.log(result);
});
// example output:
["1", "0.5", "1", "0", "0", "1", "1.5"]

augur.trading.getUserTradingHistory({
  account: "0x000000000000000000000000000000000000d00d",
  marketId: "0x0000000000000000000000000000000000000001",
  outcome: 0,
  sortBy: "price",
}, function (error, result) {
  console.log(result);
});
// example output:
[
  {
    transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000C00",
    logIndex: 0,
    orderId: "0x1100000000000000000000000000000000000000000000000000000000000000",
    type: "buy",
    price: "5.5",
    amount: "0.2",
    maker: false,
    marketCreatorFees: "0",
    reporterFees: "0",
    selfFilled: false,
    creator: "0x0000000000000000000000000000000000000b0b",
    filler: "0x000000000000000000000000000000000000d00d",
    settlementFees: "0",
    marketId: "0x0000000000000000000000000000000000000001",
    outcome: 0,
    shareToken: "0x0100000000000000000000000000000000000000",
    timestamp: 1506474500,
    tradeGroupId: null,
  }, {
    amount: "2",
    logIndex: 0,
    maker: false,
    marketCreatorFees: "0",
    marketId: "0x0000000000000000000000000000000000000001",
    orderId: "0x1990000000000000000000000000000000000000000000000000000000000000",
    outcome: 0,
    price: "4.2",
    reporterFees: "0",
    selfFilled: false,
    creator: "0x0000000000000000000000000000000000000b0b",
    filler: "0x000000000000000000000000000000000000d00d",
    settlementFees: "0",
    shareToken: "0x0100000000000000000000000000000000000000",
    timestamp: 1509065474,
    tradeGroupId: null,
    transactionHash: "0x00000000000000000000000000000000000000000000000000000000d3adb33f",
    type: "sell",
  }
]

augur.trading.getUserTradingPositions({
  universe: "0x02149d40d255fceac54a3ee3899807b0539bad60",
  account: "0xE4EC477Bc4Abd2B18225Bb8CBa14BF57867f082B",
}, function (error, result) {
  console.log(result);
});
// example output:
{
  tradingPositions: [
    {
      position: "0.901",
      marketId: "0x37adbd757099107946ceebb1791c5c6acda635fe",
      outcome: 1,
      timestamp: 1556857905,
      netPosition: "0.901",
      realized: "0",
      unrealized: "0.4505",
      total: "0.4505",
      averagePrice: "0.5",
      unrealizedCost: "0.4505",
      realizedCost: "0",
      totalCost: "0.4505",
      realizedPercent: "0",
      unrealizedPercent: "1",
      totalPercent: "1",
      unrealizedRevenue: "0.901",
      frozenFunds: "0.4505",
      lastTradePrice: "1",
      lastTradePrice24hAgo: "1",
      lastTradePrice24hChangePercent: "0",
      unrealizedRevenue24hAgo: "0.901",
      unrealizedRevenue24hChangePercent: "0"
    },
    {
      position: "0.011",
      marketId: "0x76a0067b4d3a6db11187a849b50a076e030e95ce",
      outcome: 1,
      timestamp: 1556857905,
      netPosition: "0.011",
      realized: "0",
      unrealized: "0.00993999999999999999996",
      total: "0.00993999999999999999996",
      averagePrice: "0.09636363636363636364",
      unrealizedCost: "0.00106000000000000000004",
      realizedCost: "0",
      totalCost: "0.00106000000000000000004",
      realizedPercent: "0",
      unrealizedPercent: "9.37735849056603773546",
      totalPercent: "9.37735849056603773546",
      unrealizedRevenue: "0.011",
      frozenFunds: "0.00106",
      lastTradePrice: "1",
      lastTradePrice24hAgo: "1",
      lastTradePrice24hChangePercent: "0",
      unrealizedRevenue24hAgo: "0.011",
      unrealizedRevenue24hChangePercent: "0"
    },
    {
      position: "0",
      marketId: "0x448d1d8280844513c38b2b73bde8a539d0022954",
      outcome: 1,
      timestamp: 1556857905,
      netPosition: "-0.01",
      realized: "0",
      unrealized: "-0.0019",
      total: "-0.0019",
      averagePrice: "0.01",
      unrealizedCost: "0.0099",
      realizedCost: "0",
      totalCost: "0.0099",
      realizedPercent: "0",
      unrealizedPercent: "-0.19191919191919191919",
      totalPercent: "-0.19191919191919191919",
      unrealizedRevenue: "0.008",
      frozenFunds: "0.0099",
      lastTradePrice: "0.2",
      lastTradePrice24hAgo: "0.2",
      lastTradePrice24hChangePercent: "0",
      unrealizedRevenue24hAgo: "0.008",
      unrealizedRevenue24hChangePercent: "0"
    },
    {
      position: "0",
      marketId: "0x6f5a05c21ff65c476d4b91f886984cd9c6797576",
      outcome: 1,
      timestamp: 1556857905,
      netPosition: "-0.1",
      realized: "0",
      unrealized: "-0.21",
      total: "-0.21",
      averagePrice: "40",
      unrealizedCost: "0.92",
      realizedCost: "0",
      totalCost: "0.92",
      realizedPercent: "0",
      unrealizedPercent: "-0.2282608695652173913",
      totalPercent: "-0.2282608695652173913",
      unrealizedRevenue: "0.71",
      frozenFunds: "0.92",
      lastTradePrice: "42.1",
      lastTradePrice24hAgo: "75.9",
      lastTradePrice24hChangePercent: "-0.8028503562945368171",
      unrealizedRevenue24hAgo: "-2.67",
      unrealizedRevenue24hChangePercent: "-1.26591760299625468165"
    },
    {
      position: "0",
      marketId: "0x84c47b8af766f19f14d1deb9bbcd99782422bba4",
      outcome: 1,
      timestamp: 1556857905,
      netPosition: "-0.009",
      realized: "0.0005",
      unrealized: "-0.252",
      total: "-0.2515",
      averagePrice: "12",
      unrealizedCost: "0.288",
      realizedCost: "0.032",
      totalCost: "0.32",
      realizedPercent: "0.015625",
      unrealizedPercent: "-0.875",
      totalPercent: "-0.7859375",
      unrealizedRevenue: "0.036",
      frozenFunds: "0.321",
      lastTradePrice: "40",
      lastTradePrice24hAgo: "51",
      lastTradePrice24hChangePercent: "-0.275",
      unrealizedRevenue24hAgo: "-0.063",
      unrealizedRevenue24hChangePercent: "-1.57142857142857142857"
    }
  ],
  tradingPositionsPerMarket: {
    "0x37adbd757099107946ceebb1791c5c6acda635fe": {
      timestamp: 1556857905,
      marketId: "0x37adbd757099107946ceebb1791c5c6acda635fe",
      realizedPercent: "0",
      unrealizedPercent: "1",
      totalPercent: "1",
      unrealizedRevenue24hChangePercent: "0",
      realized: "0",
      unrealized: "0.4505",
      total: "0.4505",
      unrealizedCost: "0.4505",
      realizedCost: "0",
      totalCost: "0.4505",
      unrealizedRevenue: "0.901",
      frozenFunds: "0.4505",
      unrealizedRevenue24hAgo: "0.901"
    },
    "0x76a0067b4d3a6db11187a849b50a076e030e95ce": {
      timestamp: 1556857905,
      marketId: "0x76a0067b4d3a6db11187a849b50a076e030e95ce",
      realizedPercent: "0",
      unrealizedPercent: "9.37735849056603773546",
      totalPercent: "9.37735849056603773546",
      unrealizedRevenue24hChangePercent: "0",
      realized: "0",
      unrealized: "0.00993999999999999999996",
      total: "0.00993999999999999999996",
      unrealizedCost: "0.00106000000000000000004",
      realizedCost: "0",
      totalCost: "0.00106000000000000000004",
      unrealizedRevenue: "0.011",
      frozenFunds: "0.00106",
      unrealizedRevenue24hAgo: "0.011"
    },
    "0x448d1d8280844513c38b2b73bde8a539d0022954": {
      timestamp: 1556857905,
      marketId: "0x448d1d8280844513c38b2b73bde8a539d0022954",
      realizedPercent: "0",
      unrealizedPercent: "-0.19191919191919191919",
      totalPercent: "-0.19191919191919191919",
      unrealizedRevenue24hChangePercent: "0",
      realized: "0",
      unrealized: "-0.0019",
      total: "-0.0019",
      unrealizedCost: "0.0099",
      realizedCost: "0",
      totalCost: "0.0099",
      unrealizedRevenue: "0.008",
      frozenFunds: "0.0099",
      unrealizedRevenue24hAgo: "0.008"
    },
    "0x6f5a05c21ff65c476d4b91f886984cd9c6797576": {
      timestamp: 1556857905,
      marketId: "0x6f5a05c21ff65c476d4b91f886984cd9c6797576",
      realizedPercent: "0",
      unrealizedPercent: "-0.2282608695652173913",
      totalPercent: "-0.2282608695652173913",
      unrealizedRevenue24hChangePercent: "-1.26591760299625468165",
      realized: "0",
      unrealized: "-0.21",
      total: "-0.21",
      unrealizedCost: "0.92",
      realizedCost: "0",
      totalCost: "0.92",
      unrealizedRevenue: "0.71",
      frozenFunds: "0.92",
      unrealizedRevenue24hAgo: "-2.67"
    },
    "0x84c47b8af766f19f14d1deb9bbcd99782422bba4": {
      timestamp: 1556857905,
      marketId: "0x84c47b8af766f19f14d1deb9bbcd99782422bba4",
      realizedPercent: "0.015625",
      unrealizedPercent: "-0.875",
      totalPercent: "-0.7859375",
      unrealizedRevenue24hChangePercent: "-1.57142857142857142857",
      realized: "0.0005",
      unrealized: "-0.252",
      total: "-0.2515",
      unrealizedCost: "0.288",
      realizedCost: "0.032",
      totalCost: "0.32",
      unrealizedRevenue: "0.036",
      frozenFunds: "0.321",
      unrealizedRevenue24hAgo: "-0.063"
    }
  },
  tradingPositionsTotal: {
    realizedPercent: "0.015625",
    unrealizedPercent: "-0.00207252644567704527",
    totalPercent: "-0.00173968239041764132",
    unrealizedRevenue24hChangePercent: "-1.91891891891891891892",
    realized: "0.0005",
    unrealized: "-0.00346000000000000000004",
    total: "-0.00296000000000000000004",
    unrealizedCost: "1.66946000000000000000004",
    realizedCost: "0.032",
    totalCost: "1.70146000000000000000004",
    unrealizedRevenue: "1.666",
    frozenFunds: "1.70246",
    unrealizedRevenue24hAgo: "-1.813"
  },
  frozenFundsTotal: {
    frozenFunds: "1.70246"
  }
}

augur.trading.normalizePrice({
  minPrice: "0",
  maxPrice: "2",
  price: "0.4",
});
// example output:
"0.2"

augur.trading.placeTrade({
  amount: "10",
  sharesProvided: "0",
  limitPrice: "2",
  minPrice: "1",
  maxPrice: "3",
  numTicks: "10000",
  _direction: 0,
  _market: "0x8092bdf939e23a0e926021ffce5a062d0f598d1f",
  _outcome: 0,
  doNotCreateOrders: false,
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function(result) { console.log(result); },
  onSuccess: function(result) { console.log(result); },
  onFailed: function(result) { console.log(result); }
});
// This function does not return a value, but it calls the function `augur.trading.tradeUntilAmountIsZero`, which logs information to the console as it places Orders. To see this output, refer to the JS sample code for `augur.trading.tradeUntilAmountIsZero`.

augur.trading.simulateTrade({
  orderType: 0,
  outcome: 0,
  shares: "3",
  shareBalances: ["0", "5"],
  tokenBalance: "0",
  minPrice: "0",
  maxPrice: "1",
  numTicks: "10000",
  price: "0.7",
  marketCreatorFeeRate: "0",
  reportingFeeRate: "0.01",
  shouldCollectReportingFees: 1,
  singleOutcomeOrderBook: {
    buy: {
      0x1000000000000000000000000000000000000000000000000000000000000000: {
        amount: "2",
        fullPrecisionPrice: "0.7",
        sharesEscrowed: "2",
        owner: "0x2228238db7ad03e505840bd361dc2f521a72adbc",
      },
    },
    sell: {
      0x2000000000000000000000000000000000000000000000000000000000000000: {
        amount: "2",
        fullPrecisionPrice: "0.7",
        sharesEscrowed: "2",
        owner: "0x2228238db7ad03e505840bd361dc2f521a72adbc",
      },
    },
  },
}, function (error, result) {
  console.log(result);
});
// example output:
{
  sharesFilled: "2",
  settlementFees: "0.006",
  worstCaseFees: "0.009",
  otherSharesDepleted: "3",
  sharesDepleted: "0",
  tokensDepleted: "0",
  shareBalances: ["0", "2"],
}

augur.trading.tradeUntilAmountIsZero({
  _price: "0.5",
  _fxpAmount: "10",
  sharesProvided: "0",
  numTicks: "10000",
  minPrice: "0",
  maxPrice: "1",
  _direction: 0,
  _market: "0x8092bdf939e23a0e926021ffce5a062d0f598d1f",
  _outcome: 0,
  numOutcomes: 2,
  doNotCreateOrders: false,
  meta: {
    accountType: "privateKey",
    address: "0x913dA4198E6bE1D5f5E4a40D0667f70C0B5430Ec",
    signer: [252, 111, 32, 94, 233, 213, 105, 71, 89, 162, 243, 247, 56, 81, 213, 103, 239, 75, 212, 240, 234, 95, 8, 201, 217, 55, 225, 0, 85, 109, 158, 25],
  },
  onSent: function(result) { console.log(result); },
  onSuccess: function(result) { console.log(result); },
  onFailed: function(result) { console.log(result); }
});
// This function does not return a value, but it does log information to the console as it places Orders:
"tradeUntilAmountIsZero: "
{
  "_price": "0.5",
  "_fxpAmount": "10",
  "numTicks": "10000",
  "minPrice": "0",
  "maxPrice": "1",
  "_direction": 0,
  "_market": "0x524925edb7a29cc35d886968253cb5e209655cf4",
  "_outcome": 0,
  "numOutcomes": 2,
  "doNotCreateOrders": false
}
{"cost":"5000000000000000000","onChainAmount":"1000000000000000","onChainPrice":"5000"}
"cost: 5000000000000000000 wei 5 eth"
undefined
"estimated gas cost: 6175000000000000 wei 0.006175 eth"
{
  "hash": "0xb134d37fb8a72957cb26267170ce4ca294e1e3d239622416529b7b795330ca08",
  "callReturn": "0x4bbc239211b4e207eb9a05a071b3a5bb96b5b5573b29d26c18e2c31ffc70d105"
}
"TokensTransferred: "
{
  "from": "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
  "to": "0x524925edb7a29cc35d886968253cb5e209655cf4",
  "value": "5000000000000000000",
  "address": "0xd3a7c274e3e7b1990a9c23bec98adc2b7c448ac5",
  "removed": false,
  "transactionHash": "0xb134d37fb8a72957cb26267170ce4ca294e1e3d239622416529b7b795330ca08",
  "transactionIndex": 0,
  "logIndex": 1,
  "blockNumber": 18336,
  "blockHash": "0xb79a66c248ae8888f49773569ac19bd97ebb565222e4e37e5f903e5a82d9c97d",
  "contractName": "Cash",
  "eventName": "Transfer",
  "sender": "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
  "recipient": "0x524925edb7a29cc35d886968253cb5e209655cf4",
  "token": "0xd3a7c274e3e7b1990a9c23bec98adc2b7c448ac5"
}
"convertLogToTransaction Transfer"
{
  "from": "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
  "to": "0x524925edb7a29cc35d886968253cb5e209655cf4",
  "value": "5000000000000000000",
  "address": "0xd3a7c274e3e7b1990a9c23bec98adc2b7c448ac5",
  "removed": false,
  "transactionHash": "0xb134d37fb8a72957cb26267170ce4ca294e1e3d239622416529b7b795330ca08",
  "transactionIndex": 0,
  "logIndex": 1,
  "blockNumber": 18336,
  "blockHash": "0xb79a66c248ae8888f49773569ac19bd97ebb565222e4e37e5f903e5a82d9c97d",
  "contractName": "Cash",
  "eventName": "Transfer",
  "sender": "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
  "recipient": "0x524925edb7a29cc35d886968253cb5e209655cf4",
  "token": "0xd3a7c274e3e7b1990a9c23bec98adc2b7c448ac5"
}
"Order Created: "
{
  "orderType": "buy",
  "amount": "10",
  "price": "0.5",
  "creator": "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
  "moneyEscrowed": "5000000000000000000",
  "sharesEscrowed": "0",
  "tradeGroupId": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "orderId": "0xe7505184c6ab0bab27793dc2804fb066465541e282c135232fa2ef7e964e2e7d",
  "universe": "0x04252fa3b79b7626ffc87144dafeed0838eecd59",
  "shareToken": "0x9315db4f8e425fa0ba47ae5fce58bbe9e9b18fea",
  "address": "0x25ff5dc79a7c4e34254ff0f4a19d69e491201dd3",
  "removed": false,
  "transactionHash": "0xb134d37fb8a72957cb26267170ce4ca294e1e3d239622416529b7b795330ca08",
  "transactionIndex": 0,
  "logIndex": 2,
  "blockNumber": 18336,
  "blockHash": "0xb79a66c248ae8888f49773569ac19bd97ebb565222e4e37e5f903e5a82d9c97d",
  "contractName": "Augur",
  "eventName": "OrderCreated",
  "marketId": "0x524925edb7a29cc35d886968253cb5e209655cf4",
  "outcome": 0,
  "orderCreator": "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
  "orderState": "OPEN",
  "fullPrecisionPrice": "0.5",
  "fullPrecisionAmount": "10",
  "tokensEscrowed": "5"
}
"convertTradeLogToTransaction CreateOrder"
{
  "0x524925edb7a29cc35d886968253cb5e209655cf4": {
    "0": [
      {
        "orderType": "buy",
        "amount": "10",
        "price": "0.5",
        "creator": "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
        "moneyEscrowed": "5000000000000000000",
        "sharesEscrowed": "0",
        "tradeGroupId": "0x0000000000000000000000000000000000000000000000000000000000000000",
        "orderId": "0xe7505184c6ab0bab27793dc2804fb066465541e282c135232fa2ef7e964e2e7d",
        "universe": "0x04252fa3b79b7626ffc87144dafeed0838eecd59",
        "shareToken": "0x9315db4f8e425fa0ba47ae5fce58bbe9e9b18fea",
        "address": "0x25ff5dc79a7c4e34254ff0f4a19d69e491201dd3",
        "removed": false,
        "transactionHash": "0xb134d37fb8a72957cb26267170ce4ca294e1e3d239622416529b7b795330ca08",
        "transactionIndex": 0,
        "logIndex": 2,
        "blockNumber": 18336,
        "blockHash": "0xb79a66c248ae8888f49773569ac19bd97ebb565222e4e37e5f903e5a82d9c97d",
        "contractName": "Augur",
        "eventName": "OrderCreated",
        "marketId": "0x524925edb7a29cc35d886968253cb5e209655cf4",
        "outcome": 0,
        "orderCreator": "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
        "orderState": "OPEN",
        "fullPrecisionPrice": "0.5",
        "fullPrecisionAmount": "10",
        "tokensEscrowed": "5"
      }
    ]
  }
}
"constructTradingTransaction: CreateOrder "
{
  "orderType": "buy",
  "amount": "10",
  "price": "0.5",
  "creator": "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
  "moneyEscrowed": "5000000000000000000",
  "sharesEscrowed": "0",
  "tradeGroupId": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "orderId": "0xe7505184c6ab0bab27793dc2804fb066465541e282c135232fa2ef7e964e2e7d",
  "universe": "0x04252fa3b79b7626ffc87144dafeed0838eecd59",
  "shareToken": "0x9315db4f8e425fa0ba47ae5fce58bbe9e9b18fea",
  "address": "0x25ff5dc79a7c4e34254ff0f4a19d69e491201dd3",
  "removed": false,
  "transactionHash": "0xb134d37fb8a72957cb26267170ce4ca294e1e3d239622416529b7b795330ca08",
  "transactionIndex": 0,
  "logIndex": 2,
  "blockNumber": 18336,
  "blockHash": "0xb79a66c248ae8888f49773569ac19bd97ebb565222e4e37e5f903e5a82d9c97d",
  "contractName": "Augur",
  "eventName": "OrderCreated",
  "marketId": "0x524925edb7a29cc35d886968253cb5e209655cf4",
  "outcome": 0,
  "orderCreator": "0x913da4198e6be1d5f5e4a40d0667f70c0b5430eb",
  "orderState": "OPEN",
  "fullPrecisionPrice": "0.5",
  "fullPrecisionAmount": "10",
  "tokensEscrowed": "5"
}
"getTradeAmountRemaining initial amount remaining: 1000000000000000 ocs 10 shares"
"starting amount:  1000000000000000 ocs 10 shares"
"remaining amount: 0 ocs 0 shares"
"actual cost:      5000000000000000000 wei 5 eth"
"tradeUntilAmountIsZero: "
{
  "_price": "0.5",
  "_fxpAmount": "0",
  "numTicks": "10000",
  "minPrice": "0",
  "maxPrice": "1",
  "_direction": 0,
  "_market": "0x524925edb7a29cc35d886968253cb5e209655cf4",
  "_outcome": 0,
  "numOutcomes": 2,
  "doNotCreateOrders": false,
  "estimatedCost": null
}
{"cost":"0","onChainAmount":"0","onChainPrice":"5000"}
"cost: 0 wei 0 eth"
null