Core Protocol: Add method to provide unsigned VAAs from core bridge (#383)

Author: barnjamin

core/definitions/src/protocols/core.ts

@@ -22,6 +22,10 @@ declare global {
 export interface WormholeCore<N extends Network, C extends Chain> {
   /** Get the fee for publishing a message */
   getMessageFee(): Promise<bigint>;
+
+  /** Get the current guardian set index */
+  getGuardianSetIndex(): Promise<number>;
+
   /**
    * Publish a message
    *
@@ -39,6 +43,7 @@ export interface WormholeCore<N extends Network, C extends Chain> {
     nonce: number,
     consistencyLevel: number,
   ): AsyncGenerator<UnsignedTransaction<N, C>>;
+
   /**
    * Verify a VAA against the core contract
    * @param sender the sender of the transaction
@@ -47,6 +52,7 @@ export interface WormholeCore<N extends Network, C extends Chain> {
    * @returns a stream of unsigned transactions to be signed and submitted on chain
    */
   verifyMessage(sender: AccountAddress<C>, vaa: VAA): AsyncGenerator<UnsignedTransaction<N, C>>;
+
   /**
    * Parse a transaction to get its message id
    *
@@ -55,4 +61,13 @@ export interface WormholeCore<N extends Network, C extends Chain> {
    * @returns the message ids produced by the transaction
    */
   parseTransaction(txid: TxHash): Promise<WormholeMessageId[]>;
+
+  /**
+   * Parse a transaction to get the VAA message it produced
+   *
+   * @param txid the transaction hash to parse
+   *
+   * @returns the VAA message produced by the transaction
+   */
+  parseMessages(txid: TxHash): Promise<VAA[]>;
 }

package-lock.json

@@ -6,6 +6,7 @@ import {
   VAA,
   WormholeCore,
   WormholeMessageId,
+  createVAA,
   encoding,
   keccak256,
   serialize,
@@ -162,14 +163,30 @@ export class AlgorandWormholeCore<N extends Network, C extends AlgorandChains>
     return val ? BigInt(val.value.uint) : 0n;
   }
 
+  async getGuardianSetIndex(): Promise<number> {
+    throw new Error("Not implemented");
+  }
+
   async parseTransaction(txId: string): Promise<WormholeMessageId[]> {
+    const result = await this.connection.pendingTransactionInformation(txId).do();
+    const ptr = modelsv2.PendingTransactionResponse.from_obj_for_encoding(result);
+    return this.parseTx(ptr).map((v) => {
+      return {
+        chain: v.emitterChain,
+        emitter: v.emitterAddress,
+        sequence: v.sequence,
+      };
+    });
+  }
+
+  async parseMessages(txId: string): Promise<VAA[]> {
     const result = await this.connection.pendingTransactionInformation(txId).do();
     const ptr = modelsv2.PendingTransactionResponse.from_obj_for_encoding(result);
     return this.parseTx(ptr);
   }
 
-  private parseTx(ptr: modelsv2.PendingTransactionResponse): WormholeMessageId[] {
-    const msgs: WormholeMessageId[] = [];
+  private parseTx(ptr: modelsv2.PendingTransactionResponse): VAA[] {
+    const msgs: VAA[] = [];
 
     if (ptr.innerTxns && ptr.innerTxns.length > 0) {
       msgs.push(...ptr.innerTxns.flatMap((tx) => this.parseTx(tx)));
@@ -191,7 +208,22 @@ export class AlgorandWormholeCore<N extends Network, C extends AlgorandChains>
 
     const sequence = encoding.bignum.decode(ptr.logs[0]!);
     const emitter = new AlgorandAddress(ptr.txn.txn.snd).toUniversalAddress();
-    msgs.push({ chain: this.chain, emitter, sequence });
+    const payload = new Uint8Array(args[1]!);
+    const nonce = encoding.bignum.decode(args[2]!);
+
+    msgs.push(
+      createVAA("Uint8Array", {
+        emitterChain: this.chain,
+        emitterAddress: emitter,
+        sequence,
+        guardianSet: 0, // TODO: should we get this from the contract on init?
+        timestamp: 0, // TODO: Would need to get the full block to get the timestamp
+        consistencyLevel: 0,
+        nonce: Number(nonce),
+        payload,
+        signatures: [],
+      }),
+    );
 
     return msgs;
   }

platforms/algorand/protocols/core/src/core.ts

@@ -8,6 +8,8 @@ import {
   VAA,
   WormholeCore,
   WormholeMessageId,
+  createVAA,
+  encoding,
   toChainId,
 } from "@wormhole-foundation/connect-sdk";
 import {
@@ -36,6 +38,9 @@ export class AptosWormholeCore<N extends Network, C extends AptosChains>
       throw new Error(`CoreBridge contract Address for chain ${chain} not found`);
     this.coreBridge = coreBridgeAddress;
   }
+  getGuardianSetIndex(): Promise<number> {
+    throw new Error("Method not implemented.");
+  }
   getMessageFee(): Promise<bigint> {
     throw new Error("Method not implemented.");
   }
@@ -62,20 +67,51 @@ export class AptosWormholeCore<N extends Network, C extends AptosChains>
   }
 
   async parseTransaction(txid: string): Promise<WormholeMessageId[]> {
+    const msgs = await this.parseMessages(txid);
+
+    return msgs.map((message) => {
+      return {
+        chain: message.emitterChain,
+        emitter: message.emitterAddress,
+        sequence: message.sequence,
+      };
+    });
+  }
+  async parseMessages(txid: string): Promise<VAA[]> {
     const transaction = await this.connection.getTransactionByHash(txid);
     if (transaction.type !== "user_transaction")
       throw new Error(`${txid} is not a user_transaction`);
 
     const userTransaction = transaction as Types.UserTransaction;
-    const message = userTransaction.events.find((event) => event.type.endsWith("WormholeMessage"));
-    if (!message || !message.data) {
+    const messages = userTransaction.events.filter((event) =>
+      event.type.endsWith("WormholeMessage"),
+    );
+    if (!messages || messages.length === 0)
       throw new Error(`WormholeMessage not found for ${txid}`);
-    }
 
-    const { sender, sequence } = message.data as { sender: string; sequence: string };
-    // TODO: make this work for address
-    const emitter = new UniversalAddress(BigInt(sender).toString(16).padStart(64, "0"));
+    return messages.map((message) => {
+      const msg = message.data as {
+        consistency_level: number;
+        nonce: string;
+        payload: string;
+        sender: string;
+        sequence: string;
+        timestamp: string;
+      };
+
+      const emitter = new UniversalAddress(BigInt(msg.sender).toString(16).padStart(64, "0"));
 
-    return [{ chain: this.chain, emitter, sequence: BigInt(sequence) }] as WormholeMessageId[];
+      return createVAA("Uint8Array", {
+        guardianSet: 0, // TODO: need to implement guardian set idx
+        emitterChain: this.chain,
+        emitterAddress: emitter,
+        sequence: BigInt(msg.sequence),
+        timestamp: Number(msg.timestamp),
+        consistencyLevel: msg.consistency_level,
+        nonce: Number(msg.nonce),
+        signatures: [],
+        payload: encoding.hex.decode(msg.payload),
+      });
+    });
   }
 }

platforms/aptos/protocols/core/src/core.ts

@@ -10,6 +10,8 @@ import {
   VAA,
   WormholeCore,
   WormholeMessageId,
+  createVAA,
+  encoding,
 } from "@wormhole-foundation/connect-sdk";
 import {
   AnyCosmwasmAddress,
@@ -36,6 +38,9 @@ export class CosmwasmWormholeCore<N extends Network, C extends CosmwasmChains>
 
     this.coreAddress = coreAddress;
   }
+  getGuardianSetIndex(): Promise<number> {
+    throw new Error("Method not implemented.");
+  }
 
   getMessageFee(): Promise<bigint> {
     throw new Error("Method not implemented.");
@@ -66,13 +71,18 @@ export class CosmwasmWormholeCore<N extends Network, C extends CosmwasmChains>
   }
 
   async parseTransaction(txid: string): Promise<WormholeMessageId[]> {
+    const tx = await this.rpc.getTx(txid);
+    if (!tx) throw new Error("No transaction found for txid: " + txid);
+    return [CosmwasmWormholeCore.parseWormholeMessageId(this.chain, this.coreAddress, tx)];
+  }
+
+  async parseMessages(txid: string): Promise<VAA[]> {
     const tx = await this.rpc.getTx(txid);
     if (!tx) throw new Error("No transaction found for txid: " + txid);
     return [CosmwasmWormholeCore.parseWormholeMessage(this.chain, this.coreAddress, tx)];
   }
 
-  // TODO: make consts
-  static parseWormholeMessage(chain: Chain, coreAddress: string, tx: IndexedTx): WormholeMessageId {
+  static parseWormholeMessage(chain: Chain, coreAddress: string, tx: IndexedTx): VAA {
     const events = tx.events.filter(
       (ev) =>
         ev.type === "wasm" &&
@@ -85,18 +95,36 @@ export class CosmwasmWormholeCore<N extends Network, C extends CosmwasmChains>
 
     const [wasm] = events;
 
-    const sequence = wasm!.attributes.find((e) => {
-      return e.key === "message.sequence";
-    })!.value;
+    const obj = Object.fromEntries(
+      wasm!.attributes.map((attr) => {
+        return [attr.key.split(".")[1]!, attr.value];
+      }),
+    );
+
+    return createVAA("Uint8Array", {
+      emitterChain: chain,
+      emitterAddress: new UniversalAddress(encoding.hex.decode(obj["sender"]!)),
+      sequence: BigInt(obj["sequence"]!),
 
-    const emitter = wasm!.attributes.find((e) => {
-      return e.key === "message.sender";
-    })!.value;
+      guardianSet: 0, // TODO: need to implement guardian set idx
+      timestamp: Number(obj["block_time"]),
+      consistencyLevel: 0,
+      nonce: Number(obj["nonce"]),
+      signatures: [],
+      payload: encoding.hex.decode(obj["message"]!),
+    });
+  }
+  static parseWormholeMessageId(
+    chain: Chain,
+    coreAddress: string,
+    tx: IndexedTx,
+  ): WormholeMessageId {
+    const unsignedVaa = CosmwasmWormholeCore.parseWormholeMessage(chain, coreAddress, tx);
 
     return {
-      chain: chain,
-      emitter: new UniversalAddress(emitter),
-      sequence: BigInt(sequence),
+      chain: unsignedVaa.emitterChain,
+      emitter: unsignedVaa.emitterAddress,
+      sequence: unsignedVaa.sequence,
     };
   }
 }

platforms/cosmwasm/protocols/core/src/core.ts

@@ -172,7 +172,7 @@ export class CosmwasmIbcBridge<N extends Network, C extends CosmwasmChains>
   async lookupMessageFromIbcMsgId(msg: IbcMessageId): Promise<WormholeMessageId | null> {
     const tx = await this.lookupTxFromIbcMsgId(msg);
     if (!tx) return null;
-    return CosmwasmWormholeCore.parseWormholeMessage(
+    return CosmwasmWormholeCore.parseWormholeMessageId(
       Gateway.chain,
       Gateway.coreAddress(this.network),
       tx,

platforms/cosmwasm/protocols/ibc/src/ibc.ts

@@ -6,6 +6,7 @@ import {
   VAA,
   WormholeCore,
   WormholeMessageId,
+  createVAA,
   isWormholeMessageId,
 } from '@wormhole-foundation/connect-sdk';
 import { Provider, TransactionRequest } from 'ethers';
@@ -61,6 +62,10 @@ export class EvmWormholeCore<N extends Network, C extends EvmChains>
     return await this.core.messageFee.staticCall();
   }
 
+  async getGuardianSetIndex(): Promise<number> {
+    return Number(await this.core.getCurrentGuardianSetIndex.staticCall());
+  }
+
   static async fromRpc<N extends Network>(
     provider: Provider,
     config: ChainsConfig<N, EvmPlatformType>,
@@ -129,6 +134,39 @@ export class EvmWormholeCore<N extends Network, C extends EvmChains>
       .filter(isWormholeMessageId);
   }
 
+  async parseMessages(txid: string): Promise<VAA[]> {
+    const receipt = await this.provider.getTransactionReceipt(txid);
+    if (receipt === null) throw new Error('Could not get transaction receipt');
+    const gsIdx = await this.getGuardianSetIndex();
+
+    return receipt.logs
+      .filter((l: any) => {
+        return l.address === this.coreAddress;
+      })
+      .map((log): VAA | undefined => {
+        const { topics, data } = log;
+        const parsed = this.coreIface.parseLog({
+          topics: topics.slice(),
+          data,
+        });
+        if (parsed === null) return undefined;
+
+        const emitterAddress = new EvmAddress(parsed.args['sender']);
+        return createVAA('Uint8Array', {
+          guardianSet: gsIdx, // TODO: should we get this from the contract on init?
+          timestamp: 0, // TODO: Would need to get the full block to get the timestamp
+          emitterChain: this.chain,
+          emitterAddress: emitterAddress.toUniversalAddress(),
+          consistencyLevel: Number(parsed.args['consistencyLevel']),
+          sequence: BigInt(parsed.args['sequence']),
+          nonce: Number(parsed.args['nonce']),
+          signatures: [],
+          payload: parsed.args['payload'],
+        });
+      })
+      .filter((vaa) => !!vaa) as VAA[];
+  }
+
   private createUnsignedTx(
     txReq: TransactionRequest,
     description: string,