Init

.eslintrc.js

@@ -74,6 +74,8 @@ module.exports = {
     ],
 
     'import/no-unassigned-import': 'off',
+    'import/no-extraneous-dependencies': 'off',
+    'node/no-extraneous-import': 'off',
 
     'no-invalid-this': 'off',
     '@babel/no-invalid-this': 'error',

app/scripts/controllers/network/createAptosRestClient.js

@@ -0,0 +1,39 @@
+import { createScaffoldMiddleware, mergeMiddleware } from 'json-rpc-engine';
+import {
+  createBlockRefMiddleware,
+  createRetryOnEmptyMiddleware,
+  createBlockCacheMiddleware,
+  createInflightCacheMiddleware,
+  createBlockTrackerInspectorMiddleware,
+  providerFromMiddleware,
+} from 'eth-json-rpc-middleware';
+
+import { createFetchMiddleware } from '@pontem/pontem-aptos-middleware';
+import { PollingBlockTracker } from '@pontem/pontem-block-tracker';
+
+export default function createAptosRestClient({ rpcUrl, chainId, network }) {
+  const aptosMiddleware = createFetchMiddleware({
+    rpcUrl,
+    maxAttempts: 5,
+  });
+  const provider = providerFromMiddleware(aptosMiddleware);
+  const blockTracker = new PollingBlockTracker({ provider });
+
+  const networkMiddleware = mergeMiddleware([
+    createChainIdAndNetworkMiddleware(chainId, network),
+    createBlockCacheMiddleware({ blockTracker }),
+    createInflightCacheMiddleware(),
+    createBlockRefMiddleware({ blockTracker, provider }),
+    createRetryOnEmptyMiddleware({ blockTracker, provider }),
+    createBlockTrackerInspectorMiddleware({ blockTracker }),
+    aptosMiddleware,
+  ]);
+  return { networkMiddleware, blockTracker };
+}
+
+function createChainIdAndNetworkMiddleware(chainId, network) {
+  return createScaffoldMiddleware({
+    eth_chainId: chainId,
+    net_version: network,
+  });
+}

app/scripts/controllers/network/createInfuraClient.js

@@ -24,6 +24,7 @@ export default function createInfuraClient({ network, projectId }) {
   const blockTracker = new PollingBlockTracker({ provider: infuraProvider });
 
   const networkMiddleware = mergeMiddleware([
+    createCustomMiddleware(),
     createNetworkAndChainIdMiddleware({ network }),
     createBlockCacheMiddleware({ blockTracker }),
     createInflightCacheMiddleware(),
@@ -35,6 +36,14 @@ export default function createInfuraClient({ network, projectId }) {
   return { networkMiddleware, blockTracker };
 }
 
+function createCustomMiddleware() {
+  return (req, res, next) => {
+    console.log('[Pontem] middleware', req, res);
+
+    return next();
+  };
+}
+
 function createNetworkAndChainIdMiddleware({ network }) {
   if (!NETWORK_TYPE_TO_ID_MAP[network]) {
     throw new Error(`createInfuraClient - unknown network "${network}"`);

app/scripts/controllers/network/createJsonRpcClient.js

@@ -39,6 +39,7 @@ export default function createJsonRpcClient({ rpcUrl, chainId }) {
 
 function createChainIdMiddleware(chainId) {
   return (req, res, next, end) => {
+    console.log('[Pontem] middleware', req, res);
     if (req.method === 'eth_chainId') {
       res.result = chainId;
       return end();

app/scripts/controllers/network/network.js

@@ -8,16 +8,15 @@ import {
   createSwappableProxy,
   createEventEmitterProxy,
 } from 'swappable-obj-proxy';
-import EthQuery from 'eth-query';
 import {
   RINKEBY,
   MAINNET,
-  INFURA_PROVIDER_TYPES,
+  DEFAULT_PROVIDER_TYPES,
   NETWORK_TYPE_RPC,
   NETWORK_TYPE_TO_ID_MAP,
   MAINNET_CHAIN_ID,
   RINKEBY_CHAIN_ID,
-  INFURA_BLOCKED_KEY,
+  INFURA_BLOCKED_KEY, CHAIN_ID_TO_RPC_URL_MAP, CHAIN_ID_TO_TYPE_MAP,
 } from '../../../../shared/constants/network';
 import { SECOND } from '../../../../shared/constants/time';
 import {
@@ -28,6 +27,8 @@ import getFetchWithTimeout from '../../../../shared/modules/fetch-with-timeout';
 import createMetamaskMiddleware from './createMetamaskMiddleware';
 import createInfuraClient from './createInfuraClient';
 import createJsonRpcClient from './createJsonRpcClient';
+import createAptosRestClient from './createAptosRestClient';
+import PontemQuery from '@pontem/pontem-query';
 
 const env = process.env.METAMASK_ENV;
 const fetchWithTimeout = getFetchWithTimeout(SECOND * 30);
@@ -47,7 +48,7 @@ if (process.env.IN_TEST) {
 }
 
 const defaultProviderConfig = {
-  ticker: 'ETH',
+  ticker: 'APTOS',
   ...defaultProviderConfigOpts,
 };
 
@@ -142,8 +143,9 @@ export default class NetworkController extends EventEmitter {
   getLatestBlock() {
     return new Promise((resolve, reject) => {
       const { provider } = this.getProviderAndBlockTracker();
-      const ethQuery = new EthQuery(provider);
-      ethQuery.sendAsync(
+      const pontemQuery = new PontemQuery(provider);
+      console.log('[Pontem] get block by number');
+      pontemQuery.sendAsync(
         { method: 'eth_getBlockByNumber', params: ['latest', false] },
         (err, block) => {
           if (err) {
@@ -234,18 +236,20 @@ export default class NetworkController extends EventEmitter {
     }
 
     // Ping the RPC endpoint so we can confirm that it works
-    const ethQuery = new EthQuery(this._provider);
+    const pontemQuery = new PontemQuery(this._provider);
     const initialNetwork = this.getNetworkState();
-    const { type } = this.getProviderConfig();
-    const isInfura = INFURA_PROVIDER_TYPES.includes(type);
+    // const { type } = this.getProviderConfig();
+    // const isInfura = INFURA_PROVIDER_TYPES.includes(type);
 
-    if (isInfura) {
-      this._checkInfuraAvailability(type);
-    } else {
-      this.emit(NETWORK_EVENTS.INFURA_IS_UNBLOCKED);
-    }
+    // if (isInfura) {
+    //   this._checkInfuraAvailability(type);
+    // } else {
+    //   this.emit(NETWORK_EVENTS.INFURA_IS_UNBLOCKED);
+    // }
+
+    this.emit(NETWORK_EVENTS.INFURA_IS_UNBLOCKED);
 
-    ethQuery.sendAsync({ method: 'net_version' }, (err, networkVersion) => {
+    pontemQuery.sendAsync({ method: 'net_version' }, (err, networkVersion) => {
       const currentNetwork = this.getNetworkState();
       if (initialNetwork === currentNetwork) {
         if (err) {
@@ -257,7 +261,7 @@ export default class NetworkController extends EventEmitter {
 
         this.setNetworkState(networkVersion);
         // look up EIP-1559 support
-        this.getEIP1559Compatibility();
+        // this.getEIP1559Compatibility();
       }
     });
   }
@@ -267,7 +271,7 @@ export default class NetworkController extends EventEmitter {
     return NETWORK_TYPE_TO_ID_MAP[type]?.chainId || configChainId;
   }
 
-  setRpcTarget(rpcUrl, chainId, ticker = 'ETH', nickname = '', rpcPrefs) {
+  setRpcTarget(rpcUrl, chainId, ticker = 'APTOS', nickname = '', rpcPrefs) {
     assert.ok(
       isPrefixedFormattedHexString(chainId),
       `Invalid chain ID "${chainId}": invalid hex string.`,
@@ -293,15 +297,15 @@ export default class NetworkController extends EventEmitter {
       `NetworkController - cannot call "setProviderType" with type "${NETWORK_TYPE_RPC}". Use "setRpcTarget"`,
     );
     assert.ok(
-      INFURA_PROVIDER_TYPES.includes(type),
+      DEFAULT_PROVIDER_TYPES.includes(type),
       `Unknown Infura provider type "${type}".`,
     );
     const { chainId } = NETWORK_TYPE_TO_ID_MAP[type];
     this.setProviderConfig({
       type,
       rpcUrl: '',
       chainId,
-      ticker: 'ETH',
+      ticker: 'APTOS',
       nickname: '',
     });
   }
@@ -393,18 +397,34 @@ export default class NetworkController extends EventEmitter {
   }
 
   _configureProvider({ type, rpcUrl, chainId }) {
-    // infura type-based endpoints
-    const isInfura = INFURA_PROVIDER_TYPES.includes(type);
-    if (isInfura) {
-      this._configureInfuraProvider(type, this._infuraProjectId);
-      // url-based rpc endpoints
-    } else if (type === NETWORK_TYPE_RPC) {
-      this._configureStandardProvider(rpcUrl, chainId);
-    } else {
+    const predefinedRpcUrl = rpcUrl || CHAIN_ID_TO_RPC_URL_MAP[chainId];
+    const network = CHAIN_ID_TO_TYPE_MAP[chainId]
+
+    if(!predefinedRpcUrl) {
       throw new Error(
-        `NetworkController - _configureProvider - unknown type "${type}"`,
+        `NetworkController - _configureProvider - rpc url is undefined. Network: "${type}". Chain ID: "${chainId}"`,
       );
     }
+
+    if(!network) {
+      throw new Error(
+        `NetworkController - _configureProvider - network is undefined. Network: "${type}". Chain ID: "${chainId}"`,
+      );
+    }
+
+    console.log('[Pontem.NetworkController._configureProvider]', { rpcUrl: predefinedRpcUrl, type, chainId, network })
+    this._configureStandardProvider(predefinedRpcUrl, chainId, network);
+
+    // if (isInfura) {
+    //   this._configureInfuraProvider(type, this._infuraProjectId);
+    //   // url-based rpc endpoints
+    // } else if (type === NETWORK_TYPE_RPC) {
+    //   this._configureStandardProvider(rpcUrl, chainId);
+    // } else {
+    //   throw new Error(
+    //     `NetworkController - _configureProvider - unknown type "${type}"`,
+    //   );
+    // }
   }
 
   _configureInfuraProvider(type, projectId) {
@@ -416,9 +436,9 @@ export default class NetworkController extends EventEmitter {
     this._setNetworkClient(networkClient);
   }
 
-  _configureStandardProvider(rpcUrl, chainId) {
+  _configureStandardProvider(rpcUrl, chainId, network) {
     log.info('NetworkController - configureStandardProvider', rpcUrl);
-    const networkClient = createJsonRpcClient({ rpcUrl, chainId });
+    const networkClient = createAptosRestClient({ rpcUrl, chainId, network });
     this._setNetworkClient(networkClient);
   }