use Gnosis Deps

packages/augur-sdk/src/Augur.ts

@@ -3,7 +3,8 @@ import { BigNumber } from 'bignumber.js';
 import { Callback, TXStatusCallback } from "./events";
 import { BaseConnector } from "./connector/baseConnector";
 import { ContractAddresses, NetworkId } from "@augurproject/artifacts";
-import { ContractDependenciesEthers, TransactionStatusCallback, TransactionMetadata, TransactionStatus } from "contract-dependencies-ethers";
+import { TransactionStatusCallback, TransactionStatus } from "contract-dependencies-ethers";
+import { ContractDependenciesGnosis } from "contract-dependencies-gnosis";
 import { IGnosisRelayAPI } from "@augurproject/gnosis-relay-api";
 import { ContractInterfaces } from "@augurproject/core";
 import { Contracts } from "./api/Contracts";
@@ -23,12 +24,9 @@ import { isSubscriptionEventName, SubscriptionEventName, TXEventName } from "./c
 import { Liquidity } from "./api/Liquidity";
 import { TransactionResponse } from "ethers/providers";
 
-// TODO ContractDependenciesEthers -> ContractDependenciesGnosis
-// TODO Add hooks for modifying gnosis deps flags
-
 export class Augur<TProvider extends Provider = Provider> {
   readonly provider: TProvider;
-  private readonly dependencies: ContractDependenciesEthers;
+  private readonly dependencies: ContractDependenciesGnosis;
 
   readonly networkId: NetworkId;
   readonly events: Events;
@@ -73,7 +71,7 @@ export class Augur<TProvider extends Provider = Provider> {
     "UniverseForked",
   ];
 
-  constructor(provider: TProvider, dependencies: ContractDependenciesEthers, networkId: NetworkId, addresses: ContractAddresses, connector: BaseConnector = new EmptyConnector(), gnosisRelay: IGnosisRelayAPI = undefined) {
+  constructor(provider: TProvider, dependencies: ContractDependenciesGnosis, networkId: NetworkId, addresses: ContractAddresses, connector: BaseConnector = new EmptyConnector(), gnosisRelay: IGnosisRelayAPI = undefined) {
     this.provider = provider;
     this.dependencies = dependencies;
     this.networkId = networkId;
@@ -93,7 +91,7 @@ export class Augur<TProvider extends Provider = Provider> {
     this.registerTransactionStatusEvents();
   }
 
-  static async create<TProvider extends Provider = Provider>(provider: TProvider, dependencies: ContractDependenciesEthers, addresses: ContractAddresses, connector: BaseConnector = new EmptyConnector(), gnosisRelay: IGnosisRelayAPI = undefined): Promise<Augur> {
+  static async create<TProvider extends Provider = Provider>(provider: TProvider, dependencies: ContractDependenciesGnosis, addresses: ContractAddresses, connector: BaseConnector = new EmptyConnector(), gnosisRelay: IGnosisRelayAPI = undefined): Promise<Augur> {
     // has to be static because of the way we instantiate boundTo methods
     if (!Augur.connector || connector.constructor.name !== "EmptyConnector") {
       Augur.connector = connector;
@@ -146,6 +144,14 @@ export class Augur<TProvider extends Provider = Provider> {
     await this.dependencies.signer.sendTransaction(ethersTransaction);
   }
 
+  setUseGnosisSafe(useSafe: boolean): void {
+    this.dependencies.setUseSafe(useSafe);
+  }
+
+  setUseGnosisRelay(useRelay: boolean): void {
+    this.dependencies.setUseRelay(useRelay);
+  }
+
   getUniverse(address: string): ContractInterfaces.Universe {
     return this.contracts.universeFromAddress(address);
   }

packages/augur-sdk/src/state/create-api.ts

@@ -1,6 +1,6 @@
 import { Augur } from "../Augur";
 import { BlockAndLogStreamerListener } from "./db/BlockAndLogStreamerListener";
-import { ContractDependenciesEthers } from "contract-dependencies-ethers";
+import { ContractDependenciesGnosis } from "contract-dependencies-gnosis";
 import { Controller } from "./Controller";
 import { EthersProvider } from "@augurproject/ethersjs-provider";
 import { EventLogDBRouter } from "./db/EventLogDBRouter";
@@ -10,13 +10,15 @@ import { Addresses, UploadBlockNumbers } from "@augurproject/artifacts";
 import { API } from "./getter/API";
 import DatabaseConfiguration = PouchDB.Configuration.DatabaseConfiguration;
 import { DB } from "./db/DB";
+import { GnosisRelayAPI } from "@augurproject/gnosis-relay-api";
 
 const settings = require("./settings.json");
 
 async function buildDeps(ethNodeUrl: string, account?: string, dbArgs: PouchDB.Configuration.DatabaseConfiguration = {}) {
   const ethersProvider = new EthersProvider(new JsonRpcProvider(ethNodeUrl), 10, 0, 40);
-  const contractDependencies = new ContractDependenciesEthers(ethersProvider, undefined, account);
   const networkId = await ethersProvider.getNetworkId();
+  const gnosisRelay = new GnosisRelayAPI(settings.gnosisRelayURLs[networkId]);
+  const contractDependencies = new ContractDependenciesGnosis(ethersProvider, gnosisRelay, undefined, undefined, undefined, undefined, account);
 
   const augur = await Augur.create(ethersProvider, contractDependencies, Addresses[networkId]);
   const eventLogDBRouter = new EventLogDBRouter(augur.events.parseLogs);

packages/augur-sdk/src/state/settings.json

@@ -1,6 +1,9 @@
 {
     "blockstreamDelay": 10,
     "chunkSize": 100000,
+    "gnosisRelayURLs": {
+        "4": "https://safe-relay.rinkeby.gnosis.pm/api/",
+    },
     "ethNodeURLs": {
         "4": "https://eth-rinkeby.alchemyapi.io/jsonrpc/Kd37_uEmJGwU6pYq6jrXaJXXi8u9IoOM"
     },

packages/augur-sdk/src/state/test-connector.ts

@@ -3,12 +3,14 @@
 //
 import { Addresses } from "@augurproject/artifacts";
 import { Augur } from "../Augur";
-import { ContractDependenciesEthers } from "contract-dependencies-ethers";
+import { ContractDependenciesGnosis } from "contract-dependencies-gnosis";
 import { EthersProvider } from "@augurproject/ethersjs-provider";
 import { JsonRpcProvider } from "ethers/providers";
 import { MarketCreated, NewBlock } from "../events";
 import { SubscriptionEventName } from "../constants";
 import { SEOConnector } from "../connector/seo-connector";
+import { GnosisRelayAPI } from "@augurproject/gnosis-relay-api";
+
 
 const settings = require("@augurproject/sdk/src/state/settings.json");
 
@@ -18,7 +20,8 @@ console.log("Starting web worker");
   try {
     const connector = new SEOConnector();
     const ethersProvider = new EthersProvider(new JsonRpcProvider(settings.ethNodeURLs[4]), 10, 0, 40);
-    const contractDependencies = new ContractDependenciesEthers(ethersProvider, undefined, settings.testAccounts[0]);
+    const gnosisRelay = new GnosisRelayAPI("http://localhost:8000");
+    const contractDependencies = new ContractDependenciesGnosis(ethersProvider, gnosisRelay, undefined, undefined, undefined, undefined, settings.testAccounts[0]);
     const augur = await Augur.create(ethersProvider, contractDependencies, Addresses[4], connector);
     await augur.connect("");
 

packages/augur-test/src/libs/LocalAugur.ts

@@ -1,6 +1,6 @@
 import { Augur } from "@augurproject/sdk";
 import { EthersProvider } from "@augurproject/ethersjs-provider";
-import { Account, makeGanacheProvider, makeSigner, makeDependencies, createDbFromSeed, Seed } from "@augurproject/tools";
+import { Account, makeGanacheProvider, makeSigner, makeGnosisDependencies, createDbFromSeed, Seed } from "@augurproject/tools";
 
 export async function makeProvider(seed: Seed, accounts: Account[]): Promise<EthersProvider> {
   const db = await createDbFromSeed(seed);
@@ -10,7 +10,7 @@ export async function makeProvider(seed: Seed, accounts: Account[]): Promise<Eth
 export async function makeTestAugur(seed: Seed, accounts: Account[]): Promise<Augur> {
   const provider = await makeProvider(seed, accounts);
   const signer = await makeSigner(accounts[0], provider);
-  const dependencies = makeDependencies(accounts[0], provider, signer);
+  const dependencies = makeGnosisDependencies(provider, undefined, signer, undefined, undefined, undefined, accounts[0].publicKey);
 
   return Augur.create(provider, dependencies, seed.addresses);
 }

packages/augur-tools/src/index.ts

@@ -5,6 +5,7 @@ export {
   UsefulContractObjects,
   makeSigner,
   makeDependencies,
+  makeGnosisDependencies,
 } from "./libs/blockchain";
 import * as blockchain from "./libs/blockchain";
 export { blockchain };

packages/augur-tools/src/libs/blockchain.ts

@@ -5,6 +5,8 @@ import { EthersProvider } from "@augurproject/ethersjs-provider";
 import { DeployerConfigurationOverwrite, CreateDeployerConfiguration, EthersFastSubmitWallet } from "@augurproject/core";
 import { ContractAddresses } from "@augurproject/artifacts";
 import { ContractDependenciesEthers } from "contract-dependencies-ethers";
+import { ContractDependenciesGnosis } from "contract-dependencies-gnosis";
+import { IGnosisRelayAPI } from '@augurproject/gnosis-relay-api';
 import { ContractDeployer } from "@augurproject/core";
 
 import { Account } from "../constants";
@@ -45,4 +47,6 @@ export function makeDependencies(account: Account, provider: EthersProvider, sig
   return new ContractDependenciesEthers(provider, signer, account.publicKey);
 }
 
-// TODO make Gnosis Contract Dependencies
+export function makeGnosisDependencies(provider: EthersProvider, gnosisRelay: IGnosisRelayAPI, signer: EthersFastSubmitWallet, gasToken?: string, gasPrice?: BigNumber, safeAddress?: string, address?: string) {
+  return new ContractDependenciesGnosis(provider, gnosisRelay, signer, gasToken, gasPrice, safeAddress, address);
+}

packages/augur-tools/src/libs/contract-api.ts

@@ -10,7 +10,7 @@ import {
 } from "@augurproject/sdk";
 import { ContractInterfaces } from "@augurproject/core";
 import { EthersProvider } from "@augurproject/ethersjs-provider";
-import { makeDependencies, makeSigner } from "./blockchain";
+import { makeDependencies, makeGnosisDependencies, makeSigner } from "./blockchain";
 import { Account } from "../constants";
 import { ContractAddresses } from "@augurproject/artifacts";
 import { BigNumber } from "bignumber.js";
@@ -20,18 +20,16 @@ import { IGnosisRelayAPI } from "@augurproject/gnosis-relay-api";
 
 const NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
 const ETERNAL_APPROVAL_VALUE = new BigNumber("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // 2^256 - 1
+
 export class ContractAPI {
   static async userWrapper(account: Account, provider: EthersProvider, addresses: ContractAddresses, connector: Connectors.SEOConnector = undefined, gnosisRelay: IGnosisRelayAPI = undefined) {
     const signer = await makeSigner(account, provider);
-    // TODO allow choosing to make Gnosis contract deps
-    const dependencies = makeDependencies(account, provider, signer);
+    const dependencies = makeGnosisDependencies(provider, gnosisRelay, signer, NULL_ADDRESS, new BigNumber(0), null, account.publicKey);
     const augur = await Augur.create(provider, dependencies, addresses, connector, gnosisRelay);
 
     return new ContractAPI(augur, provider, account);
   }
 
-  // TODO expose toggles for dependencies
-
   constructor(
     readonly augur: Augur,
     readonly provider: EthersProvider,
@@ -430,6 +428,14 @@ export class ContractAPI {
     return this.augur.contracts.getReputationToken().allowance_(owner, spender);
   }
 
+  setUseGnosisSafe(useSafe: boolean): void {
+    this.augur.setUseGnosisSafe(useSafe);
+  }
+
+  setUseGnosisRelay(useRelay: boolean): void {
+    this.augur.setUseGnosisRelay(useRelay);
+  }
+
   async approveAugurEternalApprovalValue(owner: string) {
     const spender = this.augur.addresses.Augur;
     const allowance = new BigNumber(await this.augur.contracts.cash.allowance_(owner, spender));

packages/contract-dependencies-gnosis/src/ContractDependenciesGnosis.ts

@@ -7,26 +7,27 @@ import { getAddress } from "ethers/utils/address";
 import { abi } from "@augurproject/artifacts";
 import * as _ from "lodash";
 
-const BASE_GAS_ESTIMATE = 75000;
+const DEFAULT_GAS_PRICE = new BigNumber(10**9);
+const BASE_GAS_ESTIMATE = new BigNumber(75000);
 const NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
 
 export class ContractDependenciesGnosis extends ContractDependenciesEthers {
   private readonly gnosisRelay: IGnosisRelayAPI;
   public readonly gasToken: string;
-  public readonly gasPrice: BigNumber;
 
   public safeAddress: string;
 
   public useRelay: boolean = true;
   public useSafe: boolean = false;
+  public gasPrice: BigNumber;
 
   public gnosisSafe: ethers.Contract;
 
-  public constructor(provider: EthersProvider, gnosisRelay: IGnosisRelayAPI, signer: EthersSigner, gasToken: string, gasPrice: BigNumber, safeAddress?: string, address?: string) {
+  public constructor(provider: EthersProvider, gnosisRelay: IGnosisRelayAPI, signer: EthersSigner, gasToken?: string, gasPrice?: BigNumber, safeAddress?: string, address?: string) {
     super(provider, signer, address);
     this.gnosisRelay = gnosisRelay;
-    this.gasToken = gasToken;
-    this.gasPrice = gasPrice;
+    this.gasToken = gasToken ? gasToken : NULL_ADDRESS;
+    this.gasPrice = gasPrice ? gasPrice : DEFAULT_GAS_PRICE;
 
     if (safeAddress) {
       this.setSafeAddress(safeAddress);
@@ -54,6 +55,10 @@ export class ContractDependenciesGnosis extends ContractDependenciesEthers {
     this.useRelay = useRelay;
   }
 
+  public setGasPrice(gasPrice: BigNumber): void {
+    this.gasPrice = gasPrice;
+  }
+
   public async getNonce(): Promise<number> {
     return (await this.gnosisSafe.nonce()).toNumber();
   }
@@ -138,7 +143,7 @@ export class ContractDependenciesGnosis extends ContractDependenciesEthers {
     const refundReceiver = NULL_ADDRESS;
 
     let txHashBytes = await this.gnosisSafe.getTransactionHash(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, nonce);
-    let sig = this.signer.signDigest(ethers.utils.arrayify(txHashBytes));
+    let sig = await this.signer.signDigest(ethers.utils.arrayify(txHashBytes));
 
     const signatures = [{
       s: new BigNumber(sig.s, 16).toFixed(),

tsconfig.json

@@ -27,6 +27,9 @@
     {
       "path": "./packages/contract-dependencies-ethers"
     },
+    {
+      "path": "./packages/contract-dependencies-gnosis"
+    },
     {
       "path": "./packages/blockstream-adapters"
     },

tsconfig.release.json

@@ -26,6 +26,9 @@
     },
     {
       "path": "./packages/contract-dependencies-ethers/tsconfig.release.json"
+    },
+    {
+      "path": "./packages/contract-dependencies-gnosis/tsconfig.release.json"
     }
   ]
 }