start to add token router

Author: barnjamin

solana/Anchor.toml

@@ -31,8 +31,7 @@ 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/01*.ts"
-# 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/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/protocol/index.ts

@@ -1 +1,2 @@
 export * from "./matchingEngine";
+export * from "./tokenRouter";

solana/ts/src/protocol/matchingEngine.ts

@@ -94,14 +94,14 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
             },
             params,
         );
-        const transaction = await this.createTx(new SolanaAddress(owner).unwrap(), [ix]);
+        const transaction = this.createTx(new SolanaAddress(owner).unwrap(), [ix]);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.initialize");
     }
 
     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]);
+        const transaction = this.createTx(payer, [ix]);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.setPause");
     }
 
@@ -123,7 +123,7 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
             { chain: toChainId(chain), cctpDomain, address, mintRecipient },
         );
 
-        const transaction = await this.createTx(ownerOrAssistant, [ix]);
+        const transaction = this.createTx(ownerOrAssistant, [ix]);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.registerRouter");
     }
 
@@ -144,7 +144,7 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
             { chain: toChainId(chain), cctpDomain, address, mintRecipient },
         );
 
-        const transaction = await this.createTx(owner, [ix]);
+        const transaction = this.createTx(owner, [ix]);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.updateRouter");
     }
 
@@ -153,7 +153,7 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
 
         const ix = await this.disableRouterEndpointIx({ owner }, toChainId(chain));
 
-        const transaction = await this.createTx(owner, [ix]);
+        const transaction = this.createTx(owner, [ix]);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.disableRouter");
     }
 
@@ -187,7 +187,7 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
             { offerPrice, totalDeposit },
         );
 
-        const transaction = await this.createTx(payer, ixs);
+        const transaction = this.createTx(payer, ixs);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.placeInitialOffer");
     }
 
@@ -203,7 +203,7 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
 
         const ixs = await this.improveOfferIx({ participant, auction }, { offerPrice: offer });
 
-        const transaction = await this.createTx(participant, ixs);
+        const transaction = this.createTx(participant, ixs);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.improveOffer");
     }
 
@@ -256,7 +256,7 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
             units: 300_000,
         });
 
-        const transaction = await this.createTx(payer, [ix, computeIx]);
+        const transaction = this.createTx(payer, [ix, computeIx]);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.executeFastOrder");
     }
 
@@ -310,7 +310,7 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
 
         const computeIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 });
 
-        const transaction = await this.createTx(payer, [ix, computeIx], lookupTables);
+        const transaction = this.createTx(payer, [ix, computeIx], lookupTables);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.prepareOrderResponse");
     }
 
@@ -377,16 +377,15 @@ export class SolanaMatchingEngine<N extends Network, C extends SolanaChains>
 
         ixs.push(settleIx);
 
-        const transaction = await this.createTx(payer, ixs, lookupTables);
-
+        const transaction = this.createTx(payer, ixs, lookupTables);
         yield this.createUnsignedTx({ transaction }, "MatchingEngine.settleAuctionComplete");
     }
 
-    private async createTx(
+    private createTx(
         payerKey: PublicKey,
         instructions: TransactionInstruction[],
         lookupTables?: AddressLookupTableAccount[],
-    ): Promise<VersionedTransaction> {
+    ): VersionedTransaction {
         const messageV0 = new TransactionMessage({
             payerKey,
             recentBlockhash: "",

solana/ts/src/protocol/tokenRouter.ts

@@ -0,0 +1,149 @@
+import {
+    AddressLookupTableAccount,
+    Connection,
+    PublicKey,
+    TransactionInstruction,
+    TransactionMessage,
+    VersionedTransaction,
+} from "@solana/web3.js";
+import {
+    FastTransfer,
+    TokenRouter,
+} from "@wormhole-foundation/example-liquidity-layer-definitions";
+import { Chain, Network, Platform } from "@wormhole-foundation/sdk-base";
+import {
+    AccountAddress,
+    ChainAddress,
+    ChainsConfig,
+    CircleBridge,
+    Contracts,
+    UnsignedTransaction,
+    VAA,
+} from "@wormhole-foundation/sdk-definitions";
+import {
+    AnySolanaAddress,
+    SolanaAddress,
+    SolanaChains,
+    SolanaPlatform,
+    SolanaTransaction,
+    SolanaUnsignedTransaction,
+} from "@wormhole-foundation/sdk-solana";
+import { SolanaWormholeCore } from "@wormhole-foundation/sdk-solana-core";
+import { ProgramId, TokenRouterProgram } from "../tokenRouter";
+
+export interface SolanaTokenRouterContracts {
+    tokenRouter: string;
+    usdcMint: string;
+}
+
+export class SolanaTokenRouter<N extends Network, C extends SolanaChains>
+    extends TokenRouterProgram
+    implements TokenRouter<N, C>
+{
+    coreBridge: SolanaWormholeCore<N, C>;
+
+    constructor(
+        readonly _network: N,
+        readonly _chain: C,
+        readonly _connection: Connection,
+        readonly _contracts: Contracts & SolanaTokenRouterContracts,
+    ) {
+        super(_connection, _contracts.tokenRouter 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>(
+        connection: Connection,
+        config: ChainsConfig<N, Platform>,
+        contracts: SolanaTokenRouterContracts,
+    ) {
+        const [network, chain] = await SolanaPlatform.chainFromRpc(connection);
+        const conf = config[chain]!;
+        if (conf.network !== network)
+            throw new Error(`Network mismatch for chain ${chain}: ${conf.network} != ${network}`);
+
+        return new SolanaTokenRouter(network as N, chain, connection, {
+            ...config[chain]!.contracts,
+            ...contracts,
+        });
+    }
+
+    async *initialize(
+        owner: AnySolanaAddress,
+        ownerAssistant: AnySolanaAddress,
+        mint?: AnySolanaAddress,
+    ) {
+        const sender = new SolanaAddress(owner).unwrap();
+        const ix = await this.initializeIx({
+            owner: sender,
+            ownerAssistant: new SolanaAddress(ownerAssistant).unwrap(),
+            mint: mint ? new SolanaAddress(mint).unwrap() : undefined,
+        });
+
+        const transaction = this.createTx(sender, [ix]);
+        yield this.createUnsignedTx({ transaction }, "TokenRouter.Initialize");
+    }
+
+    getInitialAuctionFee(): Promise<bigint> {
+        throw new Error("Method not implemented.");
+    }
+
+    placeMarketOrder(
+        amount: bigint,
+        redeemer: ChainAddress<Chain>,
+        redeemerMessage: Uint8Array,
+        minAmountOut?: bigint | undefined,
+        refundAddress?: AccountAddress<C> | undefined,
+    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+        throw new Error("Method not implemented.");
+    }
+    placeFastMarketOrder<RC extends Chain>(
+        amount: bigint,
+        chain: RC,
+        redeemer: AccountAddress<RC>,
+        redeemerMessage: Uint8Array,
+        maxFee: bigint,
+        deadline: number,
+        minAmountOut?: bigint | undefined,
+        refundAddress?: string | undefined,
+    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+        throw new Error("Method not implemented.");
+    }
+    redeemFill(
+        vaa: FastTransfer.VAA,
+        cctp: CircleBridge.Attestation,
+    ): AsyncGenerator<UnsignedTransaction<N, C>, any, unknown> {
+        throw new Error("Method not implemented.");
+    }
+
+    private createTx(
+        payerKey: PublicKey,
+        instructions: TransactionInstruction[],
+        lookupTables?: AddressLookupTableAccount[],
+    ): VersionedTransaction {
+        const messageV0 = new TransactionMessage({
+            payerKey,
+            recentBlockhash: "",
+            instructions,
+        }).compileToV0Message(lookupTables);
+        return new VersionedTransaction(messageV0);
+    }
+
+    private createUnsignedTx(
+        txReq: SolanaTransaction,
+        description: string,
+        parallelizable: boolean = false,
+    ): SolanaUnsignedTransaction<N, C> {
+        return new SolanaUnsignedTransaction(
+            txReq,
+            this._network,
+            this._chain,
+            description,
+            parallelizable,
+        );
+    }
+}

solana/ts/src/testing/utils.ts

@@ -19,6 +19,7 @@ import { SolanaWormholeCore, utils as coreUtils } from "@wormhole-foundation/sdk
 import { expect } from "chai";
 import { Err, Ok } from "ts-results";
 import { CORE_BRIDGE_PID, USDC_MINT_ADDRESS } from "./consts";
+import { execSync } from "child_process";
 
 export function toUniversalAddress(address: number[] | Buffer | Array<number>): UniversalAddress {
     return new UniversalAddress(new Uint8Array(address));
@@ -218,6 +219,17 @@ 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 waitUntilSlot(connection: Connection, targetSlot: number) {
     return new Promise((resolve, _) => {
         const sub = connection.onSlotChange((slot) => {

solana/ts/tests/02__tokenRouter.ts

@@ -30,6 +30,7 @@ import {
     toUniversalAddress,
 } from "../src/testing";
 import { Custodian, PreparedOrder, TokenRouterProgram, localnet } from "../src/tokenRouter";
+import { SolanaTokenRouter } from "../src/protocol";
 
 const SOLANA_CHAIN_ID = toChainId("Solana");
 
@@ -45,7 +46,11 @@ describe("Token Router", function () {
     const invalidChain = (foreignChain + 1) as ChainId;
     const foreignEndpointAddress = REGISTERED_TOKEN_ROUTERS["Ethereum"]!;
     const foreignCctpDomain = 0;
-    const tokenRouter = new TokenRouterProgram(connection, localnet(), USDC_MINT_ADDRESS);
+    //const tokenRouter = new TokenRouterProgram(connection, localnet(), USDC_MINT_ADDRESS);
+    const tokenRouter = new SolanaTokenRouter("Devnet", "Solana", connection, {
+        tokenRouter: localnet(),
+        usdcMint: USDC_MINT_ADDRESS.toBase58(),
+    });
 
     let lookupTableAddress: PublicKey;