refactor(sdk): IExecWeb3telegram uses async config and chain detection

Author: abbesBenayache

src/web3telegram/IExecWeb3telegram.ts

@@ -1,79 +1,88 @@
 import { AbstractProvider, AbstractSigner, Eip1193Provider } from 'ethers';
 import { IExec } from 'iexec';
+import { GraphQLClient } from 'graphql-request';
 import { fetchUserContacts } from './fetchUserContacts.js';
 import { fetchMyContacts } from './fetchMyContacts.js';
 import { sendTelegram } from './sendTelegram.js';
 import {
   Contact,
   FetchUserContactsParams,
   SendTelegramParams,
-  Web3SignerProvider,
   AddressOrENS,
   Web3TelegramConfigOptions,
   SendTelegramResponse,
+  Web3SignerProvider,
   FetchMyContactsParams,
 } from './types.js';
-import { GraphQLClient } from 'graphql-request';
-import {
-  WEB3TELEGRAM_DAPP_ADDRESS,
-  IPFS_UPLOAD_URL,
-  DEFAULT_IPFS_GATEWAY,
-  DATAPROTECTOR_SUBGRAPH_ENDPOINT,
-  WHITELIST_SMART_CONTRACT_ADDRESS,
-} from '../config/config.js';
+import { CHAIN_CONFIG } from '../config/config.js';
 import { isValidProvider } from '../utils/validators.js';
+import { getChainIdFromProvider } from '../utils/getChainId.js';
+
+type EthersCompatibleProvider =
+  | AbstractProvider
+  | AbstractSigner
+  | Eip1193Provider
+  | Web3SignerProvider
+  | string;
+
+interface Web3telegramResolvedConfig {
+  dappAddressOrENS: AddressOrENS;
+  dappWhitelistAddress: AddressOrENS;
+  graphQLClient: GraphQLClient;
+  ipfsNode: string;
+  ipfsGateway: string;
+  defaultWorkerpool: string;
+  iexec: IExec;
+}
 
 export class IExecWeb3telegram {
-  private iexec: IExec;
+  private dappAddressOrENS!: AddressOrENS;
+
+  private dappWhitelistAddress!: AddressOrENS;
 
-  private ipfsNode: string;
+  private graphQLClient!: GraphQLClient;
 
-  private ipfsGateway: string;
+  private ipfsNode!: string;
 
-  private dataProtectorSubgraph: string;
+  private ipfsGateway!: string;
 
-  private dappAddressOrENS: AddressOrENS;
+  private defaultWorkerpool!: string;
 
-  private dappWhitelistAddress: AddressOrENS;
+  private iexec!: IExec;
 
-  private graphQLClient: GraphQLClient;
+  private initPromise: Promise<void> | null = null;
+
+  private ethProvider: EthersCompatibleProvider;
+
+  private options: Web3TelegramConfigOptions;
 
   constructor(
-    ethProvider?:
-      | Eip1193Provider
-      | AbstractProvider
-      | AbstractSigner
-      | Web3SignerProvider
-      | string,
+    ethProvider?: EthersCompatibleProvider,
     options?: Web3TelegramConfigOptions
   ) {
-    try {
-      this.iexec = new IExec(
-        { ethProvider: ethProvider || 'bellecour' },
-        options?.iexecOptions
-      );
-    } catch (e) {
-      throw Error('Unsupported ethProvider');
-    }
+    this.ethProvider = ethProvider || 'bellecour';
+    this.options = options || {};
+  }
 
-    try {
-      this.dataProtectorSubgraph =
-        options?.dataProtectorSubgraph || DATAPROTECTOR_SUBGRAPH_ENDPOINT;
-      this.graphQLClient = new GraphQLClient(this.dataProtectorSubgraph);
-    } catch (e) {
-      throw Error('Impossible to create GraphQLClient');
+  async init(): Promise<void> {
+    if (!this.initPromise) {
+      this.initPromise = this.resolveConfig().then((config) => {
+        this.dappAddressOrENS = config.dappAddressOrENS;
+        this.dappWhitelistAddress = config.dappWhitelistAddress;
+        this.graphQLClient = config.graphQLClient;
+        this.ipfsNode = config.ipfsNode;
+        this.ipfsGateway = config.ipfsGateway;
+        this.defaultWorkerpool = config.defaultWorkerpool;
+        this.iexec = config.iexec;
+      });
     }
-
-    this.dappAddressOrENS =
-      options?.dappAddressOrENS || WEB3TELEGRAM_DAPP_ADDRESS;
-    this.ipfsNode = options?.ipfsNode || IPFS_UPLOAD_URL;
-    this.ipfsGateway = options?.ipfsGateway || DEFAULT_IPFS_GATEWAY;
-    this.dappWhitelistAddress =
-      options?.dappWhitelistAddress || WHITELIST_SMART_CONTRACT_ADDRESS;
+    return this.initPromise;
   }
 
   async fetchMyContacts(args?: FetchMyContactsParams): Promise<Contact[]> {
+    await this.init();
     await isValidProvider(this.iexec);
+
     return fetchMyContacts({
       ...args,
       iexec: this.iexec,
@@ -83,7 +92,9 @@ export class IExecWeb3telegram {
     });
   }
 
-  fetchUserContacts(args: FetchUserContactsParams): Promise<Contact[]> {
+  async fetchUserContacts(args: FetchUserContactsParams): Promise<Contact[]> {
+    await this.init();
+
     return fetchUserContacts({
       ...args,
       iexec: this.iexec,
@@ -94,9 +105,12 @@ export class IExecWeb3telegram {
   }
 
   async sendTelegram(args: SendTelegramParams): Promise<SendTelegramResponse> {
+    await this.init();
     await isValidProvider(this.iexec);
     return sendTelegram({
       ...args,
+      workerpoolAddressOrEns:
+        args.workerpoolAddressOrEns || this.defaultWorkerpool,
       iexec: this.iexec,
       ipfsNode: this.ipfsNode,
       ipfsGateway: this.ipfsGateway,
@@ -105,4 +119,69 @@ export class IExecWeb3telegram {
       graphQLClient: this.graphQLClient,
     });
   }
+
+  private async resolveConfig(): Promise<Web3telegramResolvedConfig> {
+    const chainId = await getChainIdFromProvider(this.ethProvider);
+    const chainDefaultConfig = CHAIN_CONFIG[chainId];
+
+    const subgraphUrl =
+      this.options?.dataProtectorSubgraph ||
+      chainDefaultConfig?.dataProtectorSubgraph;
+    const dappAddressOrENS =
+      this.options?.dappAddressOrENS || chainDefaultConfig?.dappAddress;
+    const dappWhitelistAddress =
+      this.options?.dappWhitelistAddress ||
+      chainDefaultConfig?.whitelistSmartContract;
+    const ipfsGateway =
+      this.options?.ipfsGateway || chainDefaultConfig?.ipfsGateway;
+    const defaultWorkerpool = chainDefaultConfig?.prodWorkerpoolAddress;
+    const ipfsNode =
+      this.options?.ipfsNode || chainDefaultConfig?.ipfsUploadUrl;
+
+    const missing = [];
+    if (!subgraphUrl) missing.push('dataProtectorSubgraph');
+    if (!dappAddressOrENS) missing.push('dappAddress');
+    if (!dappWhitelistAddress) missing.push('whitelistSmartContract');
+    if (!ipfsGateway) missing.push('ipfsGateway');
+    if (!defaultWorkerpool) missing.push('prodWorkerpoolAddress');
+    if (!ipfsNode) missing.push('ipfsUploadUrl');
+
+    if (missing.length > 0) {
+      throw new Error(
+        `Missing required configuration for chainId ${chainId}: ${missing.join(
+          ', '
+        )}`
+      );
+    }
+
+    let iexec: IExec, graphQLClient: GraphQLClient;
+
+    try {
+      iexec = new IExec(
+        { ethProvider: this.ethProvider },
+        {
+          ipfsGatewayURL: ipfsGateway,
+          ...this.options?.iexecOptions,
+        }
+      );
+    } catch (e: any) {
+      throw new Error(`Unsupported ethProvider: ${e.message}`);
+    }
+
+    try {
+      graphQLClient = new GraphQLClient(subgraphUrl);
+    } catch (error: any) {
+      throw new Error(`Failed to create GraphQLClient: ${error.message}`);
+    }
+
+    return {
+      dappAddressOrENS,
+      dappWhitelistAddress: dappWhitelistAddress.toLowerCase(),
+      defaultWorkerpool,
+      graphQLClient,
+      ipfsNode,
+      ipfsGateway,
+      iexec,
+    };
+  }
 }