Refactor how vaas are posted

Author: barnjamin

solana/ts/src/common/index.ts

@@ -1,20 +1,13 @@
 import { PublicKey, TransactionInstruction } from "@solana/web3.js";
 import { MessageTransmitterProgram } from "../cctp";
 import { BN } from "@coral-xyz/anchor";
+import { VAA, keccak256 } from "@wormhole-foundation/sdk-definitions";
 
 export * from "./messages";
 export * from "./state";
 
 export type Uint64 = bigint | BN | number;
 
-export function isUint64(value: Uint64): boolean {
-    return (
-        typeof value === "bigint" ||
-        (typeof value === "object" && value instanceof BN) ||
-        typeof value === "number"
-    );
-}
-
 export function uint64ToBigInt(value: Uint64): bigint {
     if (typeof value === "bigint") {
         return value;
@@ -38,32 +31,7 @@ export function uint64ToBN(value: Uint64): BN {
 }
 
 export type VaaHash = Array<number> | Buffer | Uint8Array;
-
-export function vaaHashToUint8Array(vaaHash: VaaHash): Uint8Array {
-    if (Array.isArray(vaaHash)) {
-        return Uint8Array.from(vaaHash);
-    } else if (Buffer.isBuffer(vaaHash)) {
-        return Uint8Array.from(vaaHash);
-    } else {
-        return vaaHash;
-    }
-}
-
-export function vaaHashToBuffer(vaaHash: VaaHash): Buffer {
-    if (Buffer.isBuffer(vaaHash)) {
-        return vaaHash;
-    } else {
-        return Buffer.from(vaaHashToUint8Array(vaaHash));
-    }
-}
-
-export function vaaHashToArray(vaaHash: VaaHash): Array<number> {
-    if (Array.isArray(vaaHash)) {
-        return vaaHash;
-    } else {
-        return Array.from(vaaHashToUint8Array(vaaHash));
-    }
-}
+export const vaaHash = (vaa: VAA<any>): VaaHash => keccak256(vaa.hash);
 
 export async function reclaimCctpMessageIx(
     messageTransmitter: MessageTransmitterProgram,

solana/ts/src/matchingEngine/index.ts

@@ -53,6 +53,7 @@ import {
     ReservedFastFillSequence,
     RouterEndpoint,
 } from "./state";
+import { VAA, keccak256 } from "@wormhole-foundation/sdk-definitions";
 
 export const PROGRAM_IDS = [
     "MatchingEngine11111111111111111111111111111",
@@ -225,7 +226,11 @@ export class MatchingEngineProgram {
     constructor(connection: Connection, programId: ProgramId, mint: PublicKey) {
         this._programId = programId;
         this._mint = mint;
-        this.pdas = programDerivedAddresses(new PublicKey(programId), mint);
+        this.pdas = programDerivedAddresses(
+            new PublicKey(programId),
+            mint,
+            this.coreBridgeProgramId(),
+        );
         this.program = new Program(
             { ...(IDL as any), address: this._programId },
             {
@@ -388,13 +393,11 @@ export class MatchingEngineProgram {
 
     async fetchAuction(input: VaaHash | { address: PublicKey }): Promise<Auction> {
         const addr = "address" in input ? input.address : this.auctionAddress(input);
-        // @ts-ignore This is BS. This is correct.
         return this.program.account.auction.fetch(addr);
     }
 
     async fetchProposal(input?: { address: PublicKey }): Promise<Proposal> {
         const addr = input === undefined ? await this.proposalAddress() : input.address;
-        // @ts-ignore This is BS. This is correct.
         return this.program.account.proposal.fetch(addr);
     }
 
@@ -2495,7 +2498,7 @@ export class MatchingEngineProgram {
     fastFillSequencerAddress = (sourceChain: ChainId, sender: Array<number>): PublicKey =>
         this.pdas.fastFillSequencer(sourceChain, sender);
     reservedFastFillSequenceAddress = (fastVaaHash: VaaHash): PublicKey =>
-        this.pdas.reservedFastFillSequenceAddress(fastVaaHash);
+        this.pdas.reservedFastFillSequence(fastVaaHash);
     transferAuthorityAddress = (auction: PublicKey, offerPrice: Uint64): PublicKey =>
         this.pdas.transferAuthority(auction, offerPrice);
     auctionHistoryAddress = (id: Uint64): PublicKey => this.pdas.auctionHistory(id);

solana/ts/src/matchingEngine/pdas.ts

@@ -1,6 +1,7 @@
 import * as splToken from "@solana/spl-token";
 import { PublicKey } from "@solana/web3.js";
 import { ChainId } from "@wormhole-foundation/sdk-base";
+import { utils as coreUtils } from "@wormhole-foundation/sdk-solana-core";
 import { Uint64, VaaHash, cctpMessageAddress, coreMessageAddress, writeUint64BE } from "../common";
 import {
     Auction,
@@ -14,9 +15,9 @@ import {
     ReservedFastFillSequence,
     RouterEndpoint,
 } from "./state";
-import { VAA } from "@wormhole-foundation/sdk-definitions";
+import { VAA, keccak256 } from "@wormhole-foundation/sdk-definitions";
 
-export function programDerivedAddresses(ID: PublicKey, mint: PublicKey) {
+export function programDerivedAddresses(ID: PublicKey, mint: PublicKey, coreId: PublicKey) {
     return {
         auctionConfig: (id: number) => AuctionConfig.address(ID, id),
         auction: (vaaHash: VaaHash) => Auction.address(ID, vaaHash),
@@ -54,7 +55,7 @@ export function programDerivedAddresses(ID: PublicKey, mint: PublicKey) {
             FastFill.address(ID, sourceChain, orderSender, sequence),
         fastFillSequencer: (sourceChain: ChainId, sender: Array<number>) =>
             FastFillSequencer.address(ID, sourceChain, sender),
-        reservedFastFillSequenceAddress: (fastVaaHash: VaaHash) =>
+        reservedFastFillSequence: (fastVaaHash: VaaHash) =>
             ReservedFastFillSequence.address(ID, fastVaaHash),
         transferAuthority: (auction: PublicKey, offerPrice: Uint64) => {
             const encodedOfferPrice = Buffer.alloc(8);
@@ -65,5 +66,8 @@ export function programDerivedAddresses(ID: PublicKey, mint: PublicKey) {
             )[0];
         },
         auctionHistory: (id: Uint64) => AuctionHistory.address(ID, id),
+
+        //
+        postedVaa: (vaa: VAA<any>) => coreUtils.derivePostedVaaKey(coreId, Buffer.from(vaa.hash)),
     };
 }

solana/ts/src/protocol/matchingEngine.ts

@@ -18,7 +18,6 @@ import {
     CircleAttestation,
     CircleBridge,
     Contracts,
-    UnsignedTransaction,
     VAA,
     keccak256,
 } from "@wormhole-foundation/sdk-definitions";
@@ -30,8 +29,9 @@ import {
     SolanaTransaction,
     SolanaUnsignedTransaction,
 } from "@wormhole-foundation/sdk-solana";
-import { utils as coreUtils } from "@wormhole-foundation/sdk-solana-core";
+import { vaaHash } from "../common";
 import { AuctionParameters, MatchingEngineProgram, ProgramId } from "../matchingEngine";
+import { SolanaWormholeCore } from "@wormhole-foundation/sdk-solana-core";
 
 export interface SolanaMatchingEngineContracts {
     matchingEngine: string;
@@ -42,6 +42,8 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
     extends MatchingEngineProgram
     implements MatchingEngine<N, C>
 {
+    coreBridge: SolanaWormholeCore<N, C>;
+
     constructor(
         readonly _network: N,
         readonly _chain: C,
@@ -54,6 +56,11 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
             _contracts.matchingEngine as ProgramId,
             new PublicKey(_contracts.usdcMint),
         );
+
+        this.coreBridge = new SolanaWormholeCore(_network, _chain, _connection, {
+            coreBridge: this.coreBridgeProgramId().toBase58(),
+            ...this._contracts,
+        });
     }
 
     static async fromRpc<N extends Network>(
@@ -160,6 +167,10 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
         throw new Error("Method not implemented.");
     }
 
+    async *postVaa(sender: AnySolanaAddress, vaa: FastTransfer.VAA) {
+        yield* this.coreBridge.postVaa(sender, vaa);
+    }
+
     async *placeInitialOffer(
         sender: AnySolanaAddress,
         vaa: VAA<"FastTransfer:FastMarketOrder">,
@@ -168,10 +179,7 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
     ) {
         const payer = new SolanaAddress(sender).unwrap();
 
-        const vaaAddress = coreUtils.derivePostedVaaKey(
-            this.coreBridgeProgramId(),
-            Buffer.from(vaa.hash),
-        );
+        const vaaAddress = this.pdas.postedVaa(vaa);
 
         const ixs = await this.placeInitialOfferCctpIx(
             { payer, fastVaa: vaaAddress },
@@ -196,6 +204,10 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.improveOffer");
     }
 
+    async *reserveFastFillSequence() {
+        throw new Error("Method not implemented.");
+    }
+
     async *executeFastOrder(
         sender: AnySolanaAddress,
         vaa: VAA<"FastTransfer:FastMarketOrder">,
@@ -207,16 +219,15 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
             ? new SolanaAddress(participant).unwrap()
             : undefined;
 
-        const fastVaa = coreUtils.derivePostedVaaKey(
-            this.coreBridgeProgramId(),
-            Buffer.from(vaa.hash),
-        );
+        const fastVaa = this.pdas.postedVaa(vaa);
 
-        const digest = keccak256(vaa.hash);
-        const auction = this.auctionAddress(digest);
+        const digest = vaaHash(vaa);
+        const auction = this.pdas.auction(digest);
+
+        const reservedSequence = this.pdas.reservedFastFillSequence(digest);
 
         // TODO: make sure this has already been done, or do it here
-        const reservedSequence = this.reservedFastFillSequenceAddress(digest);
+        // yield* this.reserveFastFillSequence();
 
         const { targetChain } = vaa.payload;
 
@@ -258,15 +269,8 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
     ) {
         const payer = new SolanaAddress(sender).unwrap();
 
-        const fastVaa = coreUtils.derivePostedVaaKey(
-            this.coreBridgeProgramId(),
-            Buffer.from(fast.hash),
-        );
-
-        const finalizedVaa = coreUtils.derivePostedVaaKey(
-            this.coreBridgeProgramId(),
-            Buffer.from(finalized.hash),
-        );
+        const fastVaa = this.pdas.postedVaa(fast);
+        const finalizedVaa = this.pdas.postedVaa(finalized);
 
         const preparedAddress = this.preparedOrderResponseAddress(keccak256(fast.hash));
 
@@ -340,10 +344,7 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
         const digest = keccak256(fast.hash);
         const preparedOrderResponse = this.preparedOrderResponseAddress(digest);
         const auction = this.auctionAddress(digest);
-        const fastVaa = coreUtils.derivePostedVaaKey(
-            this.coreBridgeProgramId(),
-            Buffer.from(fast.hash),
-        );
+        const fastVaa = this.pdas.postedVaa(fast);
 
         const settleIx = await (async () => {
             if (finalized && !cctp) {

solana/ts/src/testing/mock.ts

@@ -1,6 +1,7 @@
 import { Connection, Keypair } from "@solana/web3.js";
 import { Chain, Network } from "@wormhole-foundation/sdk-base";
-import { SignAndSendSigner, toUniversal } from "@wormhole-foundation/sdk-definitions";
+import { toUniversal } from "@wormhole-foundation/sdk-definitions";
+import { signAndSendWait } from "@wormhole-foundation/sdk-connect";
 import { mocks } from "@wormhole-foundation/sdk-definitions/testing";
 import { SolanaAddress, SolanaSendSigner } from "@wormhole-foundation/sdk-solana";
 import { utils as coreUtils } from "@wormhole-foundation/sdk-solana-core";
@@ -9,12 +10,18 @@ import { LiquidityLayerMessage } from "../common";
 import { VaaAccount } from "../wormhole";
 import { CORE_BRIDGE_PID, GUARDIAN_KEY, MOCK_GUARDIANS } from "./consts";
 import { getBlockTime, postVaa } from "./utils";
+import { FastTransfer } from "@wormhole-foundation/example-liquidity-layer-definitions";
+import { SolanaMatchingEngine } from "../protocol";
 
 export class SDKSigner<N extends Network> extends SolanaSendSigner<N, "Solana"> {
     unwrap(): Keypair {
         // @ts-ignore
         return this._keypair;
     }
+    connection(): Connection {
+        // @ts-ignore
+        return this._rpc;
+    }
 }
 
 export function getSdkSigner<N extends Network>(
@@ -31,21 +38,20 @@ export function unwrapSigners(signers: SDKSigner<Network>[]): Keypair[] {
     return signers.map((signer) => signer.unwrap());
 }
 
-export async function postLiquidityLayerVaav2(
+export async function createLiquidityLayerVaa(
     connection: Connection,
-    payer: Keypair | SignAndSendSigner<Network, "Solana">,
     foreignEmitterAddress: Array<number>,
     sequence: bigint,
     message: LiquidityLayerMessage | Buffer,
     args: { sourceChain?: Chain; timestamp?: number } = {},
-) {
+): Promise<FastTransfer.VAA> {
     let { sourceChain, timestamp } = args;
     sourceChain ??= "Ethereum";
     timestamp ??= await getBlockTime(connection);
 
     const foreignEmitter = new mocks.MockEmitter(
         toUniversal(sourceChain, new Uint8Array(foreignEmitterAddress)),
-        sourceChain ?? "Ethereum",
+        sourceChain,
         sequence - 1n,
     );
 
@@ -58,8 +64,20 @@ export async function postLiquidityLayerVaav2(
 
     const vaa = MOCK_GUARDIANS.addSignatures(published, [0]);
 
-    const { address } = await postVaa(connection, payer, vaa);
-    const account = await VaaAccount.fetch(connection, address);
+    // @ts-ignore -- lie
+    return vaa;
+}
+
+export async function postLiquidityLayerVaav2<N extends Network>(
+    signer: SDKSigner<N>,
+    engine: SolanaMatchingEngine<N, "Solana">,
+    vaa: FastTransfer.VAA,
+) {
+    const txs = engine.postVaa(signer.address(), vaa);
+    await signAndSendWait(txs, signer);
+
+    const address = engine.pdas.postedVaa(vaa);
+    const account = await VaaAccount.fetch(signer.connection(), address);
 
     return { address, account };
 }

solana/ts/src/testing/utils.ts

@@ -17,7 +17,6 @@ import { UniversalAddress, VAA } from "@wormhole-foundation/sdk-definitions";
 import { SolanaSendSigner, SolanaUnsignedTransaction } from "@wormhole-foundation/sdk-solana";
 import { SolanaWormholeCore, utils as coreUtils } from "@wormhole-foundation/sdk-solana-core";
 import { expect } from "chai";
-import { execSync } from "child_process";
 import { Err, Ok } from "ts-results";
 import { CORE_BRIDGE_PID, USDC_MINT_ADDRESS } from "./consts";
 
@@ -219,22 +218,6 @@ export async function postVaa(
     return { txids, address };
 }
 
-export function loadProgramBpf(artifactPath: string, keypath: string): PublicKey {
-    // Invoke BPF Loader Upgradeable `write-buffer` instruction.
-    const buffer = (() => {
-        const output = execSync(`solana -u l -k ${keypath} program write-buffer ${artifactPath}`);
-        return new PublicKey(output.toString().match(/^Buffer: ([A-Za-z0-9]+)/)![1]);
-    })();
-
-    // Return the pubkey for the buffer (our new program implementation).
-    return buffer;
-}
-
-export async function waitBySlots(connection: Connection, numSlots: number) {
-    const targetSlot = await connection.getSlot().then((slot) => slot + numSlots);
-    return waitUntilSlot(connection, targetSlot);
-}
-
 export async function waitUntilSlot(connection: Connection, targetSlot: number) {
     return new Promise((resolve, _) => {
         const sub = connection.onSlotChange((slot) => {

solana/ts/src/wormhole/index.ts

@@ -102,11 +102,7 @@ export class VaaAccount {
 
     emitterInfo(): EmitterInfo {
         const { emitterChain: chain, emitterAddress: address, sequence } = this.vaa();
-        return {
-            chain: toChainId(chain),
-            address: Array.from(address.toUint8Array()),
-            sequence,
-        };
+        return { chain: toChainId(chain), address: Array.from(address.toUint8Array()), sequence };
     }
 
     timestamp(): number {