Fix makeContract and post

packages/light.js/src/index.ts

@@ -3,23 +3,25 @@
 //
 // SPDX-License-Identifier: MIT
 
-import { setProvider } from './api';
+import { setApi, setProvider } from './api';
 import frequency from './frequency';
+import { makeContract } from './rpc/other/makeContract';
 import rpc from './rpc';
 
 export * from './utils/isLoading';
 export * from './types';
 export { withoutLoading } from './utils/operators/withoutLoading';
 
-export { frequency };
+export { frequency, makeContract }; // makeContract is a bit special, because it's not a RpcObservable
 export const {
   accounts$,
   accountsInfo$,
   balanceOf$,
   blockNumber$,
+  chainName$,
   defaultAccount$,
   myBalance$,
   peerCount$,
   syncStatus$
 } = rpc;
-export default { setProvider };
+export default { setApi, setProvider };

packages/light.js/src/rpc/other/makeContract.ts

@@ -8,9 +8,9 @@ import { abiEncode } from '@parity/api/lib/util/encode';
 import * as memoizee from 'memoizee';
 
 import { Address } from '../../types';
+import { createApiFromProvider, getApi } from '../../api';
 import createRpc from '../utils/createRpc';
 import { switchMapPromise } from '../../utils/operators';
-import api from '../../api';
 import frequency from '../../frequency';
 import { post$ } from './post';
 
@@ -32,7 +32,10 @@ interface MakeContract {
  * @return - The contract object as defined in @parity/api.
  */
 const getContract = memoizee(
-  (address: Address, abiJson: any[]) => api().newContract(abiJson, address), // use types from @parity/abi
+  (address: Address, abiJson: any[], provider: any) => {
+    const api = provider ? createApiFromProvider(provider) : getApi();
+    return api.newContract(abiJson, address);
+  }, // use types from @parity/abi
   { length: 1 } // Only memoize by address
 );
 
@@ -46,15 +49,15 @@ const getContract = memoizee(
  * function resolves.
  */
 export const makeContract = memoizee(
-  (address: Address, abiJson: any[]) => {
-    // use types from @parity/abi
-    const abi = new Abi(abiJson);
+  (address: Address, abiJson: any[], options: { provider?: any } = {}) => {
+    const { provider } = options;
+    const abi = new Abi(abiJson); // use types from @parity/abi
     // Variable result will hold the final object to return
     const result: MakeContract = {
       abi,
       address,
       get contractObject() {
-        return getContract(address, abiJson);
+        return getContract(address, abiJson, provider);
       }
     };
 
@@ -66,7 +69,7 @@ export const makeContract = memoizee(
         // We only get the contract when the function is called for the 1st
         // time. Note: getContract is memoized, won't create contract on each
         // call.
-        const contract = getContract(address, abiJson);
+        const contract = getContract(address, abiJson, provider);
         const method = contract.instance[name]; // Hold the method from the Abi
 
         // The last arguments in args can be an options object

packages/light.js/src/rpc/other/post.ts

@@ -5,9 +5,13 @@
 
 import { Observable, Observer } from 'rxjs';
 
-import api from '../../api';
+import { createApiFromProvider, getApi } from '../../api';
 import { distinctReplayRefCount } from '../../utils/operators';
-import { RpcObservable, Tx, TxStatus } from '../../types';
+import { RpcObservableOptions, Tx, TxStatus } from '../../types';
+
+interface PostOptions extends RpcObservableOptions {
+  estimate?: boolean;
+}
 
 /**
  * Post a transaction to the network.
@@ -16,31 +20,31 @@ import { RpcObservable, Tx, TxStatus } from '../../types';
  * `parity_checkRequest` and `eth_getTransactionReceipt` to get the status of
  * the transaction.
  *
- * @param options? - Options to pass.
+ * @param options? - Options to pass to the {@link RpcObservable}.
  * @return - The status of the transaction.
  */
-export const post$: RpcObservable<any, TxStatus> = (
-  tx: Tx,
-  options: { estimate?: boolean } = {}
-) => {
+export function post$(tx: Tx, options: PostOptions = {}) {
+  const { estimate, provider } = options;
+  const api = provider ? createApiFromProvider(provider) : getApi();
+
   const source$ = Observable.create(async (observer: Observer<TxStatus>) => {
     try {
-      if (options.estimate) {
+      if (estimate) {
         observer.next({ estimating: true });
-        const gas = await api().eth.estimateGas(tx);
+        const gas = await api.eth.estimateGas(tx);
         observer.next({ estimated: gas });
       }
-      const signerRequestId = await api().parity.postTransaction(tx);
+      const signerRequestId = await api.parity.postTransaction(tx);
       observer.next({ requested: signerRequestId });
-      const transactionHash = await api().pollMethod(
+      const transactionHash = await api.pollMethod(
         'parity_checkRequest',
         signerRequestId
       );
       if (tx.condition) {
         observer.next({ signed: transactionHash, schedule: tx.condition });
       } else {
         observer.next({ signed: transactionHash });
-        const receipt = await api().pollMethod(
+        const receipt = await api.pollMethod(
           'eth_getTransactionReceipt',
           transactionHash,
           (
@@ -58,14 +62,5 @@ export const post$: RpcObservable<any, TxStatus> = (
   }).pipe(distinctReplayRefCount());
 
   source$.subscribe(); // Run this Observable immediately;
-  return source$;
-};
-post$.metadata = {
-  calls: [
-    'eth_estimateGas',
-    'parity_postTransaction',
-    'parity_checkRequest',
-    'eth_getTransactionReceipt'
-  ],
-  name: 'post$'
-};
+  return source$ as Observable<TxStatus>;
+}

packages/light.js/src/rpc/rpc.spec.ts

@@ -7,7 +7,6 @@ import isObservable from '../utils/isObservable';
 import { resolveApi } from '../utils/testHelpers/mockApi';
 import rpc from './rpc';
 import { RpcKey, RpcMap, RpcObservable } from '../types';
-import { RPC_LOADING } from '../utils/isLoading';
 import { setApi } from '../api';
 
 /**
@@ -26,20 +25,16 @@ const testRpc = (name: string, rpc$: RpcObservable<any, any>) =>
     });
 
     it('function should return an Observable', () => {
-      expect(isObservable(rpc$())).toBe(true);
+      expect(isObservable(rpc$({}))).toBe(true);
     });
 
     it('function result Observable should be subscribable', () => {
-      expect(() => rpc$().subscribe()).not.toThrow();
+      expect(() => rpc$({}).subscribe()).not.toThrow();
     });
 
     it('function result Observable should return values', done => {
-      rpc$().subscribe(data => {
-        // The first value is either 'foo' (defined in mockApi), or the
-        // RPC_LOADING symbole.
-        // In the case of defaultAccount$ (which is accounts$[0]), the returned
-        // value is 'f'. TODO not clean.
-        expect(['foo', 'f', RPC_LOADING]).toContain(data);
+      rpc$({}).subscribe(data => {
+        expect(data).toBeTruthy();
         done();
       });
     });

packages/light.js/src/rpc/rpc.ts

@@ -6,8 +6,9 @@
 import * as eth from './eth';
 import { memoizeAll } from '../utils/memoizeAll';
 import * as net from './net';
+import { post$ } from './other';
 import * as parity from './parity';
 
-const rpc = { ...eth, ...net, ...parity };
+const rpc = { ...eth, ...net, ...parity, post$ };
 
 export default memoizeAll(rpc);

packages/light.js/src/rpc/utils/createRpc.ts

@@ -3,18 +3,17 @@
 //
 // SPDX-License-Identifier: MIT
 
-import * as Api from '@parity/api';
 import { isFunction } from '@parity/api/lib/util/types';
 import { merge, ReplaySubject, Observable, OperatorFunction } from 'rxjs';
 import { multicast, refCount } from 'rxjs/operators';
 import * as prune from 'json-prune';
 
-import { getApi } from '../../api';
-import { Metadata, RpcObservable, RpcObservableOptions } from '../../types';
+import { createApiFromProvider, getApi } from '../../api';
 import {
   distinctValues,
   withoutLoading as withoutLoadingOperator
 } from '../../utils/operators';
+import { Metadata, RpcObservable, RpcObservableOptions } from '../../types';
 
 interface RpcObservableWithoutMetadata<_, Out> {
   (...args: any[]): Observable<Out>;
@@ -60,7 +59,7 @@ const createRpc = <Source, Out>(metadata: Metadata<Source, Out>) => (
   options: RpcObservableOptions = {}
 ) => {
   const { provider, withoutLoading } = options;
-  const api = provider ? new Api(provider) : getApi();
+  const api = provider ? createApiFromProvider(provider) : getApi();
   // rpc$ will hold the RpcObservable minus its metadata
   const rpc$: RpcObservableWithoutMetadata<Source, Out> = (...args: any[]) => {
     // The source Observable can either be another RpcObservable (in the

packages/light.js/src/utils/testHelpers/mockApi.ts

@@ -8,7 +8,7 @@ const listOfMockRps: { [index: string]: string[] } = {
   eth: ['accounts', 'blockNumber', 'getBalance', 'syncing'],
   fake: ['method'],
   net: ['peerCount'],
-  parity: ['accountsInfo', 'netChain']
+  parity: ['accountsInfo', 'netChain', 'postTransaction']
 };
 
 /**
@@ -50,7 +50,14 @@ const createApi = (
 
       return apiObject;
     },
-    { isPubSub } as { [index: string]: any }
+    {
+      isPubSub,
+      pollMethod() {
+        return isError
+          ? Promise.reject(resolveWith)
+          : Promise.resolve(resolveWith);
+      }
+    } as { [index: string]: any }
   );
 
   return result;