Use upgradeToAndCall depending on upgrade interface version (#883)

Co-authored-by: Francisco <[email protected]>
Co-authored-by: Hadrien Croubois <[email protected]>

Author: 3 people

docs/modules/ROOT/pages/api-hardhat-upgrades.adoc

@@ -616,6 +616,8 @@ async function changeProxyAdmin(
 
 Changes the admin for a specific proxy.
 
+NOTE: This function is not supported with admins or proxies from OpenZeppelin Contracts 5.x.
+
 *Parameters:*
 
 * `proxyAddress` - the address of the proxy to change.

packages/core/CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Support new upgrade interface in OpenZeppelin Contracts 5.0. ([883](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/883))
 - Add validations for namespaced storage layout. ([#876](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/876))
 - Deprecate low-level API. Use [CLI or high-level API](https://docs.openzeppelin.com/upgrades-plugins/1.x/api-core) instead.
 

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openzeppelin/upgrades-core",
-  "version": "1.29.0",
+  "version": "1.30.0",
   "description": "",
   "repository": "https://github.com/OpenZeppelin/openzeppelin-upgrades/tree/master/packages/core",
   "license": "MIT",

packages/core/src/call-optional-signature.ts

@@ -0,0 +1,20 @@
+import { keccak256 } from 'ethereumjs-util';
+import { call, EthereumProvider } from './provider';
+
+export async function callOptionalSignature(provider: EthereumProvider, address: string, signature: string) {
+  const data = '0x' + keccak256(Buffer.from(signature)).toString('hex').slice(0, 8);
+  try {
+    return await call(provider, address, data);
+  } catch (e: any) {
+    if (
+      e.message.includes('function selector was not recognized') ||
+      e.message.includes('invalid opcode') ||
+      e.message.includes('revert') ||
+      e.message.includes('execution error')
+    ) {
+      return undefined;
+    } else {
+      throw e;
+    }
+  }
+}

packages/core/src/impl-address.ts

@@ -1,12 +1,11 @@
-import { keccak256 } from 'ethereumjs-util';
 import {
-  call,
   EIP1967BeaconNotFound,
   EIP1967ImplementationNotFound,
   getBeaconAddress,
   getImplementationAddress,
   UpgradesError,
 } from '.';
+import { callOptionalSignature } from './call-optional-signature';
 
 import { EthereumProvider } from './provider';
 import { parseAddress } from './utils/address';
@@ -24,27 +23,17 @@ export async function getImplementationAddressFromBeacon(
   provider: EthereumProvider,
   beaconAddress: string,
 ): Promise<string> {
-  const implementationFunction = '0x' + keccak256(Buffer.from('implementation()')).toString('hex').slice(0, 8);
-  let result: string | undefined;
-  try {
-    const implAddress = await call(provider, beaconAddress, implementationFunction);
-    result = parseAddress(implAddress);
-  } catch (e: any) {
-    if (
-      !(
-        e.message.includes('function selector was not recognized') ||
-        e.message.includes('invalid opcode') ||
-        e.message.includes('revert') ||
-        e.message.includes('execution error')
-      )
-    ) {
-      throw e;
-    } // otherwise fall through with no result
+  const impl = await callOptionalSignature(provider, beaconAddress, 'implementation()');
+  let parsedImplAddress;
+  if (impl !== undefined) {
+    parsedImplAddress = parseAddress(impl);
   }
-  if (result === undefined) {
+
+  if (parsedImplAddress === undefined) {
     throw new InvalidBeacon(`Contract at ${beaconAddress} doesn't look like a beacon`);
+  } else {
+    return parsedImplAddress;
   }
-  return result;
 }
 
 /**

packages/core/src/index.ts

@@ -58,4 +58,5 @@ export {
 
 export { ValidateUpgradeSafetyOptions, validateUpgradeSafety, ProjectReport, ReferenceContractNotFound } from './cli';
 
+export { getUpgradeInterfaceVersion } from './upgrade-interface-version';
 export { makeNamespacedInput } from './utils/make-namespaced';

packages/core/src/upgrade-interface-version.test.ts

@@ -0,0 +1,37 @@
+import test from 'ava';
+import { EthereumProvider } from './provider';
+import { getUpgradeInterfaceVersion } from './upgrade-interface-version';
+
+const hash = '0x1234';
+
+function makeProviderReturning(result: unknown): EthereumProvider {
+  return { send: (_method: string, _params: unknown[]) => Promise.resolve(result) } as EthereumProvider;
+}
+
+function makeProviderError(msg: string): EthereumProvider {
+  return {
+    send: (_method: string, _params: unknown[]) => {
+      throw new Error(msg);
+    },
+  } as EthereumProvider;
+}
+
+test('getUpgradeInterfaceVersion returns version', async t => {
+  // abi encoding of '5.0.0'
+  const provider = makeProviderReturning(
+    '0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000005352e302e30000000000000000000000000000000000000000000000000000000',
+  );
+  t.is(await getUpgradeInterfaceVersion(provider, hash), '5.0.0');
+});
+
+test('getUpgradeInterfaceVersion throws unrelated error', async t => {
+  const provider = makeProviderError('unrelated error');
+  await t.throwsAsync(() => getUpgradeInterfaceVersion(provider, hash), { message: 'unrelated error' });
+});
+
+test('getUpgradeInterfaceVersion returns undefined for invalid selector', async t => {
+  const provider = makeProviderError(
+    `Transaction reverted: function selector was not recognized and there's no fallback function`,
+  );
+  t.is(await getUpgradeInterfaceVersion(provider, hash), undefined);
+});

packages/core/src/upgrade-interface-version.ts

@@ -0,0 +1,27 @@
+import { callOptionalSignature } from './call-optional-signature';
+import { EthereumProvider } from './provider';
+
+export async function getUpgradeInterfaceVersion(
+  provider: EthereumProvider,
+  address: string,
+): Promise<string | undefined> {
+  const encodedVersion = await callOptionalSignature(provider, address, 'UPGRADE_INTERFACE_VERSION()');
+  if (encodedVersion !== undefined) {
+    // Encoded string
+    const buf = Buffer.from(encodedVersion.replace(/^0x/, ''), 'hex');
+
+    // The first 32 bytes represent the offset, which should be 32 for a string
+    const offset = parseInt(buf.slice(0, 32).toString('hex'), 16);
+    if (offset !== 32) {
+      throw new Error(`Unexpected type for UPGRADE_INTERFACE_VERSION at address ${address}. Expected a string`);
+    }
+
+    // The next 32 bytes represent the length of the string
+    const length = parseInt(buf.slice(32, 64).toString('hex'), 16);
+
+    // The rest is the string itself
+    return buf.slice(64, 64 + length).toString('utf8');
+  } else {
+    return undefined;
+  }
+}

packages/core/src/validate/query.ts

@@ -194,7 +194,7 @@ export function isUpgradeSafe(data: ValidationData, version: Version): boolean {
 
 export function inferUUPS(runValidation: ValidationRunData, fullContractName: string): boolean {
   const methods = getAllMethods(runValidation, fullContractName);
-  return methods.includes(upgradeToSignature);
+  return methods.includes(upgradeToSignature) || methods.includes(upgradeToAndCallSignature);
 }
 
 export function inferProxyKind(data: ValidationData, version: Version): ProxyDeployment['kind'] {

packages/plugin-hardhat/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+- Support new upgrade interface in OpenZeppelin Contracts 5.0. ([#883](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/883))
+- Support importing and upgrading 5.0 proxies.
+  - **Note**: Deploying 5.0 proxies is not supported yet.
 - Add validations for namespaced storage layout. ([#876](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/876))
 
 ## 2.2.1 (2023-08-18)