replacing more ix with tx

Author: barnjamin

solana/Anchor.toml

@@ -31,7 +31,8 @@ cluster = "Localnet"
 wallet = "ts/tests/keys/pFCBP4bhqdSsrWUVTgqhPsLrfEdChBK17vgFM7TxjxQ.json"
 
 [scripts]
-test-local = "npx ts-mocha -p ./tsconfig.anchor.json -t 1000000 --bail --full-trace --exit ts/tests/0[0-9]*.ts"
+test-local = "npx ts-mocha -p ./tsconfig.anchor.json -t 1000000 --bail --full-trace --exit ts/tests/01*.ts"
+# test-local = "npx ts-mocha -p ./tsconfig.anchor.json -t 1000000 --bail --full-trace --exit ts/tests/0[0-9]*.ts"
 test-upgrade-fork = "npx ts-mocha -p ./tsconfig.anchor.json -t 1000000 --bail --full-trace --exit ts/tests/1[0-9]*.ts"
 
 [test]

solana/ts/src/matchingEngine/index.ts

@@ -56,6 +56,7 @@ import {
 } from "./state";
 import { ChainId, toChainId, isChainId, Chain } from "@wormhole-foundation/sdk-base";
 import { programDerivedAddresses } from "./pdas";
+import { FastTransfer } from "@wormhole-foundation/example-liquidity-layer-definitions";
 
 export const PROGRAM_IDS = [
     "MatchingEngine11111111111111111111111111111",
@@ -682,21 +683,15 @@ export class MatchingEngineProgram {
     }
 
     routerEndpointComposite(addr: PublicKey): { endpoint: PublicKey } {
-        return {
-            endpoint: addr,
-        };
+        return { endpoint: addr };
     }
 
     liquidityLayerVaaComposite(vaa: PublicKey): { vaa: PublicKey } {
-        return {
-            vaa,
-        };
+        return { vaa };
     }
 
     usdcComposite(mint?: PublicKey): { mint: PublicKey } {
-        return {
-            mint: mint ?? this.mint,
-        };
+        return { mint: mint ?? this.mint };
     }
 
     localTokenRouterComposite(tokenRouterProgram: PublicKey): {
@@ -1719,7 +1714,6 @@ export class MatchingEngineProgram {
         }
         const {
             custodian,
-            routerEndpoint: toRouterEndpoint,
             coreMessage,
             cctpMessage,
             coreBridgeConfig,

solana/ts/src/protocol/matchingEngine.ts

@@ -1,4 +1,5 @@
 import {
+    ComputeBudgetProgram,
     Connection,
     PublicKey,
     TransactionInstruction,
@@ -17,8 +18,10 @@ import {
     Contracts,
     UnsignedTransaction,
     VAA,
+    keccak256,
 } from "@wormhole-foundation/sdk-definitions";
 import {
+    AnySolanaAddress,
     SolanaAddress,
     SolanaChains,
     SolanaPlatform,
@@ -67,11 +70,11 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
     }
 
     async *initialize(
-        owner: AccountAddress<C>,
-        ownerAssistant: AccountAddress<C>,
-        feeRecipient: AccountAddress<C>,
+        owner: AnySolanaAddress,
+        ownerAssistant: AnySolanaAddress,
+        feeRecipient: AnySolanaAddress,
         params: AuctionParameters,
-        mint?: AccountAddress<C>,
+        mint?: AnySolanaAddress,
     ) {
         const ix = await this.initializeIx(
             {
@@ -86,22 +89,24 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.initialize");
     }
 
-    async *setPause(sender: AccountAddress<C>, pause: boolean) {
+    async *setPause(sender: AnySolanaAddress, pause: boolean) {
         const payer = new SolanaAddress(sender).unwrap();
         const ix = await this.setPauseIx({ ownerOrAssistant: payer }, pause);
         const transaction = await this.createTx(payer, [ix]);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.setPause");
     }
 
     async *registerRouter<RC extends Chain>(
-        sender: AccountAddress<C>,
+        sender: AnySolanaAddress,
         chain: RC,
         cctpDomain: number,
         router: AccountAddress<RC>,
-        tokenAccount?: AccountAddress<C>,
+        tokenAccount?: AnySolanaAddress,
     ) {
         const ownerOrAssistant = new SolanaAddress(sender).unwrap();
-        const mintRecipient = tokenAccount?.toUniversalAddress().toUint8Array() ?? null;
+        const mintRecipient = tokenAccount
+            ? new SolanaAddress(tokenAccount).toUniversalAddress().toUint8Array()
+            : null;
         const ix = await this.addCctpRouterEndpointIx(
             { ownerOrAssistant },
             {
@@ -116,6 +121,40 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.registerRouter");
     }
 
+    async *updateRouter<RC extends Chain>(
+        sender: AnySolanaAddress,
+        chain: RC,
+        cctpDomain: number,
+        router: AccountAddress<RC>,
+        tokenAccount?: AnySolanaAddress,
+    ) {
+        const owner = new SolanaAddress(sender).unwrap();
+        const mintRecipient = tokenAccount
+            ? new SolanaAddress(tokenAccount).toUniversalAddress().toUint8Array()
+            : null;
+
+        const ix = await this.updateCctpRouterEndpointIx(
+            { owner },
+            {
+                chain: toChainId(chain),
+                cctpDomain: cctpDomain,
+                address: Array.from(router.toUniversalAddress().toUint8Array()),
+                mintRecipient: mintRecipient ? Array.from(mintRecipient) : null,
+            },
+        );
+
+        const transaction = await this.createTx(owner, [ix]);
+        yield this.createUnsignedTx({ transaction }, "MatchingEngine.updateRouter");
+    }
+
+    async *disableRouter<RC extends Chain>(sender: AnySolanaAddress, chain: RC) {
+        const owner = new SolanaAddress(sender).unwrap();
+        const ix = await this.disableRouterEndpointIx({ owner }, toChainId(chain));
+
+        const transaction = await this.createTx(owner, [ix]);
+        yield this.createUnsignedTx({ transaction }, "MatchingEngine.disableRouter");
+    }
+
     async *setConfiguration(config: {
         enabled: boolean;
         maxAmount: bigint;
@@ -126,7 +165,7 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
     }
 
     async *placeInitialOffer(
-        sender: AccountAddress<C>,
+        sender: AnySolanaAddress,
         vaa: FastTransfer.VAA,
         offerPrice: bigint,
         totalDeposit?: bigint,
@@ -144,26 +183,48 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
         );
 
         const transaction = await this.createTx(payer, ixs);
-        yield this.createUnsignedTx(
-            { transaction: transaction },
-            "MatchingEngine.placeInitialOffer",
-        );
+        yield this.createUnsignedTx({ transaction }, "MatchingEngine.placeInitialOffer");
     }
 
-    improveOffer(
-        id: Uint8Array,
-        bid: bigint,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
-        throw new Error("Method not implemented.");
+    async *improveOffer(sender: AnySolanaAddress, vaa: FastTransfer.VAA, offer: bigint) {
+        const participant = new SolanaAddress(sender).unwrap();
+        const auction = this.auctionAddress(keccak256(vaa.hash));
+
+        const ixs = await this.improveOfferIx({ participant, auction }, { offerPrice: offer });
+
+        const transaction = await this.createTx(participant, ixs);
+        yield this.createUnsignedTx({ transaction }, "MatchingEngine.improveOffer");
     }
-    executeFastOrder(
-        vaa: FastTransfer.VAA,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+
+    async *executeFastOrder(sender: AnySolanaAddress, vaa: FastTransfer.VAA) {
+        const payer = new SolanaAddress(sender).unwrap();
+
+        const fastVaa = coreUtils.derivePostedVaaKey(
+            this.coreBridgeProgramId(),
+            Buffer.from(vaa.hash),
+        );
+
+        const ix = await this.executeFastOrderCctpIx({
+            payer,
+            fastVaa,
+        });
+
+        const computeIx = ComputeBudgetProgram.setComputeUnitLimit({
+            units: 300_000,
+        });
+
+        const transaction = await this.createTx(payer, [ix, computeIx]);
+        yield this.createUnsignedTx({ transaction }, "MatchingEngine.improveOffer");
+    }
+
+    async *settleAuctionComplete() {
         throw new Error("Method not implemented.");
     }
-    settleAuctionComplete(): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+
+    settleAuction(): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
         throw new Error("Method not implemented.");
     }
+
     getAuctionGracePeriod(): Promise<number> {
         throw new Error("Method not implemented.");
     }

solana/ts/src/testing/mock.ts

@@ -1,20 +1,14 @@
 import { Connection, Keypair } from "@solana/web3.js";
-import { ethers } from "ethers";
-import { LiquidityLayerMessage } from "../common";
-import { CORE_BRIDGE_PID, GUARDIAN_KEY, MOCK_GUARDIANS } from "./consts";
-import { postVaa, getBlockTime } from "./utils";
+import { Chain, Network } from "@wormhole-foundation/sdk-base";
+import { SignAndSendSigner, toUniversal } from "@wormhole-foundation/sdk-definitions";
 import { mocks } from "@wormhole-foundation/sdk-definitions/testing";
-import { signAndSendWait } from "@wormhole-foundation/sdk-connect";
-import { SolanaWormholeCore, utils as coreUtils } from "@wormhole-foundation/sdk-solana-core";
-import { Chain, Network, contracts } from "@wormhole-foundation/sdk-base";
-import {
-    SignAndSendSigner,
-    buildConfig,
-    serialize,
-    toUniversal,
-} from "@wormhole-foundation/sdk-definitions";
 import { SolanaAddress, SolanaSendSigner } from "@wormhole-foundation/sdk-solana";
+import { utils as coreUtils } from "@wormhole-foundation/sdk-solana-core";
+import { ethers } from "ethers";
+import { LiquidityLayerMessage } from "../common";
 import { VaaAccount } from "../wormhole";
+import { CORE_BRIDGE_PID, GUARDIAN_KEY, MOCK_GUARDIANS } from "./consts";
+import { getBlockTime, postVaa } from "./utils";
 
 export type SDKSigner<N extends Network> = SolanaSendSigner<N, "Solana">;
 
@@ -56,15 +50,14 @@ export async function postLiquidityLayerVaav2(
 
     const vaa = MOCK_GUARDIANS.addSignatures(published, [0]);
 
-    await postVaa(connection, payer, Buffer.from(serialize(vaa)));
-
-    const address = coreUtils.derivePostedVaaKey(CORE_BRIDGE_PID, Buffer.from(vaa.hash));
+    const { address } = await postVaa(connection, payer, vaa);
     const account = await VaaAccount.fetch(connection, address);
 
     return { address, account };
 }
 
-// TODO: return VaaAccount, too
+// TODO: Replace any invocations of this function with postLiquidityLayerVaav2
+// then rename back to postLiquidityLayerVaa
 export async function postLiquidityLayerVaa(
     connection: Connection,
     payer: Keypair,
@@ -92,7 +85,7 @@ export async function postLiquidityLayerVaa(
     );
     const vaa = guardians.addSignatures(published, [0]);
 
-    await postVaa(connection, payer, Buffer.from(serialize(vaa)));
+    await postVaa(connection, payer, vaa);
 
     return coreUtils.derivePostedVaaKey(CORE_BRIDGE_PID, Buffer.from(vaa.hash));
 }

solana/ts/src/testing/utils.ts

@@ -16,9 +16,9 @@ import { execSync } from "child_process";
 import { Err, Ok } from "ts-results";
 import { CORE_BRIDGE_PID, USDC_MINT_ADDRESS } from "./consts";
 import { SolanaSendSigner, SolanaUnsignedTransaction } from "@wormhole-foundation/sdk-solana";
-import { SolanaWormholeCore } from "@wormhole-foundation/sdk-solana-core";
+import { SolanaWormholeCore, utils as coreUtils } from "@wormhole-foundation/sdk-solana-core";
 import { SignAndSendSigner as SdkSigner, signAndSendWait } from "@wormhole-foundation/sdk-connect";
-import { UniversalAddress, deserialize } from "@wormhole-foundation/sdk-definitions";
+import { UniversalAddress, VAA, deserialize } from "@wormhole-foundation/sdk-definitions";
 import { Chain, Network } from "@wormhole-foundation/sdk-base";
 
 export function toUniversalAddress(address: number[] | Buffer | Array<number>): UniversalAddress {
@@ -198,21 +198,25 @@ async function debugSendAndConfirmTransaction(
 export async function postVaa(
     connection: Connection,
     payer: Keypair | SdkSigner<Network, "Solana">,
-    vaaBuf: Buffer,
+    vaa: VAA,
     coreBridgeAddress?: PublicKey,
 ) {
+    coreBridgeAddress ??= CORE_BRIDGE_PID;
+
     const core = new SolanaWormholeCore("Devnet", "Solana", connection, {
-        coreBridge: (coreBridgeAddress ?? CORE_BRIDGE_PID).toString(),
+        coreBridge: coreBridgeAddress.toString(),
     });
 
     const signer =
         payer instanceof Keypair
             ? new SolanaSendSigner(connection, "Solana", payer, false, {})
             : payer;
 
-    const txs = core.postVaa(signer.address(), deserialize("Uint8Array", vaaBuf));
+    const txs = core.postVaa(signer.address(), vaa);
+    const address = coreUtils.derivePostedVaaKey(coreBridgeAddress, Buffer.from(vaa.hash));
+    const txids = await signAndSendWait(txs, signer);
 
-    return await signAndSendWait(txs, signer);
+    return { txids, address };
 }
 
 export function loadProgramBpf(artifactPath: string, keypath: string): PublicKey {

solana/ts/src/wormhole/index.ts

@@ -8,11 +8,13 @@ import {
     toChainId,
 } from "@wormhole-foundation/sdk-base";
 import {
+    PayloadLiteral,
     VAA,
     createVAA,
     deserialize,
     keccak256,
     layoutItems,
+    serialize,
 } from "@wormhole-foundation/sdk-definitions";
 export * from "./spy";
 
@@ -85,10 +87,17 @@ export class VaaAccount {
         }
     }
 
-    vaa(): VAA<"Uint8Array"> {
-        if (this._encodedVaa !== undefined) return this._encodedVaa.vaa;
-        if (this._postedVaaV1 !== undefined) return this._postedVaaV1;
-        throw new Error("impossible: vaa() failed");
+    vaa<P extends PayloadLiteral = "Uint8Array">(payload?: P): VAA<P> {
+        const vaa =
+            this._encodedVaa !== undefined
+                ? this._encodedVaa.vaa
+                : this._postedVaaV1 !== undefined
+                ? this._postedVaaV1
+                : undefined;
+
+        if (!vaa) throw new Error("impossible: vaa() failed");
+
+        return (payload ? deserialize(payload, serialize(vaa)) : vaa) as VAA<P>;
     }
 
     emitterInfo(): EmitterInfo {