Upgrade to Arc v58, Rinkeby contract addresses

config/default.json

@@ -18,6 +18,10 @@
       "host": "127.0.0.1",
       "port": 8546
     },
+    "private": {
+      "host": "127.0.0.1",
+      "port": 8545
+    },
     "ganache": {
       "host": "127.0.0.1",
       "port": 8545

lib/contractWrapperBase.ts

@@ -150,6 +150,7 @@ export abstract class ContractWrapperBase implements IContractWrapper {
 
     const maxGasLimit = await UtilsInternal.computeMaxGasLimit();
 
+    // note that Ganache is identified specifically as the one instantiated by arc.js (by the networkId)
     if (currentNetwork === "Ganache") {
       return maxGasLimit; // because who cares with ganache and we can't get good estimates from it
     }

lib/contractWrapperFactory.ts

@@ -130,6 +130,7 @@ export class ContractWrapperFactory<TWrapper extends IContractWrapper>
 
     const maxGasLimit = await UtilsInternal.computeMaxGasLimit();
 
+    // note that Ganache is identified specifically as the one instantiated by arc.js (by the networkId)
     if (currentNetwork === "Ganache") {
       return maxGasLimit; // because who cares with ganache and we can't get good estimates from it
     }

lib/scripts/createGenesisDao.ts

@@ -26,8 +26,7 @@ interface FounderSpec {
 export class GenesisDaoCreator {
 
   constructor(
-    private web3: Web3,
-    private network: string) {
+    private web3: Web3) {
   }
 
   public async run(): Promise<void> {

lib/wrappers/auction4Reputation.ts

@@ -1,5 +1,6 @@
 "use strict";
 import BigNumber from "bignumber.js";
+import { DecodedLogEntry } from "web3";
 import { Address, Hash } from "../commonTypes";
 import { ContractWrapperFactory } from "../contractWrapperFactory";
 import { ArcTransactionResult, IContractWrapperFactory } from "../iContractWrapperBase";
@@ -92,6 +93,7 @@ export class Auction4ReputationWrapper extends SchemeWrapperBase {
 
   public async redeem(options: Auction4ReputationRedeemOptions & TxGeneratingFunctionOptions)
     : Promise<ArcTransactionResult> {
+
     if (!options.beneficiaryAddress) {
       throw new Error("beneficiaryAddress is not defined");
     }
@@ -104,6 +106,27 @@ export class Auction4ReputationWrapper extends SchemeWrapperBase {
       throw new Error("auctionId must be greater than or equal to zero");
     }
 
+    const errMsg = await this.getRedeemBlocker(options);
+
+    if (errMsg) {
+      throw new Error(errMsg);
+    }
+
+    this.logContractFunctionCall("Auction4Reputation.redeem", options);
+
+    return this.wrapTransactionInvocation("Auction4Reputation.redeem",
+      options,
+      this.contract.redeem,
+      [options.beneficiaryAddress, options.auctionId]
+    );
+  }
+
+  /**
+   * Returns reason why can't redeem, or else null if can redeem
+   * @param lockerAddress
+   */
+  public async getRedeemBlocker(options: Auction4ReputationRedeemOptions): Promise<string | null> {
+
     const redeemEnableTime = await this.getRedeemEnableTime();
     const now = await UtilsInternal.lastBlockDate();
 
@@ -117,13 +140,12 @@ export class Auction4ReputationWrapper extends SchemeWrapperBase {
       throw new Error("the auction period has not passed");
     }
 
-    this.logContractFunctionCall("Auction4Reputation.redeem", options);
+    const bid = await this.getBid(options.beneficiaryAddress, options.auctionId);
+    if (bid.lte(0)) {
+      return "nothing has been bid in this auction";
+    }
 
-    return this.wrapTransactionInvocation("Auction4Reputation.redeem",
-      options,
-      this.contract.redeem,
-      [options.beneficiaryAddress, options.auctionId]
-    );
+    return null;
   }
 
   /**
@@ -201,12 +223,67 @@ export class Auction4ReputationWrapper extends SchemeWrapperBase {
       throw new Error("bidderAddress is not defined");
     }
 
+    if (!Number.isInteger(auctionId)) {
+      throw new Error("auctionId is not an integer");
+    }
+
+    if (auctionId < 0) {
+      throw new Error("auctionId must be greater than or equal to zero");
+    }
+
     this.validateAuctionId(auctionId);
 
     this.logContractFunctionCall("Auction4Reputation.getBid", { bidderAddress, auctionId });
     return this.contract.getBid(bidderAddress, auctionId);
   }
 
+  public async getUserEarnedReputation(options: Auction4ReputationRedeemOptions): Promise<BigNumber> {
+    if (!options.beneficiaryAddress) {
+      throw new Error("beneficiaryAddress is not defined");
+    }
+
+    if (!Number.isInteger(options.auctionId)) {
+      throw new Error("auctionId is not an integer");
+    }
+
+    if (options.auctionId < 0) {
+      throw new Error("auctionId must be greater than or equal to zero");
+    }
+
+    const errMsg = await this.getRedeemBlocker(options);
+
+    if (errMsg) {
+      throw new Error(errMsg);
+    }
+
+    this.logContractFunctionCall("Locking4Reputation.redeem.call", options);
+
+    return this.contract.redeem.call(options.beneficiaryAddress, options.auctionId);
+  }
+
+  /**
+   * get a promise of an array of auction ids and amounts in which the given account has placed a bid,
+   * or all auctions if beneficiaryAddressis not supplied
+   * @param beneficiaryAddress optional
+   */
+  public async getBids(beneficiaryAddress?: Address): Promise<Array<GetBidAuctionIdsResult>> {
+
+    if (!beneficiaryAddress) {
+      throw new Error("beneficiaryAddress is not defined");
+    }
+
+    const filter = beneficiaryAddress ? { _bidder: beneficiaryAddress } : {};
+
+    const bids = await this.Bid(filter).get();
+
+    return bids.map((bid: DecodedLogEntry<Auction4ReputationBidEventResult>): GetBidAuctionIdsResult => {
+      return {
+        amount: bid.args._amount,
+        auctionId: bid.args._auctionId.toNumber(),
+      };
+    });
+  }
+
   /**
    * Get a promise of the first date/time when anything can be redeemed
    */
@@ -399,3 +476,8 @@ export interface Auction4ReputationRedeemEventResult {
    */
   _beneficiary: Address;
 }
+
+export interface GetBidAuctionIdsResult {
+  auctionId: number;
+  amount: BigNumber;
+}

lib/wrappers/contributionReward.ts

@@ -56,6 +56,7 @@ export class ContributionRewardWrapper extends ProposalGeneratorBase {
     : Promise<ArcTransactionProposalResult> {
 
     const defaults = {
+      descriptionIsHashed: false,
       ethReward: "0",
       externalToken: "", // must have a value for solidity
       externalTokenReward: "0",
@@ -154,7 +155,7 @@ export class ContributionRewardWrapper extends ProposalGeneratorBase {
       eventContext,
       this.contract.proposeContributionReward,
       [options.avatar,
-      Utils.SHA3(options.description),
+      options.descriptionIsHashed ? options.description : Utils.SHA3(options.description),
         reputationChange,
       [nativeTokenReward, ethReward, externalTokenReward, options.periodLength, options.numberOfPeriods],
       options.externalToken,
@@ -539,17 +540,16 @@ export class ContributionRewardWrapper extends ProposalGeneratorBase {
 
   private convertProposalPropsArrayToObject(propsArray: Array<any>, proposalId: Hash): ContributionProposal {
     return {
-      beneficiaryAddress: propsArray[6],
-      contributionDescriptionHash: propsArray[0],
-      ethReward: propsArray[3],
-      executionTime: propsArray[9],
-      externalToken: propsArray[4],
-      externalTokenReward: propsArray[5],
-      nativeTokenReward: propsArray[1],
-      numberOfPeriods: propsArray[8],
-      periodLength: propsArray[7],
+      beneficiaryAddress: propsArray[5],
+      ethReward: propsArray[2],
+      executionTime: propsArray[8],
+      externalToken: propsArray[3],
+      externalTokenReward: propsArray[4],
+      nativeTokenReward: propsArray[0],
+      numberOfPeriods: propsArray[7],
+      periodLength: propsArray[6],
       proposalId,
-      reputationChange: propsArray[2],
+      reputationChange: propsArray[1],
     };
   }
 }
@@ -587,7 +587,6 @@ export interface NewContributionProposalEventResult {
 export interface ContributionProposal {
   proposalId: Hash;
   beneficiaryAddress: Address;
-  contributionDescriptionHash: Hash;
   ethReward: BigNumber;
   executionTime: number;
   externalToken: Address;
@@ -747,6 +746,11 @@ export interface ProposeContributionRewardParams {
    *  beneficiary address
    */
   beneficiaryAddress: string;
+  /**
+   * True if description is a hashed, false if not and in which case Arc.js will hash it.
+   * The default is false.
+   */
+  descriptionIsHashed?: boolean;
 }
 
 export interface ContributionRewardRedeemParams {

lib/wrappers/externalLocking4Reputation.ts

@@ -4,6 +4,7 @@ import { Address } from "../commonTypes";
 import { ContractWrapperFactory } from "../contractWrapperFactory";
 import { ArcTransactionResult, IContractWrapperFactory } from "../iContractWrapperBase";
 import { TxGeneratingFunctionOptions } from "../transactionService";
+import { Utils } from "../utils";
 import { Web3EventService } from "../web3EventService";
 import { Locking4ReputationWrapper } from "./locking4Reputation";
 
@@ -39,47 +40,85 @@ export class ExternalLocking4ReputationWrapper extends Locking4ReputationWrapper
     );
   }
 
-  public async getLockBlocker(options: ExternalLockingLockOptions): Promise<string | null> {
-
+  public async getLockBlocker(options: ExternalLockingClaimOptions): Promise<string | null> {
     /**
-     * stub out amount and period -- they aren't relevant to external locking validation.
+     * stub out lockerAddress, amount and period -- they aren't relevant to external locking validation.
      */
-    const msg = await super.getLockBlocker(Object.assign({}, options, { amount: "1", period: 1 }));
+    const msg = await super.getLockBlocker(Object.assign({},
+      { lockerAddress: "0x", amount: "1", period: 1 }
+    ));
+
     if (msg) {
       return msg;
     }
 
-    if (!options.lockerAddress) {
-      return "lockerAddress is not defined";
-    }
-
     const alreadyLocked = await this.getAccountHasLocked(options.lockerAddress);
     if (alreadyLocked) {
       return "this account has already executed a lock";
     }
   }
 
-  public async lock(options: ExternalLockingLockOptions & TxGeneratingFunctionOptions): Promise<ArcTransactionResult> {
+  /**
+   * Claim the MGN tokens and lock them.  Provide `lockerAddress` to claim on their behalf,
+   * otherwise claims on behalf of the caller.
+   * @param options
+   */
+  public async lock(
+    options: ExternalLockingClaimOptions & TxGeneratingFunctionOptions): Promise<ArcTransactionResult> {
 
     const msg = await this.getLockBlocker(options);
     if (msg) {
       throw new Error(msg);
     }
 
-    this.logContractFunctionCall("ExternalLocking4Reputation.lock", options);
+    const currentAccount = (await Utils.getDefaultAccount()).toLowerCase();
+    let lockerAddress: Address | number = options.lockerAddress;
 
-    return this.wrapTransactionInvocation("ExternalLocking4Reputation.lock",
+    if (lockerAddress && (lockerAddress.toLowerCase() === currentAccount)) {
+      lockerAddress = 0;
+    }
+
+    if (lockerAddress && !(await this.isRegistered(lockerAddress as Address))) {
+      throw new Error(`lockerAddress has not been registered for proxy claiming: ${lockerAddress}`);
+    }
+
+    this.logContractFunctionCall("ExternalLocking4Reputation.claim", options);
+
+    return this.wrapTransactionInvocation("ExternalLocking4Reputation.claim",
       options,
-      this.contract.lock,
-      [],
-      { from: options.lockerAddress }
+      this.contract.claim,
+      [lockerAddress]
     );
   }
 
+  /**
+   * The caller is giving permission to the contract to allow someone else to claim
+   * on their behalf.
+   */
+  public async register(): Promise<ArcTransactionResult> {
+
+    this.logContractFunctionCall("ExternalLocking4Reputation.register");
+
+    return this.wrapTransactionInvocation("ExternalLocking4Reputation.register",
+      {},
+      this.contract.register,
+      []
+    );
+  }
+
+  /**
+   * Returns promise of a boolean indicating whether the given address has registered
+   * to have their tokens claimed for them (see `register`).
+   * @param lockerAddress
+   */
+  public isRegistered(lockerAddress: Address): Promise<boolean> {
+    this.logContractFunctionCall("ExternalLocking4Reputation.registrar", { lockerAddress });
+    return this.contract.registrar(lockerAddress);
+  }
+
   public getExternalLockingContract(): Promise<Address> {
     this.logContractFunctionCall("ExternalLocking4Reputation.externalLockingContract");
     return this.contract.externalLockingContract();
-
   }
 
   public getGetBalanceFuncSignature(): Promise<string> {
@@ -126,6 +165,6 @@ export interface ExternalLockingInitializeOptions {
   reputationReward: BigNumber | string;
 }
 
-export interface ExternalLockingLockOptions {
-  lockerAddress: Address;
+export interface ExternalLockingClaimOptions {
+  lockerAddress?: Address;
 }