Contract manager upgrades (#952)

* Reuse xc_governance logic as much as possible in contract manager

Some functions in xc_governance were moved and refactored in order to become usable in
contract manager

* Add getBaseUpdateFee function for contract manager

* Add method for executeGovernanceInstructions

* Move up SetFee method to base class

* Add governance upgrade instruction

* Move governance payload generators out of contract classes into chain classes

* Switch from json to yaml for storage

* Remove test script for ci

* Add minimal aptos implementation

* Remove global Chains and Contracts variable and put them in DefaultStore

* Move aptos getClient function to Chain class

* Make denom field in baseUpdateFee optional and remove it from non-cosmwasm chains

* More documentation and minor fixes

* Add vaults storage

Although the set of vaults used in testing/production is just 2 it's a good idea to
not set them as predefined constants. So that for development purposes, we can create
new vaults and test them on the fly without changing too many places.

Author: m30m

contract_manager/examples/deploy_cosmwasm.ts

@@ -0,0 +1,48 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { CosmWasmChain } from "../src/chains";
+import { CosmWasmContract } from "../src/cosmwasm";
+import { DefaultStore } from "../src/store";
+
+const parser = yargs(hideBin(process.argv))
+  .scriptName("deploy_cosmwasm.ts")
+  .usage(
+    "Usage: $0 --code <path/to/artifact.wasm> --mnemonic <mnemonic> --chain <chain>"
+  )
+  .options({
+    code: {
+      type: "string",
+      demandOption: true,
+      desc: "Path to the artifact .wasm file",
+    },
+    mnemonic: {
+      type: "string",
+      demandOption: true,
+      desc: "Mnemonic to use for the deployment",
+    },
+    chain: {
+      type: "string",
+      demandOption: true,
+      desc: "Chain to upload the code on. Can be one of the chains available in the store",
+    },
+    wormholeContract: {
+      type: "string",
+      demandOption: true,
+      desc: "Wormhole contract address deployed on this chain",
+    },
+  });
+
+async function main() {
+  const argv = await parser.argv;
+  const { code, wormholeContract } = argv;
+  console.log(
+    await CosmWasmContract.deploy(
+      DefaultStore.chains[argv.chain] as CosmWasmChain,
+      wormholeContract,
+      argv.mnemonic,
+      code
+    )
+  );
+}
+
+main();

contract_manager/package.json

@@ -5,7 +5,6 @@
   "private": true,
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
     "shell": "ts-node ./src/shell.ts"
   },
   "author": "",
@@ -15,10 +14,11 @@
     "url": "git+https://github.com/pyth-network/pyth-crosschain.git"
   },
   "dependencies": {
+    "@certusone/wormhole-sdk": "^0.9.8",
     "@pythnetwork/cosmwasm-deploy-tools": "*",
     "@pythnetwork/price-service-client": "*",
     "@pythnetwork/xc-governance-sdk": "*",
-    "@certusone/wormhole-sdk": "^0.9.8",
+    "bs58": "^5.0.0",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.3"
   },

contract_manager/src/aptos.ts

@@ -0,0 +1,103 @@
+import { Contract } from "./base";
+import { AptosChain, Chain } from "./chains";
+import { DataSource, HexString32Bytes } from "@pythnetwork/xc-governance-sdk";
+import { AptosClient } from "aptos";
+
+export class AptosContract extends Contract {
+  static type: string = "AptosContract";
+
+  /**
+   * Given the ids of the pyth state and wormhole state, create a new AptosContract
+   * The package ids are derived based on the state ids
+   *
+   * @param chain the chain which this contract is deployed on
+   * @param stateId id of the pyth state for the deployed contract
+   * @param wormholeStateId id of the wormhole state for the wormhole contract that pyth binds to
+   */
+  constructor(
+    public chain: AptosChain,
+    public stateId: string,
+    public wormholeStateId: string
+  ) {
+    super();
+  }
+
+  static fromJson(chain: Chain, parsed: any): AptosContract {
+    if (parsed.type !== AptosContract.type) throw new Error("Invalid type");
+    if (!(chain instanceof AptosChain))
+      throw new Error(`Wrong chain type ${chain}`);
+    return new AptosContract(chain, parsed.stateId, parsed.wormholeStateId);
+  }
+
+  executeGovernanceInstruction(sender: any, vaa: Buffer): Promise<any> {
+    throw new Error("Method not implemented.");
+  }
+
+  getStateResources() {
+    const client = this.chain.getClient();
+    return client.getAccountResources(this.stateId);
+  }
+
+  /**
+   * Returns the first occurrence of a resource with the given type in the pyth package state
+   * @param type
+   */
+  async findResource(type: string) {
+    const resources = await this.getStateResources();
+    for (const resource of resources) {
+      if (resource.type === `${this.stateId}::state::${type}`) {
+        return resource.data;
+      }
+    }
+    throw new Error(`${type} resource not found in state ${this.stateId}`);
+  }
+
+  async getBaseUpdateFee() {
+    const data = (await this.findResource("BaseUpdateFee")) as any;
+    return { amount: data.fee };
+  }
+
+  getChain(): AptosChain {
+    return this.chain;
+  }
+
+  async getDataSources(): Promise<DataSource[]> {
+    const data = (await this.findResource("DataSources")) as any;
+    return data.sources.keys.map((source: any) => {
+      return new DataSource(
+        Number(source.emitter_chain),
+        new HexString32Bytes(source.emitter_address.external_address)
+      );
+    });
+  }
+
+  async getGovernanceDataSource(): Promise<DataSource> {
+    const data = (await this.findResource("GovernanceDataSource")) as any;
+    return new DataSource(
+      Number(data.source.emitter_chain),
+      new HexString32Bytes(data.source.emitter_address.external_address)
+    );
+  }
+
+  getId(): string {
+    return `${this.chain.getId()}_${this.stateId}`;
+  }
+
+  getType(): string {
+    return AptosContract.type;
+  }
+
+  async getValidTimePeriod() {
+    const data = (await this.findResource("StalePriceThreshold")) as any;
+    return Number(data.threshold_secs);
+  }
+
+  toJson() {
+    return {
+      chain: this.chain.id,
+      stateId: this.stateId,
+      wormholeStateId: this.wormholeStateId,
+      type: AptosContract.type,
+    };
+  }
+}

contract_manager/src/base.ts

@@ -1,4 +1,10 @@
-import { DataSource, HexString32Bytes } from "@pythnetwork/xc-governance-sdk";
+import {
+  CHAINS,
+  DataSource,
+  HexString32Bytes,
+  SetFeeInstruction,
+} from "@pythnetwork/xc-governance-sdk";
+import { Chain } from "./chains";
 
 export abstract class Storable {
   /**
@@ -25,11 +31,29 @@ export abstract class Contract extends Storable {
    */
   abstract getValidTimePeriod(): Promise<number>;
 
+  /**
+   * Returns the chain that this contract is deployed on
+   */
+  abstract getChain(): Chain;
+
   /**
    * Returns an array of data sources that this contract accepts price feed messages from
    */
   abstract getDataSources(): Promise<DataSource[]>;
 
+  /**
+   * Returns the base update fee for this contract
+   * This is the required fee for updating the price feeds in the contract
+   */
+  abstract getBaseUpdateFee(): Promise<{ amount: string; denom?: string }>;
+
+  /**
+   * Executes the governance instruction contained in the VAA using the sender credentials
+   * @param sender based on the contract type, this can be a private key, a mnemonic, a wallet, etc.
+   * @param vaa the VAA to execute
+   */
+  abstract executeGovernanceInstruction(sender: any, vaa: Buffer): Promise<any>;
+
   /**
    * Returns the single data source that this contract accepts governance messages from
    */

contract_manager/src/chains.ts

@@ -1,5 +1,16 @@
 import { readdirSync, readFileSync, writeFileSync } from "fs";
 import { Storable } from "./base";
+import {
+  CHAINS,
+  CosmwasmUpgradeContractInstruction,
+  EthereumUpgradeContractInstruction,
+  HexString20Bytes,
+  HexString32Bytes,
+  SetFeeInstruction,
+  SuiAuthorizeUpgradeContractInstruction,
+} from "@pythnetwork/xc-governance-sdk";
+import { BufferBuilder } from "@pythnetwork/xc-governance-sdk/lib/serialize";
+import { AptosClient } from "aptos";
 
 export abstract class Chain extends Storable {
   protected constructor(public id: string) {
@@ -9,6 +20,25 @@ export abstract class Chain extends Storable {
   getId(): string {
     return this.id;
   }
+
+  /**
+   * Returns the payload for a governance SetFee instruction for contracts deployed on this chain
+   * @param fee the new fee to set
+   * @param exponent the new fee exponent to set
+   */
+  generateGovernanceSetFeePayload(fee: number, exponent: number): Buffer {
+    return new SetFeeInstruction(
+      CHAINS[this.getId() as keyof typeof CHAINS],
+      BigInt(fee),
+      BigInt(exponent)
+    ).serialize();
+  }
+
+  /**
+   * Returns the payload for a governance contract upgrade instruction for contracts deployed on this chain
+   * @param upgradeInfo based on the contract type, this can be a contract address, codeId, package digest, etc.
+   */
+  abstract generateGovernanceUpgradePayload(upgradeInfo: any): Buffer;
 }
 
 export class CosmWasmChain extends Chain {
@@ -52,6 +82,13 @@ export class CosmWasmChain extends Chain {
   getType(): string {
     return CosmWasmChain.type;
   }
+
+  generateGovernanceUpgradePayload(codeId: bigint): Buffer {
+    return new CosmwasmUpgradeContractInstruction(
+      CHAINS[this.getId() as keyof typeof CHAINS],
+      codeId
+    ).serialize();
+  }
 }
 
 export class SuiChain extends Chain {
@@ -77,6 +114,40 @@ export class SuiChain extends Chain {
   getType(): string {
     return SuiChain.type;
   }
+
+  private wrapWithWormholeGovernancePayload(
+    actionVariant: number,
+    payload: Buffer
+  ): Buffer {
+    const builder = new BufferBuilder();
+    builder.addBuffer(
+      Buffer.from(
+        "0000000000000000000000000000000000000000000000000000000000000001",
+        "hex"
+      )
+    );
+    builder.addUint8(actionVariant);
+    builder.addUint16(CHAINS["sui"]); // should always be sui (21) no matter devnet or testnet
+    builder.addBuffer(payload);
+    return builder.build();
+  }
+
+  generateGovernanceUpgradePayload(digest: string): Buffer {
+    let setFee = new SuiAuthorizeUpgradeContractInstruction(
+      CHAINS["sui"],
+      new HexString32Bytes(digest)
+    ).serialize();
+    return this.wrapWithWormholeGovernancePayload(0, setFee);
+  }
+
+  generateGovernanceSetFeePayload(fee: number, exponent: number): Buffer {
+    let setFee = new SetFeeInstruction(
+      CHAINS["sui"],
+      BigInt(fee),
+      BigInt(exponent)
+    ).serialize();
+    return this.wrapWithWormholeGovernancePayload(3, setFee);
+  }
 }
 
 export class EVMChain extends Chain {
@@ -86,11 +157,18 @@ export class EVMChain extends Chain {
     super(id);
   }
 
-  static fromJson(parsed: any): SuiChain {
+  static fromJson(parsed: any): EVMChain {
     if (parsed.type !== EVMChain.type) throw new Error("Invalid type");
     return new EVMChain(parsed.id, parsed.rpcUrl);
   }
 
+  generateGovernanceUpgradePayload(address: HexString20Bytes): Buffer {
+    return new EthereumUpgradeContractInstruction(
+      CHAINS[this.getId() as keyof typeof CHAINS],
+      address
+    ).serialize();
+  }
+
   toJson(): any {
     return {
       id: this.id,
@@ -104,4 +182,46 @@ export class EVMChain extends Chain {
   }
 }
 
-export const Chains: Record<string, Chain> = {};
+export class AptosChain extends Chain {
+  static type = "AptosChain";
+
+  constructor(id: string, public rpcUrl: string) {
+    super(id);
+  }
+
+  getClient(): AptosClient {
+    return new AptosClient(this.rpcUrl);
+  }
+
+  generateGovernanceUpgradePayload(digest: string): Buffer {
+    return new SuiAuthorizeUpgradeContractInstruction(
+      CHAINS["aptos"],
+      new HexString32Bytes(digest)
+    ).serialize();
+  }
+
+  generateGovernanceSetFeePayload(fee: number, exponent: number): Buffer {
+    return new SetFeeInstruction(
+      CHAINS["aptos"], // should always be aptos (22) no matter devnet or testnet or mainnet
+      BigInt(fee),
+      BigInt(exponent)
+    ).serialize();
+  }
+
+  getType(): string {
+    return AptosChain.type;
+  }
+
+  toJson(): any {
+    return {
+      id: this.id,
+      rpcUrl: this.rpcUrl,
+      type: AptosChain.type,
+    };
+  }
+
+  static fromJson(parsed: any): AptosChain {
+    if (parsed.type !== AptosChain.type) throw new Error("Invalid type");
+    return new AptosChain(parsed.id, parsed.rpcUrl);
+  }
+}