feat: make current address getters async

the current address was being set when connecting, and the case where it changed wasn't being
covered. Now it is being retrieved from the node every time

Author: monitz87

package.json

@@ -9,6 +9,7 @@
   "author": "Polymath Studios Inc.",
   "license": "ISC",
   "main": "dist/index.js",
+  "browser": "dist/index.browser.js",
   "typings": "dist/index.d.ts",
   "files": [
     "dist/**/*"
@@ -48,7 +49,7 @@
     "@0x/subproviders": "^3.0.2",
     "@babel/polyfill": "^7.0.0",
     "@babel/runtime": "^7.2.0",
-    "@polymathnetwork/contract-wrappers": "2.0.0-beta.7",
+    "@polymathnetwork/contract-wrappers": "2.0.0-beta.20",
     "bluebird": "^3.5.5",
     "ethereum-address": "^0.0.4",
     "json-stable-stringify": "^1.0.1",

src/Context.ts

@@ -1,13 +1,9 @@
 import { Wallet } from './Wallet';
 import { PolymathBase } from './PolymathBase';
+import { onAddressChange } from './browserUtils';
 
 interface ConstructorParams {
   contractWrappers: PolymathBase;
-  accountAddress?: string;
-}
-
-export interface ContextWithWallet extends Context {
-  currentWallet: Wallet;
 }
 
 /**
@@ -19,15 +15,13 @@ export interface ContextWithWallet extends Context {
 export class Context {
   public contractWrappers: PolymathBase;
 
-  public currentWallet?: Wallet;
+  public currentWallet: Wallet;
 
   constructor(params: ConstructorParams) {
-    const { contractWrappers, accountAddress } = params;
+    const { contractWrappers } = params;
 
     this.contractWrappers = contractWrappers;
 
-    if (accountAddress) {
-      this.currentWallet = new Wallet({ address: accountAddress });
-    }
+    this.currentWallet = new Wallet({ address: () => contractWrappers.getAccount() });
   }
 }

src/Polymath.ts

@@ -8,12 +8,31 @@ import {
 import P from 'bluebird';
 import { Context } from './Context';
 import { getInjectedProvider } from './browserUtils';
-import { PolymathNetworkParams, ErrorCode } from './types';
+import { ErrorCode } from './types';
 import { Erc20TokenBalance, SecurityToken, SecurityTokenReservation } from './entities';
 import { ReserveSecurityToken } from './procedures';
 import { PolymathError } from './PolymathError';
 import { PolymathBase } from './PolymathBase';
 
+interface PolymathNetworkParams {
+  polymathRegistryAddress: string;
+}
+
+interface PolymathNetworkNodeParams extends PolymathNetworkParams {
+  providerUrl: string;
+  privateKey: string;
+}
+
+interface ConnectParams extends PolymathNetworkParams {
+  providerUrl?: string;
+  privateKey?: string;
+}
+
+interface Connect {
+  (params: PolymathNetworkParams): Promise<Polymath>;
+  (params: PolymathNetworkNodeParams): Promise<Polymath>;
+}
+
 export class Polymath {
   public networkId: number = -1;
 
@@ -27,18 +46,19 @@ export class Polymath {
 
   private context: Context = {} as Context;
 
-  public connect = async ({
+  public connect: Connect = async ({
     polymathRegistryAddress,
     providerUrl,
     privateKey,
-  }: PolymathNetworkParams) => {
+  }: ConnectParams) => {
     let provider: Provider;
     const providerEngine = new Web3ProviderEngine();
     const injectedProvider = await getInjectedProvider();
 
     if (providerUrl && privateKey) {
       providerEngine.addProvider(new PrivateKeyWalletSubprovider(privateKey));
       providerEngine.addProvider(new RedundantSubprovider([new RPCSubprovider(providerUrl)]));
+      providerEngine.start();
       provider = providerEngine;
     } else if (injectedProvider) {
       provider = injectedProvider;
@@ -54,11 +74,8 @@ export class Polymath {
 
     this.contractWrappers = contractWrappers;
 
-    const account = await contractWrappers.getAccount();
-
     this.context = new Context({
       contractWrappers,
-      accountAddress: account,
     });
 
     this.isConnected = true;
@@ -88,17 +105,12 @@ export class Polymath {
     const {
       context: { currentWallet, contractWrappers },
     } = this;
+
     let owner: string;
     if (args) {
       ({ owner } = args);
-    } else if (currentWallet) {
-      ({ address: owner } = currentWallet);
     } else {
-      throw new PolymathError({
-        code: ErrorCode.FetcherValidationError,
-        message:
-          "No default account set. You must pass the token owner's private key to Polymath.connect()",
-      });
+      owner = await currentWallet.address();
     }
 
     const symbols = await contractWrappers.securityTokenRegistry.getTickersByOwner({ owner });
@@ -159,17 +171,12 @@ export class Polymath {
     const {
       context: { currentWallet, contractWrappers },
     } = this;
+
     let owner: string;
     if (args) {
       ({ owner } = args);
-    } else if (currentWallet) {
-      ({ address: owner } = currentWallet);
     } else {
-      throw new PolymathError({
-        code: ErrorCode.FetcherValidationError,
-        message:
-          "No default account set. You must pass the token owner's private key to Polymath.connect()",
-      });
+      owner = await currentWallet.address();
     }
 
     const symbols = await contractWrappers.securityTokenRegistry.getTokensByOwner({ owner });
@@ -289,11 +296,11 @@ export class Polymath {
   };
 
   /**
-   * Returns the wallet address of the current user if it exists
+   * Returns the wallet address of the current user
    */
-  public getCurrentAddress = () => {
+  public getCurrentAddress = async () => {
     const { currentWallet } = this.context;
 
-    return currentWallet ? currentWallet.address : undefined;
+    return currentWallet.address();
   };
 }

src/Wallet.ts

@@ -1,16 +1,11 @@
 interface Args {
-  address: string;
+  address: () => Promise<string>;
 }
 
-// TODO @RafaelVidaurre: Implement caching strategies and dedupe-ing transactions
 export class Wallet {
-  public address: string;
+  public address: () => Promise<string>;
 
   constructor({ address }: Args) {
     this.address = address;
   }
-
-  public toString() {
-    return this.address;
-  }
 }

src/browserUtils.ts

@@ -43,10 +43,14 @@ interface WindowWithWeb3 extends ExtendedWindow {
  * Returns the browser support for Ethereum
  */
 export function getBrowserSupport() {
-  const win = window as ExtendedWindow;
-  if (!win) {
+  const isClient = typeof window !== 'undefined';
+
+  if (!isClient) {
     return BrowserSupport.None;
   }
+
+  const win = window as ExtendedWindow;
+
   if (win.ethereum) {
     return BrowserSupport.MetamaskModern;
   }
@@ -71,10 +75,14 @@ function isUnsupported(obj: any): obj is ExtendedWindow {
 /* eslint-enable @typescript-eslint/no-unused-vars */
 
 export async function getInjectedProvider(): Promise<Provider | undefined> {
-  const win = (window as any) as ExtendedWindow | undefined;
-  if (!win) {
+  const isClient = typeof window !== 'undefined';
+
+  if (!isClient) {
     return undefined;
   }
+
+  const win = (window as any) as ExtendedWindow;
+
   if (isModern(win)) {
     const injectedProvider = win.ethereum;
     try {

src/entities/SecurityToken/SubModule.ts

@@ -2,7 +2,7 @@ import { SecurityToken } from './SecurityToken';
 import { Context } from '../../Context';
 
 export class SubModule {
-  public securityToken: SecurityToken;
+  protected securityToken: SecurityToken;
 
   protected context: Context;
 

src/procedures/ApproveErc20.ts

@@ -13,7 +13,7 @@ export class ApproveErc20 extends Procedure<ApproveErc20ProcedureArgs> {
     const { amount, spender, tokenAddress } = this.args;
     const { contractWrappers, currentWallet } = this.context;
 
-    const { address: ownerAddress } = currentWallet;
+    const ownerAddress = await currentWallet.address();
 
     const { polyToken } = contractWrappers;
 

src/procedures/ControllerTransfer.ts

@@ -52,7 +52,7 @@ export class ControllerTransfer extends Procedure<ControllerTransferProcedureArg
 
     const controller = await securityToken.controller();
 
-    const { address: account } = currentWallet;
+    const account = await currentWallet.address();
 
     if (account !== controller) {
       throw new PolymathError({

src/procedures/CreateSecurityToken.ts

@@ -27,12 +27,11 @@ export class CreateSecurityToken extends Procedure<
     } = context;
 
     let wallet: string;
-    const { address: currentAddress } = currentWallet;
 
     if (treasuryWallet) {
       wallet = treasuryWallet;
     } else {
-      wallet = currentAddress;
+      wallet = await currentWallet.address();
     }
 
     const [isAvailable, isRegisteredByCurrentIssuer, isLaunched] = await Promise.all([

src/procedures/Procedure.ts

@@ -9,7 +9,7 @@ import {
   PolyTransactionTag,
 } from '../types';
 import { TransactionQueue } from '../entities/TransactionQueue';
-import { Context, ContextWithWallet } from '../Context';
+import { Context } from '../Context';
 import { PostTransactionResolver } from '../PostTransactionResolver';
 import { PolymathError } from '../PolymathError';
 import { Entity } from '../entities';
@@ -29,23 +29,15 @@ export abstract class Procedure<
 
   protected args: Args;
 
-  protected context: ContextWithWallet;
+  protected context: Context;
 
   protected caller: Caller;
 
   private transactions: TransactionSpec[] = [];
 
   constructor(args: Args, context: Context, caller: Caller) {
-    if (!context.currentWallet) {
-      throw new PolymathError({
-        message:
-          "No default account set. You must pass the token owner's private key to Polymath.connect()",
-        code: ErrorCode.ProcedureValidationError,
-      });
-    }
-
     this.args = args;
-    this.context = context as ContextWithWallet;
+    this.context = context;
     this.caller = caller;
   }
 
@@ -75,14 +67,14 @@ export abstract class Procedure<
    * @param options.resolver An asynchronous callback used to provide runtime data after
    * the added transaction has finished successfully
    */
-  public addProcedure<A, R extends any = any>(
+  public addProcedure = <A, R extends any = any>(
     Proc: ProcedureClass<A>,
     {
       resolver = (() => {}) as () => Promise<R>,
     }: {
       resolver?: (receipt: TransactionReceiptWithDecodedLogs) => Promise<R>;
     } = {}
-  ) {
+  ) => {
     return async (args: A) => {
       const postTransactionResolver = new PostTransactionResolver(resolver);
       const operation = new Proc(args, this.context);
@@ -105,7 +97,7 @@ export abstract class Procedure<
       this.transactions = [...this.transactions, ...transactions];
       return postTransactionResolver;
     };
-  }
+  };
 
   /**
    * Appends a method into the TransactionQueue's queue. This defines
@@ -117,7 +109,7 @@ export abstract class Procedure<
    * @param options.resolver An asynchronous callback used to provide runtime data after
    * the added transaction has finished successfully
    */
-  public addTransaction<A, R extends any = any>(
+  public addTransaction = <A, R extends any = any>(
     method: LowLevelMethod<A>,
     {
       tag,
@@ -126,7 +118,7 @@ export abstract class Procedure<
       tag?: PolyTransactionTag;
       resolver?: (receipt: TransactionReceiptWithDecodedLogs) => Promise<R>;
     } = {}
-  ) {
+  ) => {
     return async (args: MapMaybeResolver<A>) => {
       const postTransactionResolver = new PostTransactionResolver(resolver);
 
@@ -141,7 +133,7 @@ export abstract class Procedure<
 
       return postTransactionResolver;
     };
-  }
+  };
 
   protected abstract prepareTransactions(): Promise<
     MaybeResolver<ReturnType | undefined> | undefined