Implement PythGovernanceAction (#906)

* blah

* rename workflow

* grrr

* ok progress

* ok progress

* ok progress

* grrr

* ok

* fix

* fix layout

Author: jayantk

.github/workflows/xc-admin-frontend-image-push.yaml

@@ -1,4 +1,4 @@
-name: Build and Push Cross Chain Admin Frontend
+name: xc_admin_frontend Docker Image
 on:
   pull_request:
   push:

governance/xc_admin/packages/xc_admin_common/package.json

@@ -38,6 +38,7 @@
     "@types/lodash": "^4.14.191",
     "jest": "^29.3.1",
     "prettier": "^2.8.1",
-    "ts-jest": "^29.0.3"
+    "ts-jest": "^29.0.3",
+    "fast-check": "^3.10.0"
   }
 }

governance/xc_admin/packages/xc_admin_common/src/__tests__/GovernancePayload.test.ts

@@ -1,5 +1,39 @@
 import { PublicKey, SystemProgram } from "@solana/web3.js";
-import { PythGovernanceHeader, ExecutePostedVaa } from "..";
+import {
+  PythGovernanceHeader,
+  ExecutePostedVaa,
+  MODULES,
+  MODULE_EXECUTOR,
+  TargetAction,
+  ExecutorAction,
+  ActionName,
+  PythGovernanceAction,
+  decodeGovernancePayload,
+} from "..";
+import * as fc from "fast-check";
+import {
+  ChainId,
+  ChainName,
+  CHAINS,
+  toChainId,
+  toChainName,
+} from "@certusone/wormhole-sdk";
+import { Arbitrary, IntArrayConstraints } from "fast-check";
+import {
+  AptosAuthorizeUpgradeContract,
+  CosmosUpgradeContract,
+  EvmUpgradeContract,
+} from "../governance_payload/UpgradeContract";
+import {
+  AuthorizeGovernanceDataSourceTransfer,
+  RequestGovernanceDataSourceTransfer,
+} from "../governance_payload/GovernanceDataSourceTransfer";
+import { SetFee } from "../governance_payload/SetFee";
+import { SetValidPeriod } from "../governance_payload/SetValidPeriod";
+import {
+  DataSource,
+  SetDataSources,
+} from "../governance_payload/SetDataSources";
 
 test("GovernancePayload ser/de", (done) => {
   jest.setTimeout(60000);
@@ -121,3 +155,142 @@ test("GovernancePayload ser/de", (done) => {
 
   done();
 });
+
+/** Fastcheck generator for arbitrary PythGovernanceHeaders */
+function governanceHeaderArb(): Arbitrary<PythGovernanceHeader> {
+  const actions = [
+    ...Object.keys(ExecutorAction),
+    ...Object.keys(TargetAction),
+  ] as ActionName[];
+  const actionArb = fc.constantFrom(...actions);
+  const targetChainIdArb = fc.constantFrom(
+    ...(Object.keys(CHAINS) as ChainName[])
+  );
+
+  return actionArb.chain((action) => {
+    return targetChainIdArb.chain((chainId) => {
+      return fc.constant(new PythGovernanceHeader(chainId, action));
+    });
+  });
+}
+
+/** Fastcheck generator for arbitrary Buffers */
+function bufferArb(constraints?: IntArrayConstraints): Arbitrary<Buffer> {
+  return fc.uint8Array(constraints).map((a) => Buffer.from(a));
+}
+
+/** Fastcheck generator for a uint of numBits bits. Warning: don't pass numBits > float precision */
+function uintArb(numBits: number): Arbitrary<number> {
+  return fc.bigUintN(numBits).map((x) => Number.parseInt(x.toString()));
+}
+
+/** Fastcheck generator for a byte array encoded as a hex string. */
+function hexBytesArb(constraints?: IntArrayConstraints): Arbitrary<string> {
+  return fc.uint8Array(constraints).map((a) => Buffer.from(a).toString("hex"));
+}
+
+function dataSourceArb(): Arbitrary<DataSource> {
+  return fc.record({
+    emitterChain: uintArb(16),
+    emitterAddress: hexBytesArb({ minLength: 32, maxLength: 32 }),
+  });
+}
+
+/**
+ * Fastcheck generator for arbitrary PythGovernanceActions.
+ *
+ * Note that this generator doesn't generate ExecutePostedVaa instruction payloads because they're hard to generate.
+ */
+function governanceActionArb(): Arbitrary<PythGovernanceAction> {
+  return governanceHeaderArb().chain<PythGovernanceAction>((header) => {
+    if (header.action === "ExecutePostedVaa") {
+      // NOTE: the instructions field is hard to generatively test, so we're using the hardcoded
+      // tests above instead.
+      return fc.constant(new ExecutePostedVaa(header.targetChainId, []));
+    } else if (header.action === "UpgradeContract") {
+      const cosmosArb = fc.bigUintN(64).map((codeId) => {
+        return new CosmosUpgradeContract(header.targetChainId, codeId);
+      });
+      const aptosArb = hexBytesArb({ minLength: 32, maxLength: 32 }).map(
+        (buffer) => {
+          return new AptosAuthorizeUpgradeContract(
+            header.targetChainId,
+            buffer
+          );
+        }
+      );
+      const evmArb = hexBytesArb({ minLength: 20, maxLength: 20 }).map(
+        (address) => {
+          return new EvmUpgradeContract(header.targetChainId, address);
+        }
+      );
+
+      return fc.oneof(cosmosArb, aptosArb, evmArb);
+    } else if (header.action === "AuthorizeGovernanceDataSourceTransfer") {
+      return bufferArb().map((claimVaa) => {
+        return new AuthorizeGovernanceDataSourceTransfer(
+          header.targetChainId,
+          claimVaa
+        );
+      });
+    } else if (header.action === "SetDataSources") {
+      return fc.array(dataSourceArb()).map((dataSources) => {
+        return new SetDataSources(header.targetChainId, dataSources);
+      });
+    } else if (header.action === "SetFee") {
+      return fc
+        .record({ v: fc.bigUintN(64), e: fc.bigUintN(64) })
+        .map(({ v, e }) => {
+          return new SetFee(header.targetChainId, v, e);
+        });
+    } else if (header.action === "SetValidPeriod") {
+      return fc.bigUintN(64).map((period) => {
+        return new SetValidPeriod(header.targetChainId, period);
+      });
+    } else if (header.action === "RequestGovernanceDataSourceTransfer") {
+      return fc.bigUintN(32).map((index) => {
+        return new RequestGovernanceDataSourceTransfer(
+          header.targetChainId,
+          parseInt(index.toString())
+        );
+      });
+    } else {
+      throw new Error("Unsupported action type");
+    }
+  });
+}
+
+test("Header serialization round-trip test", (done) => {
+  fc.assert(
+    fc.property(governanceHeaderArb(), (original) => {
+      const decoded = PythGovernanceHeader.decode(original.encode());
+      if (decoded === undefined) {
+        return false;
+      }
+
+      return (
+        decoded.action === original.action &&
+        decoded.targetChainId === original.targetChainId
+      );
+    })
+  );
+
+  done();
+});
+
+test("Governance action serialization round-trip test", (done) => {
+  fc.assert(
+    fc.property(governanceActionArb(), (original) => {
+      const encoded = original.encode();
+      const decoded = decodeGovernancePayload(encoded);
+      if (decoded === undefined) {
+        return false;
+      }
+
+      // TODO: not sure if i love this test.
+      return decoded.encode().equals(original.encode());
+    })
+  );
+
+  done();
+});

governance/xc_admin/packages/xc_admin_common/src/governance_payload/BufferLayoutExt.ts

@@ -0,0 +1,51 @@
+import { Layout } from "@solana/buffer-layout";
+
+export class UInt64BE extends Layout<bigint> {
+  constructor(span: number, property?: string) {
+    super(span, property);
+  }
+
+  override decode(b: Uint8Array, offset?: number): bigint {
+    let o = offset ?? 0;
+    return Buffer.from(b.slice(o, o + this.span)).readBigUInt64BE();
+  }
+
+  override encode(src: bigint, b: Uint8Array, offset?: number): number {
+    const buffer = Buffer.alloc(this.span);
+    buffer.writeBigUint64BE(src);
+    b.set(buffer, offset);
+    return this.span;
+  }
+}
+
+export class HexBytes extends Layout<string> {
+  // span is the number of bytes to read
+  constructor(span: number, property?: string) {
+    super(span, property);
+  }
+
+  override decode(b: Uint8Array, offset?: number): string {
+    let o = offset ?? 0;
+    return Buffer.from(b.slice(o, o + this.span)).toString("hex");
+  }
+
+  override encode(src: string, b: Uint8Array, offset?: number): number {
+    const buffer = Buffer.alloc(this.span);
+    buffer.write(src, "hex");
+    b.set(buffer, offset);
+    return this.span;
+  }
+}
+
+/** A big-endian u64, returned as a bigint. */
+export function u64be(property?: string | undefined): UInt64BE {
+  return new UInt64BE(8, property);
+}
+
+/** An array of numBytes bytes, returned as a hexadecimal string. */
+export function hexBytes(
+  numBytes: number,
+  property?: string | undefined
+): HexBytes {
+  return new HexBytes(numBytes, property);
+}

governance/xc_admin/packages/xc_admin_common/src/governance_payload/GovernanceDataSourceTransfer.ts

@@ -0,0 +1,84 @@
+import {
+  ActionName,
+  PythGovernanceAction,
+  PythGovernanceActionImpl,
+  PythGovernanceHeader,
+} from "./PythGovernanceAction";
+import * as BufferLayout from "@solana/buffer-layout";
+import { ChainName } from "@certusone/wormhole-sdk";
+
+/**
+ * Authorize transferring the governance data source from the sender's emitter address to another emitter.
+ * The receiving emitter address is the sender of claimVaa, which must be a RequestGovernanceDataSourceTransfer message.
+ */
+export class AuthorizeGovernanceDataSourceTransfer
+  implements PythGovernanceAction
+{
+  readonly actionName: ActionName;
+  readonly claimVaa: Buffer;
+
+  constructor(readonly targetChainId: ChainName, vaa: Buffer) {
+    this.actionName = "AuthorizeGovernanceDataSourceTransfer";
+    this.claimVaa = new Buffer(vaa);
+  }
+
+  static decode(
+    data: Buffer
+  ): AuthorizeGovernanceDataSourceTransfer | undefined {
+    const header = PythGovernanceHeader.decode(data);
+    if (!header || header.action !== "AuthorizeGovernanceDataSourceTransfer") {
+      return undefined;
+    }
+
+    const payload = data.subarray(PythGovernanceHeader.span, data.length);
+
+    return new AuthorizeGovernanceDataSourceTransfer(
+      header.targetChainId,
+      payload
+    );
+  }
+
+  encode(): Buffer {
+    const headerBuffer = new PythGovernanceHeader(
+      this.targetChainId,
+      this.actionName
+    ).encode();
+    return Buffer.concat([headerBuffer, this.claimVaa]);
+  }
+}
+
+/**
+ * Request a transfer of the governance data source to the emitter of this message.
+ */
+export class RequestGovernanceDataSourceTransfer extends PythGovernanceActionImpl {
+  static layout: BufferLayout.Structure<
+    Readonly<{ governanceDataSourceIndex: number }>
+  > = BufferLayout.struct([BufferLayout.u32be()]);
+
+  constructor(
+    targetChainId: ChainName,
+    readonly governanceDataSourceIndex: number
+  ) {
+    super(targetChainId, "RequestGovernanceDataSourceTransfer");
+  }
+
+  static decode(data: Buffer): RequestGovernanceDataSourceTransfer | undefined {
+    const decoded = PythGovernanceActionImpl.decodeWithPayload(
+      data,
+      "RequestGovernanceDataSourceTransfer",
+      RequestGovernanceDataSourceTransfer.layout
+    );
+    if (!decoded) return undefined;
+
+    return new RequestGovernanceDataSourceTransfer(
+      decoded[0].targetChainId,
+      decoded[1].governanceDataSourceIndex
+    );
+  }
+
+  encode(): Buffer {
+    return super.encodeWithPayload(RequestGovernanceDataSourceTransfer.layout, {
+      governanceDataSourceIndex: this.governanceDataSourceIndex,
+    });
+  }
+}