[contract-manager] More utility scripts and docs (#1222)

* Remove mainnet condition in check proposal

Testnet contracts can also listen to mainnet governance so this check does not make
sense anymore

* Simple script for executing vaas

* Add script for evm upgrades

* Script to list evm contracts with their versions

* More docs

Author: m30m

contract_manager/.gitignore

@@ -1 +1,3 @@
 lib/
+.cache*
+docs

contract_manager/README.md

@@ -7,3 +7,21 @@ It has the following structure:
 - `store` contains all the necessary information for registered chains and deployed contracts
 - `scripts` contains utility scripts to interact with the contract manager and accomplish common tasks
 - `src` contains the contract manager code
+
+# Main Entities
+
+Contract Manager has base classes which you can use to interact with the following entities:
+
+- Chain
+- PythContract
+- WormholeContract
+
+Each of these entities has a specialized class for each supported chain (EVM/Cosmos/Aptos/Sui).
+
+# Docs
+
+You can generate the docs by running `npx typedoc src/index.ts` from this directory. Open the docs by opening `docs/index.html` in your browser.
+
+# Scripts
+
+You can run the scripts by executing `npx ts-node scripts/<script_name>.ts` from this directory.

contract_manager/package.json

@@ -20,18 +20,19 @@
     "url": "git+https://github.com/pyth-network/pyth-crosschain.git"
   },
   "dependencies": {
-    "@mysten/sui.js": "^0.37.1",
     "@certusone/wormhole-sdk": "^0.9.8",
+    "@injectivelabs/networks": "1.0.68",
+    "@mysten/sui.js": "^0.37.1",
     "@pythnetwork/cosmwasm-deploy-tools": "*",
     "@pythnetwork/price-service-client": "*",
     "@pythnetwork/pyth-sui-js": "*",
-    "@injectivelabs/networks": "1.0.68",
     "aptos": "^1.5.0",
     "bs58": "^5.0.0",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.3"
   },
   "devDependencies": {
-    "prettier": "^2.6.2"
+    "prettier": "^2.6.2",
+    "typedoc": "^0.25.7"
   }
 }

contract_manager/scripts/check_proposal.ts

@@ -63,7 +63,6 @@ async function main() {
         for (const chain of Object.values(DefaultStore.chains)) {
           if (
             chain instanceof EvmChain &&
-            chain.isMainnet() === (cluster === "mainnet-beta") &&
             chain.wormholeChainName ===
               instruction.governanceAction.targetChainId
           ) {

contract_manager/scripts/execute_vaas.ts

@@ -0,0 +1,88 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { DefaultStore } from "../src/store";
+import { SubmittedWormholeMessage, Vault } from "../src/governance";
+import { parseVaa } from "@certusone/wormhole-sdk";
+import { decodeGovernancePayload } from "xc_admin_common";
+import { executeVaa } from "../src/executor";
+import { toPrivateKey } from "../src";
+
+const parser = yargs(hideBin(process.argv))
+  .usage(
+    "Tries to execute all vaas on a vault.\n" +
+      "Useful for batch upgrades.\n" +
+      "Usage: $0 --vault <mainnet|devnet> --private-key <private-key> --offset <offset> [--dryrun]"
+  )
+  .options({
+    vault: {
+      type: "string",
+      default: "mainnet",
+      choices: ["mainnet", "devnet"],
+      desc: "Which vault to use for fetching VAAs",
+    },
+    "private-key": {
+      type: "string",
+      demandOption: true,
+      desc: "Private key to sign the transactions executing the governance VAAs. Hex format, without 0x prefix.",
+    },
+    offset: {
+      type: "number",
+      demandOption: true,
+      desc: "Offset to use from the last executed sequence number",
+    },
+    dryrun: {
+      type: "boolean",
+      default: false,
+      desc: "Whether to execute the VAAs or just print them",
+    },
+  });
+
+async function main() {
+  const argv = await parser.argv;
+  let vault: Vault;
+  if (argv.vault === "mainnet") {
+    vault =
+      DefaultStore.vaults[
+        "mainnet-beta_FVQyHcooAtThJ83XFrNnv74BcinbRH3bRmfFamAHBfuj"
+      ];
+  } else {
+    vault =
+      DefaultStore.vaults[
+        "devnet_6baWtW1zTUVMSJHJQVxDUXWzqrQeYBr6mu31j3bTKwY3"
+      ];
+  }
+  console.log("Executing VAAs for vault", vault.getId());
+  console.log(
+    "Executing VAAs for emitter",
+    (await vault.getEmitter()).toBase58()
+  );
+  const lastSequenceNumber = await vault.getLastSequenceNumber();
+  const startSequenceNumber = lastSequenceNumber - argv.offset;
+  console.log(
+    `Going from sequence number ${startSequenceNumber} to ${lastSequenceNumber}`
+  );
+  for (
+    let seqNumber = startSequenceNumber;
+    seqNumber <= lastSequenceNumber;
+    seqNumber++
+  ) {
+    const submittedWormholeMessage = new SubmittedWormholeMessage(
+      await vault.getEmitter(),
+      seqNumber,
+      vault.cluster
+    );
+    const vaa = await submittedWormholeMessage.fetchVaa();
+    const decodedAction = decodeGovernancePayload(parseVaa(vaa).payload);
+    if (!decodedAction) {
+      console.log("Skipping unknown action for vaa ", seqNumber);
+      continue;
+    }
+    console.log("Executing vaa", seqNumber);
+    console.log(decodedAction);
+    if (!argv.dryrun) {
+      await executeVaa(toPrivateKey(argv["private-key"]), vaa);
+    }
+  }
+}
+
+main();

contract_manager/scripts/list_evm_contracts.ts

@@ -0,0 +1,42 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import {
+  AptosContract,
+  CosmWasmContract,
+  DefaultStore,
+  EvmContract,
+} from "../src";
+
+const parser = yargs(hideBin(process.argv))
+  .usage("Usage: $0")
+  .options({
+    testnet: {
+      type: "boolean",
+      default: false,
+      desc: "Fetch testnet contract fees instead of mainnet",
+    },
+  });
+
+async function main() {
+  const argv = await parser.argv;
+  const entries = [];
+  for (const contract of Object.values(DefaultStore.contracts)) {
+    if (contract.getChain().isMainnet() === argv.testnet) continue;
+    if (contract instanceof EvmContract) {
+      try {
+        const version = await contract.getVersion();
+        entries.push({
+          chain: contract.getChain().getId(),
+          contract: contract.address,
+          version: version,
+        });
+        console.log(`Fetched version for ${contract.getId()}`);
+      } catch (e) {
+        console.error(`Error fetching version for ${contract.getId()}`, e);
+      }
+    }
+  }
+  console.table(entries);
+}
+
+main();

contract_manager/scripts/upgrade_evm_contracts.ts

@@ -0,0 +1,127 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { DefaultStore, EvmChain, loadHotWallet, toPrivateKey } from "../src";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+const CACHE_FILE = ".cache-upgrade-evm";
+
+const parser = yargs(hideBin(process.argv))
+  .usage(
+    "Deploys a new PythUpgradable contract to a set of chains and creates a governance proposal for it.\n" +
+      `Uses a cache file (${CACHE_FILE}) to avoid deploying contracts twice\n` +
+      "Usage: $0 --chain <chain_1> --chain <chain_2> --private-key <private_key> --ops-key-path <ops_key_path> --std-output <std_output>"
+  )
+  .options({
+    testnet: {
+      type: "boolean",
+      default: false,
+      desc: "Upgrade testnet contracts instead of mainnet",
+    },
+    "all-chains": {
+      type: "boolean",
+      default: false,
+      desc: "Upgrade the contract on all chains. Use with --testnet flag to upgrade all testnet contracts",
+    },
+    chain: {
+      type: "array",
+      string: true,
+      desc: "Chains to upgrade the contract on",
+    },
+    "private-key": {
+      type: "string",
+      demandOption: true,
+      desc: "Private key to use for the deployment",
+    },
+    "ops-key-path": {
+      type: "string",
+      demandOption: true,
+      desc: "Path to the private key of the proposer to use for the operations multisig governance proposal",
+    },
+    "std-output": {
+      type: "string",
+      demandOption: true,
+      desc: "Path to the standard JSON output of the pyth contract (build artifact)",
+    },
+  });
+
+async function run_if_not_cached(
+  cache_key: string,
+  fn: () => Promise<string>
+): Promise<string> {
+  const cache = existsSync(CACHE_FILE)
+    ? JSON.parse(readFileSync(CACHE_FILE, "utf8"))
+    : {};
+  if (cache[cache_key]) {
+    return cache[cache_key];
+  }
+  const result = await fn();
+  cache[cache_key] = result;
+  writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+  return result;
+}
+
+async function main() {
+  const argv = await parser.argv;
+  const selectedChains: EvmChain[] = [];
+
+  if (argv.allChains && argv.chain)
+    throw new Error("Cannot use both --all-chains and --chain");
+  if (!argv.allChains && !argv.chain)
+    throw new Error("Must use either --all-chains or --chain");
+  for (const chain of Object.values(DefaultStore.chains)) {
+    if (!(chain instanceof EvmChain)) continue;
+    if (
+      (argv.allChains && chain.isMainnet() !== argv.testnet) ||
+      argv.chain?.includes(chain.getId())
+    )
+      selectedChains.push(chain);
+  }
+  if (argv.chain && selectedChains.length !== argv.chain.length)
+    throw new Error(
+      `Some chains were not found ${selectedChains
+        .map((chain) => chain.getId())
+        .toString()}`
+    );
+  for (const chain of selectedChains) {
+    if (chain.isMainnet() != selectedChains[0].isMainnet())
+      throw new Error("All chains must be either mainnet or testnet");
+  }
+
+  const vault =
+    DefaultStore.vaults[
+      "mainnet-beta_FVQyHcooAtThJ83XFrNnv74BcinbRH3bRmfFamAHBfuj"
+    ];
+
+  console.log("Using cache file", CACHE_FILE);
+  console.log(
+    "Upgrading on chains",
+    selectedChains.map((c) => c.getId())
+  );
+
+  const payloads: Buffer[] = [];
+  for (const chain of selectedChains) {
+    const artifact = JSON.parse(readFileSync(argv["std-output"], "utf8"));
+    console.log("Deploying contract to", chain.getId());
+    const address = await run_if_not_cached(`deploy-${chain.getId()}`, () => {
+      return chain.deploy(
+        toPrivateKey(argv["private-key"]),
+        artifact["abi"],
+        artifact["bytecode"],
+        []
+      );
+    });
+    console.log(`Deployed contract at ${address} on ${chain.getId()}`);
+    payloads.push(
+      chain.generateGovernanceUpgradePayload(address.replace("0x", ""))
+    );
+  }
+
+  console.log("Using vault at for proposal", vault.getId());
+  const wallet = await loadHotWallet(argv["ops-key-path"]);
+  console.log("Using wallet ", wallet.publicKey.toBase58());
+  await vault.connect(wallet);
+  const proposal = await vault.proposeWormholeMessage(payloads);
+  console.log("Proposal address", proposal.address.toBase58());
+}
+
+main();

contract_manager/src/executor.ts

@@ -23,8 +23,16 @@ export async function executeVaa(senderPrivateKey: PrivateKey, vaa: Buffer) {
           parsedVaa.emitterAddress.toString("hex") &&
         governanceSource.emitterChain === parsedVaa.emitterChain
       ) {
-        // TODO: check governance sequence number as well
+        const lastExecutedSequence =
+          await contract.getLastExecutedGovernanceSequence();
+        if (lastExecutedSequence >= parsedVaa.sequence) {
+          console.log(
+            `Skipping on contract ${contract.getId()} as it was already executed`
+          );
+          continue;
+        }
         await contract.executeGovernanceInstruction(senderPrivateKey, vaa);
+        console.log(`Executed on contract ${contract.getId()}`);
       }
     }
   }