add support for proxy contracts

Author: YaroShkvorets

packages/cli/src/command-helpers/contracts.ts

@@ -206,6 +206,51 @@ export class ContractService {
     return null;
   }
 
+  async getProxyImplementation(networkId: string, address: string) {
+    const urls = this.getRpcUrls(networkId);
+    if (!urls.length) {
+      throw new Error(`No JSON-RPC available for ${networkId} in the registry`);
+    }
+
+    const EIP_1967_SLOT = '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc';
+    const OPEN_ZEPPELIN_SLOT = '0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3';
+    const getStorageAt = async (url: string, slot: string) => {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          method: 'eth_getStorageAt',
+          params: [address, slot, 'latest'],
+          id: 1,
+        }),
+      });
+      const json = await response.json();
+      if (json?.result) {
+        const impl = '0x' + json.result.slice(-40);
+        if (impl !== '0x0000000000000000000000000000000000000000') {
+          return impl;
+        }
+      }
+      return null;
+    };
+
+    for (const url of urls) {
+      for (const slot of [EIP_1967_SLOT, OPEN_ZEPPELIN_SLOT]) {
+        try {
+          const impl = await getStorageAt(url, slot);
+          if (impl) {
+            return impl;
+          }
+        } catch (error) {
+          logger(`Failed to fetch proxy implementation from ${url}: ${error}`);
+        }
+      }
+    }
+
+    throw new Error(`JSON-RPC is unreachable`);
+  }
+
   private async fetchTransactionByHash(networkId: string, txHash: string) {
     const urls = this.getRpcUrls(networkId);
     if (!urls.length) {

packages/cli/src/commands/init.ts

@@ -635,6 +635,7 @@ async function processInitForm(
         }
 
         // If ABI is not provided, try to fetch it from Etherscan API
+        let implAddress: string | undefined = undefined;
         if (protocolInstance.hasABIs() && !initAbi) {
           abiFromApi = await retryWithPrompt(() =>
             withSpinner(
@@ -647,15 +648,50 @@ async function processInitForm(
           initDebugger.extend('processInitForm')("abiFromEtherscan len: '%s'", abiFromApi?.name);
         } else {
           abiFromApi = initAbi;
+          const isProxy =
+            abiFromApi?.callFunctions().some(entry => entry.get('name') === 'implementation') ??
+            false;
+          initDebugger.extend('processInitForm')('isProxy: %O', isProxy);
+          if (isProxy) {
+            const impl = await retryWithPrompt(() =>
+              withSpinner(
+                'Fetching proxy implementation address...',
+                'Failed to fetch proxy implementation address',
+                'Warning fetching proxy implementation address',
+                () => contractService.getProxyImplementation(network.id, address),
+              ),
+            );
+            initDebugger.extend('processInitForm')("proxyImplementation: '%s'", impl);
+            if (impl) {
+              const useImplementation = await prompt.confirm(
+                `Proxy contract detected. Index implementation contract at ${impl}?`,
+                true,
+              );
+
+              if (useImplementation) {
+                implAddress = impl;
+                abiFromApi = await retryWithPrompt(() =>
+                  withSpinner(
+                    'Fetching implementation contract ABI...',
+                    'Failed to fetch implementation ABI',
+                    'Warning fetching implementation ABI',
+                    () =>
+                      contractService.getABI(protocolInstance.getABI(), network.id, implAddress!),
+                  ),
+                );
+              }
+            }
+          }
         }
+
         // If startBlock is not provided, try to fetch it from Etherscan API
         if (!initStartBlock) {
           startBlock = await retryWithPrompt(() =>
             withSpinner(
               'Fetching start block from contract API...',
               'Failed to fetch start block',
               'Warning fetching start block',
-              () => contractService.getStartBlock(network.id, address),
+              () => contractService.getStartBlock(network.id, implAddress ?? address),
             ),
           );
           initDebugger.extend('processInitForm')("startBlockFromEtherscan: '%s'", startBlock);
@@ -668,7 +704,7 @@ async function processInitForm(
               'Fetching contract name from contract API...',
               'Failed to fetch contract name',
               'Warning fetching contract name',
-              () => contractService.getContractName(network.id, address),
+              () => contractService.getContractName(network.id, implAddress ?? address),
             ),
           );
           initDebugger.extend('processInitForm')("contractNameFromEtherscan: '%s'", contractName);