[xc-admin] Add support for arbitrary wormhole payloads (#759)

* Add vaa

* Remove the command from multisig_wh_message_builder

* Add comment to the multisig addresses

Author: guibescos

governance/multisig_wh_message_builder/src/index.ts

@@ -17,11 +17,7 @@ import { program } from "commander";
 import * as fs from "fs";
 import { LedgerNodeWallet } from "./wallet";
 import lodash from "lodash";
-import {
-  getActiveProposals,
-  getManyProposalsInstructions,
-  getProposalInstructions,
-} from "./multisig";
+import { getProposalInstructions } from "./multisig";
 import {
   WormholeNetwork,
   loadWormholeTools,
@@ -151,130 +147,6 @@ program
     );
   });
 
-program
-  .command("create")
-  .description("Create a new multisig transaction")
-  .option("-c, --cluster <network>", "solana cluster to use", "devnet")
-  .option("-l, --ledger", "use ledger")
-  .option(
-    "-lda, --ledger-derivation-account <number>",
-    "ledger derivation account to use"
-  )
-  .option(
-    "-ldc, --ledger-derivation-change <number>",
-    "ledger derivation change to use"
-  )
-  .option(
-    "-w, --wallet <filepath>",
-    "multisig wallet secret key filepath",
-    "keys/key.json"
-  )
-  .option("-f, --file <filepath>", "Path to a json file with instructions")
-  .option("-p, --payload <hex-string>", "Wormhole VAA payload")
-  .option("-s, --skip-duplicate-check", "Skip checking duplicates")
-  .action(async (options) => {
-    const cluster: Cluster = options.cluster;
-    const squad = await getSquadsClient(
-      cluster,
-      options.ledger,
-      options.ledgerDerivationAccount,
-      options.ledgerDerivationChange,
-      options.wallet
-    );
-
-    if (options.payload && options.file) {
-      console.log("Only one of --payload or --file must be provided");
-      return;
-    }
-
-    if (options.payload) {
-      const wormholeTools = await loadWormholeTools(cluster, squad.connection);
-
-      if (!options.skipDuplicateCheck) {
-        const activeProposals = await getActiveProposals(
-          squad,
-          CONFIG[cluster].vault
-        );
-        const activeInstructions = await getManyProposalsInstructions(
-          squad,
-          activeProposals
-        );
-
-        const msAccount = await squad.getMultisig(CONFIG[cluster].vault);
-        const emitter = squad.getAuthorityPDA(
-          msAccount.publicKey,
-          msAccount.authorityIndex
-        );
-
-        for (let i = 0; i < activeProposals.length; i++) {
-          if (
-            hasWormholePayload(
-              squad,
-              emitter,
-              activeProposals[i].publicKey,
-              options.payload,
-              activeInstructions[i],
-              wormholeTools
-            )
-          ) {
-            console.log(
-              `❌ Skipping, payload ${options.payload} matches instructions at ${activeProposals[i].publicKey}`
-            );
-            return;
-          }
-        }
-      }
-
-      await createWormholeMsgMultisigTx(
-        options.cluster,
-        squad,
-        CONFIG[cluster].vault,
-        options.payload,
-        wormholeTools
-      );
-    }
-
-    if (options.file) {
-      const instructions: SquadInstruction[] = loadInstructionsFromJson(
-        options.file
-      );
-
-      if (!options.skipDuplicateCheck) {
-        const activeProposals = await getActiveProposals(
-          squad,
-          CONFIG[cluster].vault
-        );
-        const activeInstructions = await getManyProposalsInstructions(
-          squad,
-          activeProposals
-        );
-
-        for (let i = 0; i < activeProposals.length; i++) {
-          if (
-            areEqualOnChainInstructions(
-              instructions.map((ix) => ix.instruction),
-              activeInstructions[i]
-            )
-          ) {
-            console.log(
-              `❌ Skipping, instructions from ${options.file} match instructions at ${activeProposals[i].publicKey}`
-            );
-            return;
-          }
-        }
-      }
-
-      const txKey = await createTx(squad, CONFIG[cluster].vault);
-      await addInstructionsToTx(
-        cluster,
-        squad,
-        CONFIG[cluster].vault,
-        txKey,
-        instructions
-      );
-    }
-  });
-
 program
   .command("verify")
   .description("Verify given proposal matches a payload")

governance/xc_admin/packages/xc_admin_cli/src/index.ts

@@ -26,6 +26,7 @@ import {
   mapKey,
   MultisigParser,
   PROGRAM_AUTHORITY_ESCROW,
+  proposeArbitraryPayload,
   proposeInstructions,
   WORMHOLE_ADDRESS,
 } from "xc_admin_common";
@@ -64,7 +65,10 @@ const multisigCommand = (name: string, description: string) =>
       "-w, --wallet <filepath>",
       'path to the operations key or "ledger"'
     )
-    .requiredOption("-v, --vault <pubkey>", "multisig address")
+    .requiredOption(
+      "-v, --vault <pubkey>",
+      "multisig address, all the addresses can be found in xc_admin_common/src/multisig.ts"
+    )
     .option(
       "-lda, --ledger-derivation-account <number>",
       "ledger derivation account to use"
@@ -409,6 +413,33 @@ multisigCommand("propose-sol-transfer", "Propose sol transfer")
     );
   });
 
+multisigCommand("propose-arbitrary-payload", "Propose arbitrary payload")
+  .option("-p, --payload <hex-string>", "Wormhole VAA payload")
+  .action(async (options: any) => {
+    const wallet = await loadHotWalletOrLedger(
+      options.wallet,
+      options.ledgerDerivationAccount,
+      options.ledgerDerivationChange
+    );
+
+    const cluster: PythCluster = options.cluster;
+    const vault: PublicKey = new PublicKey(options.vault);
+
+    const squad = SquadsMesh.endpoint(getPythClusterApiUrl(cluster), wallet);
+
+    let payload = options.payload;
+    if (payload.startsWith("0x")) {
+      payload = payload.substring(2);
+    }
+
+    await proposeArbitraryPayload(
+      squad,
+      vault,
+      Buffer.from(payload, "hex"),
+      WORMHOLE_ADDRESS[cluster]!
+    );
+  });
+
 /**
  * Activate proposal, mostly useful for cleaning up draft proposals that happen when the browser wallet fails to send all transactions succesfully
  */

governance/xc_admin/packages/xc_admin_common/src/propose.ts

@@ -30,6 +30,70 @@ type SquadInstruction = {
   authorityType?: string;
 };
 
+export async function proposeArbitraryPayload(
+  squad: Squads,
+  vault: PublicKey,
+  payload: Buffer,
+  wormholeAddress: PublicKey
+): Promise<PublicKey> {
+  const msAccount = await squad.getMultisig(vault);
+
+  let ixToSend: TransactionInstruction[] = [];
+  const proposalIndex = msAccount.transactionIndex + 1;
+  ixToSend.push(
+    await squad.buildCreateTransaction(
+      msAccount.publicKey,
+      msAccount.authorityIndex,
+      proposalIndex
+    )
+  );
+
+  const newProposalAddress = getTxPDA(
+    vault,
+    new BN(proposalIndex),
+    squad.multisigProgramId
+  )[0];
+
+  const instructionToPropose = await getPostMessageInstruction(
+    squad,
+    vault,
+    newProposalAddress,
+    1,
+    wormholeAddress,
+    payload
+  );
+  ixToSend.push(
+    await squad.buildAddInstruction(
+      vault,
+      newProposalAddress,
+      instructionToPropose.instruction,
+      1,
+      instructionToPropose.authorityIndex,
+      instructionToPropose.authorityBump,
+      instructionToPropose.authorityType
+    )
+  );
+  ixToSend.push(
+    await squad.buildActivateTransaction(vault, newProposalAddress)
+  );
+  ixToSend.push(await squad.buildApproveTransaction(vault, newProposalAddress));
+
+  const txToSend = batchIntoTransactions(ixToSend);
+
+  for (let i = 0; i < txToSend.length; i += SIZE_OF_SIGNED_BATCH) {
+    await new AnchorProvider(
+      squad.connection,
+      squad.wallet,
+      AnchorProvider.defaultOptions()
+    ).sendAll(
+      txToSend.slice(i, i + SIZE_OF_SIGNED_BATCH).map((tx) => {
+        return { tx, signers: [] };
+      })
+    );
+  }
+  return newProposalAddress;
+}
+
 /**
  * Propose an array of `TransactionInstructions` as a proposal
  * @param squad Squads client
@@ -291,14 +355,41 @@ export async function wrapAsRemoteInstruction(
   instructionIndex: number,
   wormholeAddress: PublicKey
 ): Promise<SquadInstruction> {
-  const emitter = squad.getAuthorityPDA(vault, 1);
+  const buffer: Buffer = new ExecutePostedVaa("pythnet", instructions).encode();
+  return await getPostMessageInstruction(
+    squad,
+    vault,
+    proposalAddress,
+    instructionIndex,
+    wormholeAddress,
+    buffer
+  );
+}
 
+/**
+ * Returns a postMessage instruction that will post the provided payload to wormhole when the multisig approves the proposal
+ * @param squad Squads client
+ * @param vault vault public key (the id of the multisig where these instructions should be proposed)
+ * @param proposalAddress address of the proposal
+ * @param instructionIndex index of the instruction within the proposal
+ * @param wormholeAddress address of the Wormhole bridge
+ * @param payload the payload to be posted
+ */
+async function getPostMessageInstruction(
+  squad: Squads,
+  vault: PublicKey,
+  proposalAddress: PublicKey,
+  instructionIndex: number,
+  wormholeAddress: PublicKey,
+  payload: Buffer
+): Promise<SquadInstruction> {
   const [messagePDA, messagePdaBump] = getIxAuthorityPDA(
     proposalAddress,
     new BN(instructionIndex),
     squad.multisigProgramId
   );
 
+  const emitter = squad.getAuthorityPDA(vault, 1);
   const provider = new AnchorProvider(
     squad.connection,
     squad.wallet,
@@ -309,8 +400,6 @@ export async function wrapAsRemoteInstruction(
     provider
   );
 
-  const buffer: Buffer = new ExecutePostedVaa("pythnet", instructions).encode();
-
   const accounts = getPostMessageAccounts(
     wormholeAddress,
     emitter,
@@ -320,14 +409,15 @@ export async function wrapAsRemoteInstruction(
 
   return {
     instruction: await wormholeProgram.methods
-      .postMessage(0, buffer, 0)
+      .postMessage(0, payload, 0)
       .accounts(accounts)
       .instruction(),
     authorityIndex: instructionIndex,
     authorityBump: messagePdaBump,
     authorityType: "custom",
   };
 }
+
 function getPostMessageAccounts(
   wormholeAddress: PublicKey,
   emitter: PublicKey,