integration/helpers/flash.ts
"use strict";
import { IFlash } from "../types/types";
import { UnlockedAccounts } from "../constants/accounts";
import Augur from "augur.js";
import connectionEndpoints from "augur.js/scripts/connection-endpoints";
import pushTimestamp from "augur.js/scripts/flash/push-timestamp";
import setAugurTimestamp from "augur.js/scripts/flash/set-timestamp-cmd";
import forceFinalize from "augur.js/scripts/flash/force-finalize";
import tradeCompleteSets from "augur.js/scripts/flash/trade-complete-sets";
import designateReport from "augur.js/scripts/flash/designated-report";
import fillMarketOrders from "augur.js/scripts/flash/fill-market-orders";
import initialReport from "augur.js/scripts/flash/initial-report";
import disputeContribute from "augur.js/scripts/flash/dispute-contribute";
import createMarketOrder from "augur.js/scripts/flash/create-market-order";
import finalizeMarket from "augur.js/scripts/flash/finalize-market";
import { getPrivateKeyFromString } from "augur.js/scripts/dp/lib/get-private-key";
export default class Flash implements IFlash {
augur: Augur;
auth: object;
constructor(contractAddress: string = UnlockedAccounts.CONTRACT_OWNER_PRIV) {
this.augur = new Augur();
this.auth = getPrivateKeyFromString(contractAddress);
this.augur.connect(
connectionEndpoints,
(err: any) => {
if (err) console.error("Augur could not connect");
}
);
}
dispose(): void {
this.augur.destroy();
this.augur = new Augur();
}
setMarketEndTime(marketId: string): Promise<Boolean> {
const oThis = this;
return new Promise<Boolean>((resolve, reject) => {
this.augur.markets.getMarketsInfo(
{ marketIds: [marketId] },
(err: any, marketInfos: any) => {
if (err) reject();
if (!marketInfos || marketInfos.length === 0) reject();
const market = marketInfos[0];
oThis.setTimestamp(market.endTime).then(result => {
if (!result) return reject();
return resolve(result);
});
}
);
});
}
setTimestamp(timestamp: number): Promise<Boolean> {
const args = {
opt: {
timestamp: timestamp
}
};
return this.command(args, setAugurTimestamp);
}
pushSeconds(numberOfSeconds: number) {
const args = {
opt: {
count: numberOfSeconds
}
};
return this.command(args, pushTimestamp);
}
pushDays(numberOfDays: number) {
const args = {
opt: {
count: numberOfDays,
days: true
}
};
return this.command(args, pushTimestamp);
}
pushWeeks(numberOfWeeks: number) {
const args = {
opt: {
count: numberOfWeeks,
weeks: true
}
};
return this.command(args, pushTimestamp);
}
forceFinalize(marketId: string) {
const args = {
opt: {
marketId: marketId
}
};
return this.command(args, forceFinalize);
}
finalizeMarket(marketId: string) {
const args = {
opt: {
marketId: marketId
}
};
return this.command(args, finalizeMarket);
}
tradeCompleteSets(marketId: string) {
const args = {
opt: {
marketId: marketId,
amount: 100000000000000000
}
};
return this.command(args, tradeCompleteSets);
}
designateReport(marketId: string, outcome: string) {
const args = {
opt: {
marketId: marketId,
outcome: outcome
}
};
return this.command(args, designateReport);
}
fillMarketOrders(marketId: string, outcome: string, orderType: string) {
const args = {
opt: {
marketId: marketId,
outcome: outcome,
orderType: orderType
}
};
return this.command(args, fillMarketOrders);
}
initialReport(
marketId: string,
outcome: string,
invalid: boolean = false,
noPush: boolean = false
) {
const args = {
opt: {
marketId: marketId,
outcome: outcome,
invalid: invalid,
noPush: noPush
}
};
return this.command(args, initialReport);
}
disputeContribute(
marketId: string,
outcome: string,
invalid: boolean = false,
noPush: boolean = false,
amount?: string
) {
const args = {
opt: {
marketId: marketId,
outcome: outcome,
invalid: invalid,
noPush: noPush
}
};
if (amount) {
args.opt.amount = amount;
}
return this.command(args, disputeContribute);
}
createMarketOrder(
marketId: string,
outcome: string,
orderType: string,
price: string,
amount: string
) {
const args = {
opt: {
marketId: marketId,
outcome: outcome,
orderType: orderType,
price: price,
amount: amount,
useShares: false
}
};
return this.command(args, createMarketOrder);
}
command(args: object, func: Function) {
return new Promise<Boolean>((resolve, reject) => {
func(this.augur, args, this.auth, (err: object) => {
if (err) return reject();
resolve(true);
});
});
}
}