start replacing matching engine calls

barnjamin · barnjamin · commit 990afeb6ac8e · 2024-07-01T13:11:46.000-04:00
diff --git a/evm/ts/src/protocol/matchingEngine.ts b/evm/ts/src/protocol/matchingEngine.ts
@@ -32,96 +32,79 @@ export class EvmMatchingEngine<N extends Network, C extends EvmChains>
     ) {
         super(provider, contracts.matchingEngine, contracts.cctp.tokenMessenger);
     }
-    registerRouter<RC extends Chain>(
-        sender: AccountAddress<C>,
+    async *registerRouter<RC extends Chain>(
+        sender: AnyEvmAddress,
         chain: RC,
         cctpDomain: number,
         router: AccountAddress<RC>,
         tokenAccount?: AccountAddress<C> | undefined,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+    ) {
         throw new Error("Method not implemented.");
     }
-    updateRouter<RC extends Chain>(
-        sender: AccountAddress<C>,
+    async *updateRouter<RC extends Chain>(
+        sender: AnyEvmAddress,
         chain: RC,
         cctpDomain: number,
         router: AccountAddress<RC>,
         tokenAccount?: AccountAddress<C> | undefined,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+    ) {
         throw new Error("Method not implemented.");
     }
-    disableRouter<RC extends Chain>(
-        sender: AccountAddress<C>,
-        chain: RC,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+    async *disableRouter<RC extends Chain>(sender: AnyEvmAddress, chain: RC) {
         throw new Error("Method not implemented.");
     }
-    setPause(
-        sender: AccountAddress<C>,
-        pause: boolean,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+    async *setPause(sender: AnyEvmAddress, pause: boolean) {
         throw new Error("Method not implemented.");
     }
-    setConfiguration(config: {
+    async *setConfiguration(config: {
         enabled: boolean;
         maxAmount: bigint;
         baseFee: bigint;
         initAuctionFee: bigint;
-    }): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+    }) {
         throw new Error("Method not implemented.");
     }
-    placeInitialOffer(
-        sender: AccountAddress<C>,
+    async *placeInitialOffer(
+        sender: AnyEvmAddress,
         vaa: VAA<"FastTransfer:FastMarketOrder">,
         offerPrice: bigint,
         totalDeposit?: bigint | undefined,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
-        throw new Error("Method not implemented.");
+    ) {
+        const from = new EvmAddress(sender).unwrap();
+        const txReq = await this.connect(this.provider).placeInitialBidTx(
+            serialize(vaa),
+            offerPrice,
+        );
+
+        yield this.createUnsignedTx({ ...txReq, from }, "MatchingEngine.placeInitialOffer");
     }
-    improveOffer(
-        sender: AccountAddress<C>,
+    async *improveOffer(
+        sender: AnyEvmAddress,
         vaa: VAA<"FastTransfer:FastMarketOrder">,
         offer: bigint,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+    ) {
         throw new Error("Method not implemented.");
     }
-    executeFastOrder(
-        sender: AccountAddress<C>,
-        vaa: VAA<"FastTransfer:FastMarketOrder">,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+    async *executeFastOrder(sender: AnyEvmAddress, vaa: VAA<"FastTransfer:FastMarketOrder">) {
         throw new Error("Method not implemented.");
     }
-    prepareOrderResponse(
+    async *prepareOrderResponse(
         sender: AccountAddress<C>,
         vaa: VAA<"FastTransfer:FastMarketOrder">,
         deposit: VAA<"FastTransfer:CctpDeposit">,
         cctp: CircleBridge.Attestation,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+    ) {
         throw new Error("Method not implemented.");
     }
-    settleOrder(
+    async *settleOrder(
         sender: AccountAddress<C>,
         fast: VAA<"FastTransfer:FastMarketOrder">,
         deposit?: VAA<"FastTransfer:CctpDeposit"> | undefined,
         cctp?: CircleBridge.Attestation | undefined,
-    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+    ) {
         throw new Error("Method not implemented.");
     }
 
-    //async *redeemFill(
-    //    sender: AnyEvmAddress,
-    //    vaa: VAA<"FastTransfer:CctpDeposit"> | VAA<"FastTransfer:FastFill">,
-    //    cctp?: CircleBridge.Attestation,
-    //) {
-    //    const from = new EvmAddress(sender).unwrap();
-    //    const txReq = await this.redeemFillTx({
-    //        encodedWormholeMessage: serialize(vaa),
-    //        circleBridgeMessage: cctp ? CircleBridge.serialize(cctp.message) : new Uint8Array(),
-    //        circleAttestation: cctp ? encoding.hex.decode(cctp.attestation!) : new Uint8Array(),
-    //    });
-    //    yield this.createUnsignedTx({ ...txReq, from }, "TokenRouter.redeemFill");
-    //}
-
     private createUnsignedTx(
         txReq: ethers.TransactionRequest,
         description: string,
diff --git a/evm/ts/src/testing/utils.ts b/evm/ts/src/testing/utils.ts
@@ -1,17 +1,16 @@
-import { ethers, isError } from "ethers";
-import { IERC20 } from "../types";
-import { IUSDC__factory } from "../types/factories/IUSDC__factory";
-import { WALLET_PRIVATE_KEYS } from "./consts";
-import { EvmMatchingEngine } from "..";
-import { signAndSendWait } from "@wormhole-foundation/sdk-connect";
 import { Chain, Network } from "@wormhole-foundation/sdk-base";
+import { signAndSendWait } from "@wormhole-foundation/sdk-connect";
 import {
     SignAndSendSigner,
     UnsignedTransaction,
-    toNative,
     toUniversal,
 } from "@wormhole-foundation/sdk-definitions";
 import { EvmChains, EvmNativeSigner } from "@wormhole-foundation/sdk-evm";
+import { ethers, isError } from "ethers";
+import { MatchingEngine } from "..";
+import { IERC20 } from "../types";
+import { IUSDC__factory } from "../types/factories/IUSDC__factory";
+import { WALLET_PRIVATE_KEYS } from "./consts";
 
 export interface ScoreKeeper {
     player: ethers.NonceManager;
@@ -38,19 +37,21 @@ export class SdkSigner<N extends Network, C extends EvmChains>
         return this._signer as unknown as ethers.Wallet;
     }
 
-    async signAndSend(txs: UnsignedTransaction<N, C>[]): Promise<string[]> {
+    // Does not wait for confirmations
+    async signOnly(txs: UnsignedTransaction<N, C>[]): Promise<string[]> {
         const txids: string[] = [];
         for (let tx of txs) {
-            for (let x = 0; x < 3; x++) {
+            for (let retries = 0; retries < 3; retries++) {
                 try {
                     const res = await this._signer.sendTransaction(tx.transaction);
                     txids.push(res.hash);
                     break;
                 } catch (e) {
                     if (
-                        isError(e, "CALL_EXCEPTION") &&
-                        "info" in e &&
-                        e.info!.error.message === "nonce too low"
+                        (isError(e, "CALL_EXCEPTION") &&
+                            "info" in e &&
+                            e.info!.error.message === "nonce too low") ||
+                        isError(e, "NONCE_EXPIRED")
                     ) {
                         const nonce = await this.wallet.getNonce();
                         console.log("Setting nonce to ", nonce);
@@ -61,18 +62,34 @@ export class SdkSigner<N extends Network, C extends EvmChains>
                 }
             }
         }
-
-        await mine(this.provider);
-        await this.provider.waitForTransaction(txids[0], 1, 5000);
         return txids;
     }
+
+    // Mine and wait for transaction
+    async signAndSend(txs: UnsignedTransaction<N, C>[]): Promise<string[]> {
+        try {
+            const txids = await this.signOnly(txs);
+            await mine(this.provider);
+            await this.provider.waitForTransaction(txids[0], 1, 5000);
+            return txids;
+        } catch (e) {
+            console.error(e);
+            throw e;
+        }
+    }
 }
 
 export const sleep = async (seconds: number) =>
     await new Promise((resolve) => setTimeout(resolve, seconds * 1000));
 
-export const nonceManagedWallet = (key: string, provider: ethers.Provider) =>
-    new ethers.NonceManager(new ethers.Wallet(key, provider));
+export function getSigners(key: string, provider: ethers.Provider) {
+    const wallet = new ethers.Wallet(key, provider);
+
+    return {
+        wallet: new ethers.NonceManager(wallet),
+        signer: getSdkSigner("Ethereum", wallet),
+    };
+}
 
 export async function mine(provider: ethers.JsonRpcProvider) {
     await provider.send("evm_mine", []);
@@ -90,7 +107,7 @@ export function tryNativeToUint8Array(address: string, chain: Chain) {
 
 export async function mineToGracePeriod(
     auctionId: Uint8Array,
-    engine: EvmMatchingEngine,
+    engine: MatchingEngine,
     provider: ethers.JsonRpcProvider,
 ) {
     const { startBlock } = await engine.liveAuctionInfo(auctionId);
@@ -104,7 +121,7 @@ export async function mineToGracePeriod(
 
 export async function mineToPenaltyPeriod(
     auctionId: Uint8Array,
-    engine: EvmMatchingEngine,
+    engine: MatchingEngine,
     provider: ethers.JsonRpcProvider,
     penaltyBlocks: number,
 ) {
@@ -116,6 +133,15 @@ export async function mineToPenaltyPeriod(
     await mineMany(provider, Number(blocksToMine));
 }
 
+export async function signOnly<N extends Network, C extends EvmChains>(
+    txs: AsyncGenerator<UnsignedTransaction<N, C>, void, unknown>,
+    signer: SdkSigner<N, C>,
+) {
+    const txns = [];
+    for await (const tx of txs) txns.push(tx);
+    await signer.signOnly(txns);
+}
+
 export async function signSendMineWait<N extends Network, C extends EvmChains>(
     txs: AsyncGenerator<UnsignedTransaction<N, C>, void, unknown>,
     signer: SdkSigner<N, C>,
diff --git a/evm/ts/tests/03__marketOrder.ts b/evm/ts/tests/03__marketOrder.ts
@@ -1,6 +1,5 @@
 import { TokenRouter } from "@wormhole-foundation/example-liquidity-layer-definitions";
-import { encoding } from "@wormhole-foundation/sdk-base";
-import { CircleBridge, deserialize, toNative } from "@wormhole-foundation/sdk-definitions";
+import { toNative } from "@wormhole-foundation/sdk-definitions";
 import { expect } from "chai";
 import { ethers } from "ethers";
 import { EvmTokenRouter, OrderResponse, decodedOrderResponse } from "../src";
diff --git a/evm/ts/tests/04__fastMarketOrder.ts b/evm/ts/tests/04__fastMarketOrder.ts
