tmp before migrating ethers version

Author: barnjamin

evm/ts/src/protocol/tokenRouter.ts

@@ -1,36 +1,58 @@
 import { TokenRouter } from "@wormhole-foundation/example-liquidity-layer-definitions";
-import { Chain, Network } from "@wormhole-foundation/sdk-base";
+import { Network, nativeChainIds, toChainId } from "@wormhole-foundation/sdk-base";
 import {
-    AccountAddress,
-    UnsignedTransaction,
-    VAA,
     CircleBridge,
     Contracts,
+    UnsignedTransaction,
+    VAA,
 } from "@wormhole-foundation/sdk-definitions";
-import { EvmTokenRouter as _EvmTokenRouter } from "../TokenRouter";
+import {
+    AnyEvmAddress,
+    EvmAddress,
+    EvmChains,
+    EvmUnsignedTransaction,
+} from "@wormhole-foundation/sdk-evm";
 import { ethers } from "ethers";
+import { EvmTokenRouter as _EvmTokenRouter } from "../TokenRouter";
 
-export class EvmTokenRouter<N extends Network, C extends Chain>
+export class EvmTokenRouter<N extends Network, C extends EvmChains>
     extends _EvmTokenRouter
     implements TokenRouter<N, C>
 {
+    private _chainId: number;
     constructor(
         readonly network: N,
         readonly chain: C,
         readonly provider: ethers.providers.Provider,
         readonly contracts: Contracts & TokenRouter.Addresses,
     ) {
         super(provider, contracts.tokenRouter, contracts.cctp.tokenMessenger);
+        this._chainId = 0; //nativeChainIds.networkChainToNativeChainId(network, chain);
     }
 
     async *placeMarketOrder(
-        sender: AccountAddress<C>,
-        order: TokenRouter.OrderRequest | TokenRouter.PreparedOrder<C>,
+        sender: AnyEvmAddress,
+        order: TokenRouter.OrderRequest,
     ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
-        throw new Error("Method not implemented.");
+        const msg = order.redeemerMessage ? order.redeemerMessage : new Uint8Array();
+
+        const refundAddress = order.refundAddress
+            ? new EvmAddress(order.refundAddress).unwrap()
+            : undefined;
+
+        const tx = await this.placeMarketOrderTx(
+            order.amountIn,
+            toChainId(order.targetChain),
+            order.redeemer.toUint8Array(),
+            msg,
+            order.minAmountOut,
+            refundAddress,
+        );
+
+        yield this.createUnsignedTx(tx, "TokenRouter.placeMarketOrder");
     }
     async *redeemFill(
-        sender: AccountAddress<C>,
+        sender: AnyEvmAddress,
         vaa:
             | VAA<"FastTransfer:CctpDeposit">
             | VAA<"FastTransfer:FastMarketOrder">
@@ -39,4 +61,21 @@ export class EvmTokenRouter<N extends Network, C extends Chain>
     ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
         throw new Error("Method not implemented.");
     }
+
+    private createUnsignedTx(
+        txReq: ethers.ContractTransaction,
+        description: string,
+        parallelizable: boolean = false,
+    ): EvmUnsignedTransaction<N, C> {
+        txReq.chainId = this._chainId;
+
+        return new EvmUnsignedTransaction(
+            // txReq,
+            {},
+            this.network,
+            this.chain,
+            description,
+            parallelizable,
+        );
+    }
 }

universal/ts/src/protocol.ts

@@ -150,7 +150,7 @@ export namespace TokenRouter {
     export type PreparedOrder<C extends Chain> = AccountAddress<C>;
 }
 
-export interface TokenRouter<N extends Network = Network, C extends Chain = Chain> {
+export interface TokenRouter<N extends Network, C extends Chain> {
     placeMarketOrder(
         sender: AccountAddress<C>,
         order: TokenRouter.OrderRequest | TokenRouter.PreparedOrder<C>,