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/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;
 }

lib/wrappers/genesisProtocol.ts

@@ -891,24 +891,28 @@ export class GenesisProtocolWrapper extends IntVoteInterfaceWrapper
   }
 
   public async getParameters(paramsHash: Hash): Promise<GetGenesisProtocolParamsResult> {
-    const params = await this.getParametersArray(paramsHash);
-    return {
-      boostedVotePeriodLimit: params[2].toNumber(),
-      daoBountyConst: 0, // params[12].toNumber(),
-      daoBountyLimit: new BigNumber(0), // params[13],
-      minimumStakingFee: params[5],
-      preBoostedVotePeriodLimit: params[1].toNumber(),
-      preBoostedVoteRequiredPercentage: params[0].toNumber(),
-      proposingRepRewardConstA: params[7].toNumber(),
-      proposingRepRewardConstB: params[8].toNumber(),
-      quietEndingPeriod: params[6].toNumber(),
-      stakerFeeRatioForVoters: params[9].toNumber(),
-      thresholdConstA: params[3],
-      thresholdConstB: params[4].toNumber(),
-      voteOnBehalf: "", // params[14],
-      votersGainRepRatioFromLostRep: params[11].toNumber(),
-      votersReputationLossRatio: params[10].toNumber(),
-    };
+    const paramsArray = await this.getParametersArray(paramsHash);
+    const params = {
+      boostedVotePeriodLimit: paramsArray[2].toNumber(),
+      minimumStakingFee: paramsArray[5],
+      preBoostedVotePeriodLimit: paramsArray[1].toNumber(),
+      preBoostedVoteRequiredPercentage: paramsArray[0].toNumber(),
+      proposingRepRewardConstA: paramsArray[7].toNumber(),
+      proposingRepRewardConstB: paramsArray[8].toNumber(),
+      quietEndingPeriod: paramsArray[6].toNumber(),
+      stakerFeeRatioForVoters: paramsArray[9].toNumber(),
+      thresholdConstA: paramsArray[3],
+      thresholdConstB: paramsArray[4].toNumber(),
+      voteOnBehalf: paramsArray[12],
+      votersGainRepRatioFromLostRep: paramsArray[11].toNumber(),
+      votersReputationLossRatio: paramsArray[10].toNumber(),
+    } as GetGenesisProtocolParamsResult;
+
+    const bountyParamsArray = await this.contract.getDaoBountyParams(paramsHash);
+    params.daoBountyConst = bountyParamsArray[0].toNumber();
+    params.daoBountyLimit = bountyParamsArray[1];
+
+    return params;
   }
 
   /**

lib/wrappers/lockingToken4Reputation.ts

@@ -1,27 +1,29 @@
 "use strict";
 import BigNumber from "bignumber.js";
-import { Address } from "../commonTypes";
+import { Address, Hash } from "../commonTypes";
 import { ContractWrapperFactory } from "../contractWrapperFactory";
 import { ArcTransactionResult, IContractWrapperFactory } from "../iContractWrapperBase";
 import { TxGeneratingFunctionOptions } from "../transactionService";
 import { Utils } from "../utils";
-import { Web3EventService } from "../web3EventService";
+import { EventFetcherFactory, Web3EventService } from "../web3EventService";
 import { WrapperService } from "../wrapperService";
 import { InitializeOptions, Locking4ReputationWrapper, LockingOptions, ReleaseOptions } from "./locking4Reputation";
-import { StandardTokenWrapper } from "./standardToken";
+import { StandardTokenFactory, StandardTokenWrapper } from "./standardToken";
 
 export class LockingToken4ReputationWrapper extends Locking4ReputationWrapper {
   public name: string = "LockingToken4Reputation";
   public friendlyName: string = "Locking Token For Reputation";
   public factory: IContractWrapperFactory<LockingToken4ReputationWrapper> = LockingToken4ReputationFactory;
 
+  public LockToken: EventFetcherFactory<LockingToken4ReputationLockEventResult>;
+
   public async initialize(options: LockTokenInitializeOptions & TxGeneratingFunctionOptions)
     : Promise<ArcTransactionResult> {
 
     await super._initialize(options);
 
-    if (!options.tokenAddress) {
-      throw new Error(`tokenAddress not supplied`);
+    if (!options.priceOracleContract) {
+      throw new Error(`priceOracleContract not supplied`);
     }
 
     this.logContractFunctionCall("LockingToken4Reputation.initialize", options);
@@ -35,7 +37,7 @@ export class LockingToken4ReputationWrapper extends Locking4ReputationWrapper {
       options.lockingEndTime.getTime() / 1000,
       options.redeemEnableTime.getTime() / 1000,
       options.maxLockingPeriod,
-      options.tokenAddress]
+      options.priceOracleContract]
     );
   }
 
@@ -55,14 +57,18 @@ export class LockingToken4ReputationWrapper extends Locking4ReputationWrapper {
   /**
    * Returns reason why can't lock, else null if can lock
    */
-  public async getLockBlocker(options: LockingOptions): Promise<string | null> {
+  public async getLockBlocker(options: TokenLockingOptions): Promise<string | null> {
 
     const msg = await super.getLockBlocker(options);
     if (msg) {
       return msg;
     }
 
-    const token = await this.getToken();
+    if (!options.tokenAddress) {
+      return "tokenAddress was not supplied";
+    }
+
+    const token = await StandardTokenFactory.at(options.tokenAddress);
     const balance = await Utils.getTokenBalance(options.lockerAddress, token.address);
     const amount = new BigNumber(options.amount);
 
@@ -73,7 +79,7 @@ export class LockingToken4ReputationWrapper extends Locking4ReputationWrapper {
     return null;
   }
 
-  public async lock(options: LockingOptions & TxGeneratingFunctionOptions): Promise<ArcTransactionResult> {
+  public async lock(options: TokenLockingOptions & TxGeneratingFunctionOptions): Promise<ArcTransactionResult> {
 
     const msg = await this.getLockBlocker(options);
     if (msg) {
@@ -85,14 +91,14 @@ export class LockingToken4ReputationWrapper extends Locking4ReputationWrapper {
     return this.wrapTransactionInvocation("LockingToken4Reputation.lock",
       options,
       this.contract.lock,
-      [options.amount, options.period],
+      [options.amount, options.period, options.tokenAddress],
       { from: options.lockerAddress }
     );
   }
 
-  public async getToken(): Promise<StandardTokenWrapper> {
-    this.logContractFunctionCall("LockingToken4Reputation.token");
-    const address = await this.contract.token();
+  public async getTokenForLock(lockingId: Hash): Promise<StandardTokenWrapper> {
+    this.logContractFunctionCall("LockingToken4Reputation.lockedTokens");
+    const address = await this.contract.lockedTokens(lockingId);
     return WrapperService.factories.StandardToken.at(address);
   }
 }
@@ -111,5 +117,28 @@ export const LockingToken4ReputationFactory =
     new Web3EventService()) as LockingToken4ReputationType;
 
 export interface LockTokenInitializeOptions extends InitializeOptions {
+  priceOracleContract: Address;
+}
+
+export interface LockingToken4ReputationLockEventResult {
+  /**
+   * indexed
+   */
+  _lockingId: BigNumber;
+  /**
+   * indexed
+   */
+  _token: Address;
+  /**
+   * number/denominator is the price of the token at the time the token is locked
+   */
+  _numerator: BigNumber;
+  /**
+   * number/denominator is the price of the token at the time the token is locked
+   */
+  _denominator: BigNumber;
+}
+
+export interface TokenLockingOptions extends LockingOptions {
   tokenAddress: Address;
 }