@openzeppelin/upgrades-core 1.9.1

package/src/version.test.ts

@@ -0,0 +1,59 @@
+import test from 'ava';
+import { artifacts } from 'hardhat';
+import { hashBytecodeWithoutMetadata, hashBytecode } from './version';
+
+const contractBytecode = '01234567890abcdef';
+
+test('same code different formatting produces different metadata', async t => {
+  async function getBytecodeByContractName(contractName: string): Promise<string> {
+    const buildInfo = await artifacts.getBuildInfo('contracts/test/Version.sol:Greeter');
+    if (buildInfo === undefined) {
+      throw new Error('Build info not found');
+    }
+    const solcOutput = buildInfo.output;
+    return solcOutput.contracts['contracts/test/Version.sol'][contractName].evm.bytecode.object;
+  }
+
+  const GreeterBytecode = await getBytecodeByContractName('Greeter');
+  const GreeterDifferentFormattingBytecode = await getBytecodeByContractName('GreeterDifferentFormatting');
+
+  t.not(hashBytecode(GreeterBytecode), hashBytecode(GreeterDifferentFormattingBytecode));
+  t.is(hashBytecodeWithoutMetadata(GreeterBytecode), hashBytecodeWithoutMetadata(GreeterDifferentFormattingBytecode));
+});
+
+test('removes metadata from Solidity 0.4 bytecode', t => {
+  const swarmHash = '69b1869ae52f674ffccdd8f6d35de04d578a778e919a1b41b7a2177668e08e1a';
+  const swarmHashWrapper = `65627a7a72305820${swarmHash}`;
+  const metadata = `a1${swarmHashWrapper}0029`;
+  const bytecode = `0x${contractBytecode}${metadata}`;
+
+  t.is(hashBytecodeWithoutMetadata(bytecode), hashBytecode(`0x${contractBytecode}`));
+});
+
+test('removes metadata from Solidity ^0.5.9 bytecode', t => {
+  // Solidity 0.5.9 includes solc version into the CBOR encoded metadata
+  // https://github.com/ethereum/solidity/releases/tag/v0.5.9
+  const swarmHash = '69b1869ae52f674ffccdd8f6d35de04d578a778e919a1b41b7a2177668e08e1a';
+  const swarmHashWrapper = `65627a7a72305820${swarmHash}`;
+  const solcVersionWrapper = '64736f6c6343000509';
+  const metadata = `a2${swarmHashWrapper}${solcVersionWrapper}0032`;
+  const bytecode = `0x${contractBytecode}${metadata}`;
+
+  t.is(hashBytecodeWithoutMetadata(bytecode), hashBytecode(`0x${contractBytecode}`));
+});
+
+test('does not change the bytecode if metadata encoding is invalid', t => {
+  const swarmHash = '69b1869ae52f674ffccdd8f6d35de04d578a778e919a1b41b7a2177668e08e1a';
+  const invalidSwarmHashWrapper = `a165627a7a72305821${swarmHash}0029`;
+  const bytecode = `0x${contractBytecode}${invalidSwarmHashWrapper}`;
+
+  t.is(hashBytecodeWithoutMetadata(bytecode), hashBytecode(bytecode));
+});
+
+test('does not change the bytecode if metadata length is not reliable', t => {
+  const swarmHash = '69b1869ae52f674ffccdd8f6d35de04d578a778e919a1b41b7a2177668e08e1a';
+  const invalidSwarmHashWrapper = `a165627a7a72305821${swarmHash}9929`;
+  const bytecode = `0x${contractBytecode}${invalidSwarmHashWrapper}`;
+
+  t.is(hashBytecodeWithoutMetadata(bytecode), hashBytecode(bytecode));
+});

package/src/version.ts

@@ -0,0 +1,71 @@
+import { keccak256 } from 'ethereumjs-util';
+import cbor from 'cbor';
+
+export interface Version {
+  withMetadata: string;
+  withoutMetadata: string;
+  linkedWithoutMetadata: string;
+}
+
+export function getVersion(bytecode: string, linkedBytecode?: string): Version {
+  if (bytecode !== '') {
+    return {
+      withMetadata: hashBytecode(bytecode),
+      withoutMetadata: hashBytecodeWithoutMetadata(bytecode),
+      linkedWithoutMetadata: hashBytecodeWithoutMetadata(linkedBytecode ?? bytecode),
+    };
+  } else {
+    throw new Error('Abstract contract not allowed here');
+  }
+}
+
+export function hashBytecode(bytecode: string): 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));
+
+  // Fail if bytecode is still not valid hex after transformations above.
+  // Buffer.from silently truncates at the first non-hex character.
+  // NOTE: Some bytecode seems to have odd length, so we cannot do ([0-9a-fA-F]{2})*
+  if (!/^(0x)?[0-9a-fA-F]*$/.test(bytecode)) {
+    throw new Error('Bytecode is not a valid hex string');
+  }
+
+  const buf = Buffer.from(bytecode.replace(/^0x/, ''), 'hex');
+  return keccak256(buf).toString('hex');
+}
+
+export function hashBytecodeWithoutMetadata(bytecode: string): string {
+  return hashBytecode(trimBytecodeMetadata(bytecode));
+}
+
+function trimBytecodeMetadata(bytecode: string): string {
+  // Bail on empty bytecode
+  if (bytecode.length <= 4) {
+    return bytecode;
+  }
+
+  // Gather length of CBOR metadata from the end of the file
+  const rawLength = bytecode.slice(bytecode.length - 4);
+  const metadataLength = parseInt(rawLength, 16) * 2;
+
+  // Bail on unreasonable values for length
+  if (metadataLength > bytecode.length - 4) {
+    return bytecode;
+  }
+
+  // Gather what we assume is the CBOR encoded metadata, and try to parse it
+  const metadataStart = bytecode.length - metadataLength - 4;
+  const metadata = bytecode.slice(metadataStart, bytecode.length - 4);
+
+  // Parse it to see if it is indeed valid metadata
+  try {
+    cbor.decode(Buffer.from(metadata, 'hex'));
+  } catch (err) {
+    // to do: log lack metadata to the user
+    return bytecode;
+  }
+
+  // Return bytecode without it
+  return bytecode.slice(0, metadataStart);
+}