@openzeppelin/upgrades-core 1.9.1 → 1.11.1

package/src/usage-error.ts

@@ -0,0 +1,68 @@
+import { EthereumProvider, getBeaconAddress, isBeaconProxy, isTransparentOrUUPSProxy, UpgradesError } from '.';
+
+export class BeaconProxyUnsupportedError extends UpgradesError {
+  constructor() {
+    super(
+      'Beacon proxies are not supported with the current function.',
+      () => 'Use deployBeacon(), deployBeaconProxy(), or upgradeBeacon() instead.',
+    );
+  }
+}
+
+export class DeployBeaconProxyKindError extends UpgradesError {
+  constructor(kind: string) {
+    super(
+      `Unsupported proxy kind '${kind}'`,
+      () => `deployBeaconProxy() is only supported with proxy kind undefined or 'beacon'`,
+    );
+  }
+}
+
+export class DeployBeaconProxyUnsupportedError extends UpgradesError {
+  constructor(beaconAddress: string) {
+    super(`Contract at ${beaconAddress} doesn't look like a beacon`, () => 'Deploy a beacon using deployBeacon().');
+  }
+}
+
+export class DeployBeaconProxyImplUnknownError extends UpgradesError {
+  constructor(implAddress: string) {
+    super(
+      `Beacon's current implementation at ${implAddress} is unknown`,
+      () => `Call deployBeaconProxy() with the implementation option providing the beacon's current implementation.`,
+    );
+  }
+}
+
+export class LoadProxyUnsupportedError extends UpgradesError {
+  constructor(proxyAddress: string) {
+    super(
+      `Contract at ${proxyAddress} doesn't look like a supported proxy`,
+      () => 'Only transparent, UUPS, or beacon proxies can be loaded with the loadProxy() function.',
+    );
+  }
+}
+
+export class PrepareUpgradeUnsupportedError extends UpgradesError {
+  constructor(proxyOrBeaconAddress: string) {
+    super(
+      `Contract at address ${proxyOrBeaconAddress} doesn't look like a supported proxy or beacon`,
+      () => `Only transparent, UUPS, or beacon proxies or beacons can be used with the prepareUpgrade() function.`,
+    );
+  }
+}
+
+export async function assertNotProxy(provider: EthereumProvider, address: string) {
+  if (await isTransparentOrUUPSProxy(provider, address)) {
+    throw new UpgradesError(
+      'Address is a transparent or UUPS proxy which cannot be upgraded using upgradeBeacon().',
+      () => 'Use upgradeProxy() instead.',
+    );
+  } else if (await isBeaconProxy(provider, address)) {
+    const beaconAddress = await getBeaconAddress(provider, address);
+    throw new UpgradesError(
+      'Address is a beacon proxy which cannot be upgraded directly.',
+      () =>
+        `upgradeBeacon() must be called with a beacon address, not a beacon proxy address. Call upgradeBeacon() on the beacon address ${beaconAddress} instead.`,
+    );
+  }
+}

package/src/utils/address.ts

@@ -0,0 +1,16 @@
+import { toChecksumAddress } from 'ethereumjs-util';
+
+/**
+ * Parses an address from a hex string which may come from storage or a returned address via eth_call.
+ *
+ * @param addressString The address hex string.
+ * @returns The parsed checksum address, or undefined if the input string is not an address.
+ */
+export function parseAddress(addressString: string): string | undefined {
+  const buf = Buffer.from(addressString.replace(/^0x/, ''), 'hex');
+  if (!buf.slice(0, 12).equals(Buffer.alloc(12, 0))) {
+    return undefined;
+  }
+  const address = '0x' + buf.toString('hex', 12, 32); // grab the last 20 bytes
+  return toChecksumAddress(address);
+}

package/src/utils/make-non-enumerable.ts

@@ -1,4 +1,3 @@
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function makeNonEnumerable<O extends any>(obj: O, key: keyof O): void {
+export function makeNonEnumerable<O>(obj: O, key: keyof O): void {
   Object.defineProperty(obj, key, { enumerable: false });
 }

package/src/validate/error.ts

@@ -1,75 +1,11 @@
-import chalk from 'chalk';
-
 import { ValidationError } from './run';
-import { UpgradesError, ErrorDescriptions } from '../error';
+import { UpgradesError } from '../error';
+import { UpgradeableContractErrorReport } from './report';
 
 export class ValidationErrors extends UpgradesError {
   constructor(contractName: string, readonly errors: ValidationError[]) {
-    super(`Contract \`${contractName}\` is not upgrade safe`, () => {
-      return errors.map(describeError).join('\n\n');
-    });
-  }
-}
-
-const errorInfo: ErrorDescriptions<ValidationError> = {
-  constructor: {
-    msg: e => `Contract \`${e.contract}\` has a constructor`,
-    hint: () => 'Define an initializer instead',
-    link: 'https://zpl.in/upgrades/error-001',
-  },
-  delegatecall: {
-    msg: () => `Use of delegatecall is not allowed`,
-    link: 'https://zpl.in/upgrades/error-002',
-  },
-  selfdestruct: {
-    msg: () => `Use of selfdestruct is not allowed`,
-    link: 'https://zpl.in/upgrades/error-003',
-  },
-  'state-variable-assignment': {
-    msg: e => `Variable \`${e.name}\` is assigned an initial value`,
-    hint: () => 'Move the assignment to the initializer',
-    link: 'https://zpl.in/upgrades/error-004',
-  },
-  'state-variable-immutable': {
-    msg: e => `Variable \`${e.name}\` is immutable`,
-    hint: () => `Use a constant or mutable variable instead`,
-    link: 'https://zpl.in/upgrades/error-005',
-  },
-  'external-library-linking': {
-    msg: e => `Linking external libraries like \`${e.name}\` is not yet supported`,
-    hint: () =>
-      `Use libraries with internal functions only, or skip this check with the \`unsafeAllowLinkedLibraries\` flag \n` +
-      `    if you have manually checked that the libraries are upgrade safe`,
-    link: 'https://zpl.in/upgrades/error-006',
-  },
-  'struct-definition': {
-    msg: e => `Structs like \`${e.name}\` are supported in the latest version of the plugin`,
-    hint: () => `Update your dependency and run again`,
-  },
-  'enum-definition': {
-    msg: e => `Enums like \`${e.name}\` are supported in the latest version of the plugin`,
-    hint: () => `Update your dependency and run again`,
-  },
-  'missing-public-upgradeto': {
-    msg: () => `Implementation is missing a public \`upgradeTo(address)\` function`,
-    hint: () =>
-      `Inherit UUPSUpgradeable to include this function in your contract\n` +
-      `    @openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol`,
-    link: 'https://zpl.in/upgrades/error-008',
-  },
-};
-
-function describeError(e: ValidationError): string {
-  const info = errorInfo[e.kind];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const log = [chalk.bold(e.src) + ': ' + info.msg(e as any)];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const hint = info.hint?.(e as any);
-  if (hint) {
-    log.push(hint);
-  }
-  if (info.link) {
-    log.push(chalk.dim(info.link));
+    super(`Contract \`${contractName}\` is not upgrade safe`, () =>
+      new UpgradeableContractErrorReport(errors).explain(),
+    );
   }
-  return log.join('\n    ');
 }

package/src/validate/index.ts

@@ -11,7 +11,9 @@ export {
   getUnlinkedBytecode,
   getErrors,
   isUpgradeSafe,
+  inferProxyKind,
 } from './query';
+export { UpgradeableContractErrorReport } from './report';
 
 // Backwards compatibility
 export { silenceWarnings } from '../utils/log';

package/src/validate/overrides.ts

@@ -69,7 +69,7 @@ export function processExceptions(
 ): ValidationError[] {
   const { unsafeAllow } = withValidationDefaults(opts);
 
-  if (opts.kind === 'transparent') {
+  if (opts.kind === 'transparent' || opts.kind === 'beacon') {
     errors = errors.filter(error => error.kind !== 'missing-public-upgradeto');
   }
 

package/src/validate/query.ts

@@ -5,13 +5,15 @@ import { unlinkBytecode } from '../link-refs';
 import { ValidationOptions, processExceptions } from './overrides';
 import { ValidationErrors } from './error';
 import { ValidationData, normalizeValidationData } from './data';
+import { ProxyDeployment } from '../manifest';
+
+const upgradeToSignature = 'upgradeTo(address)';
 
 export function assertUpgradeSafe(data: ValidationData, version: Version, opts: ValidationOptions): void {
   const dataV3 = normalizeValidationData(data);
   const [contractName] = getContractNameAndRunValidation(dataV3, version);
 
-  let errors = getErrors(dataV3, version);
-  errors = processExceptions(contractName, errors, opts);
+  const errors = getErrors(dataV3, version, opts);
 
   if (errors.length > 0) {
     throw new ValidationErrors(contractName, errors);
@@ -100,28 +102,55 @@ export function getUnlinkedBytecode(data: ValidationData, bytecode: string): str
   return bytecode;
 }
 
-export function getErrors(data: ValidationData, version: Version): ValidationError[] {
+export function getErrors(data: ValidationData, version: Version, opts: ValidationOptions = {}): ValidationError[] {
   const dataV3 = normalizeValidationData(data);
   const [contractName, runValidation] = getContractNameAndRunValidation(dataV3, version);
   const c = runValidation[contractName];
 
-  const errors = c.errors
-    .concat(...c.inherit.map(name => runValidation[name].errors))
-    .concat(...c.libraries.map(name => runValidation[name].errors));
+  const errors = getUsedContractsAndLibraries(contractName, runValidation).flatMap(name => runValidation[name].errors);
 
-  const selfAndInheritedMethods = c.methods.concat(...c.inherit.map(name => runValidation[name].methods));
+  const selfAndInheritedMethods = getAllMethods(runValidation, contractName);
 
-  if (!selfAndInheritedMethods.includes('upgradeTo(address)')) {
+  if (!selfAndInheritedMethods.includes(upgradeToSignature)) {
     errors.push({
       src: c.src,
       kind: 'missing-public-upgradeto',
     });
   }
 
-  return errors;
+  return processExceptions(contractName, errors, opts);
+}
+
+function getAllMethods(runValidation: ValidationRunData, contractName: string): string[] {
+  const c = runValidation[contractName];
+  return c.methods.concat(...c.inherit.map(name => runValidation[name].methods));
+}
+
+function getUsedContractsAndLibraries(contractName: string, runValidation: ValidationRunData) {
+  const c = runValidation[contractName];
+  // Add current contract and all of its parents
+  const res = new Set([contractName, ...c.inherit]);
+  // Add used libraries transitively until no more are found
+  for (const c1 of res) {
+    for (const c2 of runValidation[c1].libraries) {
+      res.add(c2);
+    }
+  }
+  return Array.from(res);
 }
 
 export function isUpgradeSafe(data: ValidationData, version: Version): boolean {
   const dataV3 = normalizeValidationData(data);
   return getErrors(dataV3, version).length == 0;
 }
+
+export function inferProxyKind(data: ValidationData, version: Version): ProxyDeployment['kind'] {
+  const dataV3 = normalizeValidationData(data);
+  const [contractName, runValidation] = getContractNameAndRunValidation(dataV3, version);
+  const methods = getAllMethods(runValidation, contractName);
+  if (methods.includes(upgradeToSignature)) {
+    return 'uups';
+  } else {
+    return 'transparent';
+  }
+}

package/src/validate/report.ts

@@ -0,0 +1,78 @@
+import _chalk from 'chalk';
+
+import { ErrorDescriptions } from '../error';
+import { ValidationError } from './run';
+
+export class UpgradeableContractErrorReport {
+  constructor(readonly errors: ValidationError[]) {}
+
+  get ok(): boolean {
+    return this.errors.length === 0;
+  }
+
+  explain(color = true): string {
+    return this.errors.map(e => describeError(e, color)).join('\n\n');
+  }
+}
+
+const errorInfo: ErrorDescriptions<ValidationError> = {
+  constructor: {
+    msg: e => `Contract \`${e.contract}\` has a constructor`,
+    hint: () => 'Define an initializer instead',
+    link: 'https://zpl.in/upgrades/error-001',
+  },
+  delegatecall: {
+    msg: () => `Use of delegatecall is not allowed`,
+    link: 'https://zpl.in/upgrades/error-002',
+  },
+  selfdestruct: {
+    msg: () => `Use of selfdestruct is not allowed`,
+    link: 'https://zpl.in/upgrades/error-003',
+  },
+  'state-variable-assignment': {
+    msg: e => `Variable \`${e.name}\` is assigned an initial value`,
+    hint: () => 'Move the assignment to the initializer',
+    link: 'https://zpl.in/upgrades/error-004',
+  },
+  'state-variable-immutable': {
+    msg: e => `Variable \`${e.name}\` is immutable`,
+    hint: () => `Use a constant or mutable variable instead`,
+    link: 'https://zpl.in/upgrades/error-005',
+  },
+  'external-library-linking': {
+    msg: e => `Linking external libraries like \`${e.name}\` is not yet supported`,
+    hint: () =>
+      `Use libraries with internal functions only, or skip this check with the \`unsafeAllowLinkedLibraries\` flag \n` +
+      `    if you have manually checked that the libraries are upgrade safe`,
+    link: 'https://zpl.in/upgrades/error-006',
+  },
+  'struct-definition': {
+    msg: e => `Structs like \`${e.name}\` are supported in the latest version of the plugin`,
+    hint: () => `Update your dependency and run again`,
+  },
+  'enum-definition': {
+    msg: e => `Enums like \`${e.name}\` are supported in the latest version of the plugin`,
+    hint: () => `Update your dependency and run again`,
+  },
+  'missing-public-upgradeto': {
+    msg: () => `Implementation is missing a public \`upgradeTo(address)\` function`,
+    hint: () =>
+      `Inherit UUPSUpgradeable to include this function in your contract\n` +
+      `    @openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol`,
+    link: 'https://zpl.in/upgrades/error-008',
+  },
+};
+
+function describeError(e: ValidationError, color = true): string {
+  const chalk = new _chalk.Instance({ level: color && _chalk.supportsColor ? _chalk.supportsColor.level : 0 });
+  const info = errorInfo[e.kind];
+  const log = [chalk.bold(e.src) + ': ' + info.msg(e as any)];
+  const hint = info.hint?.(e as any);
+  if (hint) {
+    log.push(hint);
+  }
+  if (info.link) {
+    log.push(chalk.dim(info.link));
+  }
+  return log.join('\n    ');
+}

package/src/validate.test.ts

@@ -131,3 +131,4 @@ testValid('UsesExplicitSafeInternalLibraryNatspec', 'transparent', true);
 testValid('UsesExplicitSafeExternalLibraryNatspec', 'transparent', true);
 testValid('UsesExplicitUnsafeInternalLibraryNatspec', 'transparent', true);
 testValid('UsesExplicitUnsafeExternalLibraryNatspec', 'transparent', true);
+testValid('TransitiveLibraryIsUnsafe', 'transparent', false);

package/src/version.ts

@@ -7,19 +7,19 @@ export interface Version {
   linkedWithoutMetadata: string;
 }
 
-export function getVersion(bytecode: string, linkedBytecode?: string): Version {
+export function getVersion(bytecode: string, linkedBytecode?: string, constructorArgs = ''): Version {
   if (bytecode !== '') {
     return {
       withMetadata: hashBytecode(bytecode),
       withoutMetadata: hashBytecodeWithoutMetadata(bytecode),
-      linkedWithoutMetadata: hashBytecodeWithoutMetadata(linkedBytecode ?? bytecode),
+      linkedWithoutMetadata: hashBytecodeWithoutMetadata(linkedBytecode ?? bytecode, constructorArgs),
     };
   } else {
     throw new Error('Abstract contract not allowed here');
   }
 }
 
-export function hashBytecode(bytecode: string): string {
+export function hashBytecode(bytecode: string, constructorArgs = ''): string {
   bytecode = bytecode
     .replace(/__\$([0-9a-fA-F]{34})\$__/g, (_, placeholder) => `000${placeholder}000`)
     .replace(/__\w{36}__/g, placeholder => keccak256(Buffer.from(placeholder)).toString('hex', 0, 20));
@@ -31,12 +31,20 @@ export function hashBytecode(bytecode: string): string {
     throw new Error('Bytecode is not a valid hex string');
   }
 
-  const buf = Buffer.from(bytecode.replace(/^0x/, ''), 'hex');
+  if (!/^(0x)?[0-9a-fA-F]*$/.test(constructorArgs)) {
+    throw new Error('Constructor arguments are not a valid hex string');
+  }
+
+  const buf = Buffer.concat([
+    Buffer.from(bytecode.replace(/^0x/, ''), 'hex'),
+    Buffer.from(constructorArgs.replace(/^0x/, ''), 'hex'),
+  ]);
+
   return keccak256(buf).toString('hex');
 }
 
-export function hashBytecodeWithoutMetadata(bytecode: string): string {
-  return hashBytecode(trimBytecodeMetadata(bytecode));
+export function hashBytecodeWithoutMetadata(bytecode: string, constructorArgs = ''): string {
+  return hashBytecode(trimBytecodeMetadata(bytecode), constructorArgs);
 }
 
 function trimBytecodeMetadata(bytecode: string): string {

package/CHANGELOG.md

@@ -1,110 +0,0 @@
-# Changelog
-
-## 1.9.1 (2021-09-15)
-
-- Silence all warnings when using `silenceWarnings`.
-
-## 1.9.0 (2021-08-25)
-
-- Add `getBeaconAddress`. ([#413](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/413))
-
-## 1.8.1 (2021-08-06)
-
-- Add support for function types.
-
-## 1.8.0 (2021-06-29)
-
-- Add option `unsafeAllowRenames` to configure storage layout check to allow variable renaming.
-
-## 1.7.6 (2021-05-25)
-
-- Fix recognition of value types in storage layouts.
-
-## 1.7.5 (2021-05-22)
-
-- Fix exception when upgrading mapping key to enum.
-
-## 1.7.4 (2021-05-22)
-
-- Fix handling of functions with struct or mapping storage pointer arguments.
-
-## 1.7.3 (2021-05-13)
-
-- Simplify clean up of manifest data before storing to disk.
-
-## 1.7.2 (2021-05-13)
-
-- Fix bug when the project uses external libraries.
-
-## 1.7.1 (2021-05-03)
-
-- Use `web3_clientVersion` to better detect development networks.
-
-## 1.7.0 (2021-04-29)
-
-- Add support for UUPS proxies. ([#315](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/315))
-- Fix parsing of NatSpec `@custom:oz-upgrades-unsafe-allow` when included in a `/**`-style comment.
-
-## 1.6.0 (2021-04-14)
-- Add `unsafeAllow` as a new field in `ValidationOptions`, which can be used as a manual override to silence any type of validation error. For example, `opts = { unsafeAllow: ['external-library-linking', 'delegatecall'] }` will silence the corresponding checks. ([#320](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/320))
-- Custom NatSpec comments can disable error checks directly from the Solidity code. See `core/contracts/test/ValidationNatspec.sol` for example usage of these NatSpec comments. Note: this requires Solidity >=0.8.2. ([#320](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/320))
-- Fix a bug with library placeholders when hashing contract source code. ([#320](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/320))
-
-## 1.5.1 (2021-02-24)
-
-- Add support for enum keys in mappings. ([#301](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/301))
-
-## 1.5.0 (2021-01-27)
-
-- Add support for structs and enums. ([#261](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/261))
-- Enable optimizations when compiling proxies.
-
-## 1.4.4 (2021-01-14)
-
-- Fix `InvalidDeployment` error on some networks. ([#282](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/282))
-
-## 1.4.3 (2020-12-21)
-
-- Fix a type error caused by duplicate contract names in Truffle.
-
-## 1.4.2 (2020-12-16)
-
-- Fix an error in the `unsafeAllowCustomTypes` flag that would cause other storage layout incompatibilities to be ignored. ([#259](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/259))
-
-Users of this flag are advised to update to this version.
-
-## 1.4.1 (2020-11-30)
-
-- Fix a problem in deployment logic when used with Hyperledger Besu. ([#244](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/244))
-
-## 1.4.0 (2020-11-24)
-
-- Add `silenceWarnings` to emit a single warning and silence all subsequent ones. ([#228](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/228))
-
-## 1.3.1 (2020-11-13)
-
-- Add missing artifact files in the package.
-
-## 1.3.0 (2020-11-13)
-
-- Support Hardhat. ([#214](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/214))
-
-## 1.2.0 (2020-10-16)
-
-- Support new flag `unsafeAllowLinkedLibraries` to allow deployment of contracts with linked libraries. ([#182](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/182))
-
-## 1.1.1 (2020-10-08)
-
-- Fix OpenZeppelin CLI migration for projects that were initialized with ZeppelinOS. ([#193](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/193))
-
-## 1.1.0 (2020-09-18)
-
-- Add ability to migrate from OpenZeppelin CLI. ([#143](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/143))
-
-## 1.0.2 (2020-09-16)
-
-- Fix false positive variable initialization check in Solidity 0.7.1. ([#171](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/171))
-
-## 1.0.1 (2020-09-01)
-
-- Include `src` directory in npm packages. ([#150](https://github.com/OpenZeppelin/openzeppelin-upgrades/pull/150))

package/dist/set-proxy-kind.d.ts

@@ -1,5 +0,0 @@
-import { EthereumProvider } from './provider';
-import { ValidationOptions } from './validate';
-import { ProxyDeployment } from './manifest';
-export declare function setProxyKind(provider: EthereumProvider, proxyAddress: string, opts: ValidationOptions): Promise<ProxyDeployment['kind']>;
-//# sourceMappingURL=set-proxy-kind.d.ts.map

package/dist/set-proxy-kind.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set-proxy-kind.d.ts","sourceRoot":"","sources":["../src/set-proxy-kind.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAgC,eAAe,EAAE,MAAM,YAAY,CAAC;AAE3E,wBAAsB,YAAY,CAChC,QAAQ,EAAE,gBAAgB,EAC1B,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAkBlC"}

package/dist/set-proxy-kind.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setProxyKind = void 0;
-const manifest_1 = require("./manifest");
-async function setProxyKind(provider, proxyAddress, opts) {
-    var _a;
-    const manifest = await manifest_1.Manifest.forNetwork(provider);
-    const manifestDeployment = await manifest.getProxyFromAddress(proxyAddress).catch(e => {
-        if (e instanceof manifest_1.DeploymentNotFound) {
-            return undefined;
-        }
-        else {
-            throw e;
-        }
-    });
-    if (opts.kind === undefined) {
-        opts.kind = (_a = manifestDeployment === null || manifestDeployment === void 0 ? void 0 : manifestDeployment.kind) !== null && _a !== void 0 ? _a : 'transparent';
-    }
-    else if (manifestDeployment && opts.kind !== manifestDeployment.kind) {
-        throw new Error(`Requested an upgrade of kind ${opts.kind} but proxy is ${manifestDeployment.kind}`);
-    }
-    return opts.kind;
-}
-exports.setProxyKind = setProxyKind;
-//# sourceMappingURL=set-proxy-kind.js.map

package/dist/set-proxy-kind.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"set-proxy-kind.js","sourceRoot":"","sources":["../src/set-proxy-kind.ts"],"names":[],"mappings":";;;AAEA,yCAA2E;AAEpE,KAAK,UAAU,YAAY,CAChC,QAA0B,EAC1B,YAAoB,EACpB,IAAuB;;IAEvB,MAAM,QAAQ,GAAG,MAAM,mBAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IAErD,MAAM,kBAAkB,GAAG,MAAM,QAAQ,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;QACpF,IAAI,CAAC,YAAY,6BAAkB,EAAE;YACnC,OAAO,SAAS,CAAC;SAClB;aAAM;YACL,MAAM,CAAC,CAAC;SACT;IACH,CAAC,CAAC,CAAC;IAEH,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE;QAC3B,IAAI,CAAC,IAAI,GAAG,MAAA,kBAAkB,aAAlB,kBAAkB,uBAAlB,kBAAkB,CAAE,IAAI,mCAAI,aAAa,CAAC;KACvD;SAAM,IAAI,kBAAkB,IAAI,IAAI,CAAC,IAAI,KAAK,kBAAkB,CAAC,IAAI,EAAE;QACtE,MAAM,IAAI,KAAK,CAAC,gCAAgC,IAAI,CAAC,IAAI,iBAAiB,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC;KACtG;IAED,OAAO,IAAI,CAAC,IAAI,CAAC;AACnB,CAAC;AAtBD,oCAsBC"}

package/src/set-proxy-kind.ts

@@ -1,27 +0,0 @@
-import { EthereumProvider } from './provider';
-import { ValidationOptions } from './validate';
-import { Manifest, DeploymentNotFound, ProxyDeployment } from './manifest';
-
-export async function setProxyKind(
-  provider: EthereumProvider,
-  proxyAddress: string,
-  opts: ValidationOptions,
-): Promise<ProxyDeployment['kind']> {
-  const manifest = await Manifest.forNetwork(provider);
-
-  const manifestDeployment = await manifest.getProxyFromAddress(proxyAddress).catch(e => {
-    if (e instanceof DeploymentNotFound) {
-      return undefined;
-    } else {
-      throw e;
-    }
-  });
-
-  if (opts.kind === undefined) {
-    opts.kind = manifestDeployment?.kind ?? 'transparent';
-  } else if (manifestDeployment && opts.kind !== manifestDeployment.kind) {
-    throw new Error(`Requested an upgrade of kind ${opts.kind} but proxy is ${manifestDeployment.kind}`);
-  }
-
-  return opts.kind;
-}