deploy: adds solana matching engine initialize script

Author: scnale

deployment/helpers/solana.ts

@@ -1,4 +1,17 @@
-import { PublicKey } from '@solana/web3.js';
+import {
+  Transaction,
+  TransactionInstruction,
+  Keypair,
+  PublicKey,
+  Connection,
+  Commitment
+} from "@solana/web3.js";
+import { SolanaLedgerSigner } from "@xlabs-xyz/ledger-signer-solana";
+import { ecosystemChains, getEnv } from "./env";
+import type { SolanaScriptCb } from "./interfaces";
+import { inspect } from "util";
+
+export const connectionCommitmentLevel = (process.env.SOLANA_COMMITMENT || "confirmed") as Commitment;
 
 export function validateSolAddress(address: string){
     try {
@@ -7,4 +20,71 @@ export function validateSolAddress(address: string){
     } catch (error) {
       return false;
     }
+}
+
+export function solanaOperatingChains() {
+  const { operatingChains } = ecosystemChains;
+  if (Array.isArray(operatingChains) && operatingChains.length >= 1) {
+    return ecosystemChains.solana.networks.filter((x) => {
+      return operatingChains.includes(x.chainId);
+    });
+  }
+  return ecosystemChains.solana.networks;
+};
+
+export async function runOnSolana(scriptName: string, cb: SolanaScriptCb) {
+  const chains = solanaOperatingChains();
+
+  console.log(`Running script on Solana:`, scriptName);
+
+  const result = chains.map(async chain => {
+    const log = (...args: any[]) => console.log(`[${chain.chainId}]`, ...args);
+    const signer = await getSigner();
+    log(`Starting script. Signer: ${await signer.getAddress()}`);
+
+    try {
+      await cb(chain, signer, log);
+      log("Success");
+    } catch (error) {
+      log("Error: ", (error as any)?.stack || inspect(error, {depth: 5}));
+    }
+    console.log();
+  });
+
+  await Promise.all(result);
+}
+
+let signer: SolanaLedgerSigner | null;
+export async function getSigner(): Promise<SolanaLedgerSigner> {
+  if (!signer) {
+    const derivationPath = getEnv("LEDGER_BIP32_PATH");
+    signer = await SolanaLedgerSigner.create(derivationPath);
+  }
+
+  return signer;
+}
+
+export async function ledgerSignAndSend(connection: Connection, instructions: TransactionInstruction[], signers: Keypair[]) {
+  const deployerSigner = await getSigner();
+  const deployerPk = new PublicKey(await deployerSigner.getAddress());
+
+  const tx = new Transaction();
+
+  tx.add(...instructions);
+
+  const recentBlockHash = await connection.getLatestBlockhash();
+
+  tx.recentBlockhash = recentBlockHash.blockhash;
+  tx.feePayer = deployerPk;
+
+  signers.forEach((signer) => tx.partialSign(signer));
+
+  await addLedgerSignature(tx, deployerSigner, deployerPk);
+
+  return connection.sendRawTransaction(tx.serialize());
+}
+
+async function addLedgerSignature(tx: Transaction, signer: SolanaLedgerSigner, signerPk: PublicKey) {
+  const signedByPayer = await signer.signTransaction(tx.compileMessage().serialize());
+  tx.addSignature(signerPk, signedByPayer);
 }

deployment/scripts/evm/TokenRouter/utils.ts

@@ -22,7 +22,7 @@ export async function deployImplementation(chain: ChainInfo, signer: ethers.Sign
 
   const matchingEngineMintRecipient = (new UniversalAddress(getMintRecipientAddress(), 'base58')).toString();
   const matchinEngineChain = 1; // Solana wormhole chain id
-  const matchingEngineDomain = 5; // Solana cctp domain  
+  const matchingEngineDomain = 5; // Solana cctp domain
   let matchingEngineAddress = (getContractAddress(
     "MatchingEngineProxy", 
     matchinEngineChain

deployment/scripts/solana/initializeMatchingEngine.ts

@@ -0,0 +1,74 @@
+import {
+    ComputeBudgetProgram,
+    Connection,
+    PublicKey,
+} from "@solana/web3.js";
+import "dotenv/config";
+import { uint64ToBN } from "@wormhole-foundation/example-liquidity-layer-solana/common";
+import { AuctionParameters, MatchingEngineProgram } from "@wormhole-foundation/example-liquidity-layer-solana/matchingEngine";
+import { LoggerFn, connectionCommitmentLevel, getChainConfig, getContractAddress, ledgerSignAndSend, runOnSolana } from "../../helpers";
+import { MatchingEngineConfiguration } from "../../config/config-types";
+import { ProgramId } from "@wormhole-foundation/example-liquidity-layer-solana/matchingEngine";
+import { SolanaLedgerSigner } from "@xlabs-xyz/ledger-signer-solana";
+import { circle } from "@wormhole-foundation/sdk-base";
+
+
+const AUCTION_PARAMS: AuctionParameters = {
+    userPenaltyRewardBps: 400000, // 40%
+    initialPenaltyBps: 250000, // 25%
+    duration: 5, // slots
+    gracePeriod: 10, // slots
+    penaltyPeriod: 20, // slots
+    minOfferDeltaBps: 50000, // 5%
+    securityDepositBase: uint64ToBN(1000000n), // 1 USDC
+    securityDepositBps: 5000, // 0.5%
+};
+
+runOnSolana("deploy-matching-engine", async (chain, signer, log) => {
+    const config = await getChainConfig<MatchingEngineConfiguration>("matching-engine", chain.chainId);
+    const matchingEngineId = getContractAddress("MatchingEngine", chain.chainId) as ProgramId;
+
+    const env = "Mainnet";
+    const usdcMint = new PublicKey(circle.usdcContract(env, "Solana"));
+    const connection = new Connection(chain.rpc, connectionCommitmentLevel);
+    const matchingEngine = new MatchingEngineProgram(connection, matchingEngineId, usdcMint);
+
+    await initialize(matchingEngine, signer, log, config, usdcMint);
+});
+
+async function initialize(matchingEngine: MatchingEngineProgram, signer: SolanaLedgerSigner, log: LoggerFn, config: MatchingEngineConfiguration, usdcMint: PublicKey) {
+    const connection = matchingEngine.program.provider.connection;
+
+    const custodian = matchingEngine.custodianAddress();
+    log("custodian", custodian.toString());
+
+    const exists = await connection.getAccountInfo(custodian).then((acct) => acct != null);
+    if (exists) {
+        log("already initialized");
+        return;
+    }
+
+    const signerPubkey = new PublicKey(await signer.getAddress());
+    const initializeIx = await matchingEngine.initializeIx(
+        {
+            owner: signerPubkey,
+            ownerAssistant: signerPubkey,
+            feeRecipient: signerPubkey,
+        },
+        AUCTION_PARAMS,
+    );
+
+    const splToken = await import("@solana/spl-token");
+    const assocciatedTokenProgramId = splToken.ASSOCIATED_TOKEN_PROGRAM_ID;
+    const associatedToken = splToken.getAssociatedTokenAddressSync(usdcMint, signerPubkey, undefined, usdcMint, assocciatedTokenProgramId);
+    const createAtaInstructions = [];
+    createAtaInstructions.push(splToken.createAssociatedTokenAccountInstruction(signerPubkey, associatedToken, signerPubkey, usdcMint));
+    createAtaInstructions.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 }));
+
+    const createAtaTxid = await ledgerSignAndSend(connection, createAtaInstructions, []);
+    log(`CreateAtaTxid ${createAtaTxid}`);
+
+    const initializeTxid = await ledgerSignAndSend(connection, [initializeIx], []);
+    log(`InitializeTxid ${initializeTxid}`);
+}
+