WIP scripts

Author: AgusVelez5

deployment/config/config-types.ts

@@ -12,7 +12,7 @@ export type TokenRouterConfiguration = {
     baseFee: number;
     initAuctionFee: number;
   };
-  cctpAllowance: number;
+  cctpAllowance: string;
   disableRouterEndpoints?: ChainId[];
 };
 
@@ -30,5 +30,5 @@ export type MatchingEngineConfiguration = {
   // Mutable values
   ownerAssistant: string;
   feeRecipient: string;
-  cctpAllowance: number;
+  cctpAllowance: string;
 };

deployment/helpers/env.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import { ethers, utils } from "ethers";
 import { validateSolAddress } from "./solana";
-import { ChainConfig, ChainInfo, ContractsJson, Dependencies, Ecosystem } from "./interfaces";
+import { ChainConfig, ChainInfo, ContractsJson, Dependencies, Ecosystem, VerificationApiKeys } from "./interfaces";
 import { getSigner } from "./evm";
 // TODO: support different env files
 import 'dotenv/config';
@@ -11,6 +11,7 @@ export const env = getEnv("ENV");
 export const contracts = loadContracts();
 export const dependencies = loadDependencies();
 export const ecosystemChains = loadEcosystem();
+export const verificationApiKeys = loadVerificationApiKeys();
 
 function loadJson<T>(filename: string): T {
   const fileContent = fs.readFileSync(
@@ -32,6 +33,10 @@ function loadEcosystem(): Ecosystem {
   return loadJson<Ecosystem>("ecosystem");
 }
 
+function loadVerificationApiKeys() {
+  return loadJson<VerificationApiKeys[]>("verification-api-keys");
+}
+
 export function getEnv(env: string): string {
   const v = process.env[env];
   if (!v) {

deployment/helpers/interfaces.ts

@@ -1,4 +1,4 @@
-import { ChainId } from "@wormhole-foundation/sdk-base";
+import { ChainId, Network } from "@wormhole-foundation/sdk-base";
 import { SolanaLedgerSigner } from "@xlabs-xyz/ledger-signer-solana";
 import { BytesLike, ethers } from "ethers";
 
@@ -9,13 +9,23 @@ export type LoggerFn = (...args: any[]) => void;
 
 export type ChainInfo = {
   name: string;
-  chainId: ChainId; // Wormhole ChainId
+  /**
+   * Wormhole ChainId
+   */
+  chainId: ChainId;
   rpc: string;
-  externalId?: string; // Native ChainId
+  /**
+   * Native ChainId
+   */
+  externalId?: string;
+  network: Network;
 };
 
 export type Deployment = {
-  chainId: number; // Wormhole ChainId
+  /**
+   * Wormhole ChainId
+   */
+  chainId: number;
   address: string;
   constructorArgs?: any[];
 };
@@ -33,7 +43,10 @@ export type Ecosystem = {
 export type ContractsJson = Record<string, Deployment[]>;
 
 export interface ChainConfig {
-  chainId: ChainId; // Wormhole ChainId
+  /**
+   * Wormhole ChainId
+   */
+  chainId: ChainId;
 }
 
 export interface Dependencies extends ChainConfig {
@@ -57,7 +70,10 @@ export interface VerificationApiKeys extends ChainConfig {
 } 
 
 export type RouterEndpoint = {
-  wormholeChainId: ChainId;
+  /**
+   * Wormhole ChainId
+   */
+  chainId: ChainId;
   endpoint: {
     router: BytesLike;
     mintRecipient: BytesLike;

deployment/helpers/utils.ts

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { ChainInfo, LoggerFn, ValueDiff } from '.';
+import { UniversalAddress } from '@wormhole-foundation/sdk-definitions';
 
 export const someoneIsDifferent = (values: ValueDiff[]) => values.some((value) => value.onChain.toString() !== value.offChain.toString() && Number(value.onChain) !== Number(value.offChain));
 
@@ -48,7 +49,10 @@ export function flattenObject(obj: Record<string, any>, parentKey = '', result:
   return result;
 }
 
-/// Verify bytecode helper
+export function getUniversalAddress(address: string): string {
+  const type = getAddressType(address);
+  return new UniversalAddress(address, type).toString()
+}
 
 export function getVerifyCommand(
   chain: ChainInfo,

deployment/scripts/evm/TokenRouter/bytecode-verification-token-router.ts

@@ -1,4 +1,4 @@
-import { runOnEvms, ChainInfo, LoggerFn, getContractAddress, getDeploymentArgs, getVerifyCommand } from "../../../helpers";
+import { runOnEvms, ChainInfo, LoggerFn, getContractAddress, getDeploymentArgs, getVerifyCommand, verificationApiKeys, flattenObject } from "../../../helpers";
 import { ethers } from "ethers";
 import { execSync } from "child_process";
 import path from "path";
@@ -8,44 +8,55 @@ runOnEvms("bytecode-verification-token-router", async (chain: ChainInfo, signer:
   // The root path of the foundry project
   const rootPath = path.resolve('../evm/');
 
-  if (chain.externalId === undefined)
-    throw new Error(`Chain ${chain.chainId} does not have an external ID`);
 
-  // Implementation data
-  const implementationName = "TokenRouter";
-  const implementationPath = 'src/TokenRouter/TokenRouter.sol';
-  const implementationAddress = getContractAddress("TokenRouterImplementation", chain.chainId);
-  const implementationDeploymentArgs = getDeploymentArgs("TokenRouterImplementation", chain.chainId);
-  const implementationConstructorSignature = "constructor(address,address,address,uint16,bytes32,bytes32,uint32)";
-  const verifyImplementationCommand = getVerifyCommand(
-    implementationName, 
-    implementationPath,
-    implementationAddress, 
-    implementationConstructorSignature, 
-    implementationDeploymentArgs, 
-    parseInt(chain.externalId)
-  );
-  
-  // Proxy data
-  const proxyName = "ERC1967Proxy";
-  const proxyPath = 'lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol';
-  const proxyAddress = getContractAddress("TokenRouterProxy", chain.chainId);
-  const proxyDeploymentArgs = getDeploymentArgs("TokenRouterProxy", chain.chainId);
-  const proxyConstructorSignature = "constructor(address,bytes)";
-  const verifyProxyCommand = getVerifyCommand(
-    proxyName,
-    proxyPath, 
-    proxyAddress, 
-    proxyConstructorSignature, 
-    proxyDeploymentArgs, 
-    parseInt(chain.externalId)
-  );
+  const verifiersData = verificationApiKeys.find((x) => x.chainId == chain.chainId);
+  const verifiers = flattenObject(verifiersData!);
+  delete verifiers.chainId;
 
-  log(chalk.green("Verifying implementation bytecode..."));
-  execSync(verifyImplementationCommand, { stdio: "inherit", cwd: rootPath });
-  console.log()
+  for (let [name, apiKey] of Object.entries(verifiers)) {
+    name = name.split("-")[0];
 
-  log(chalk.green("Verifying proxy bytecode..."));
-  execSync(verifyProxyCommand, { stdio: "inherit", cwd: rootPath });
-  console.log()
+    // Implementation data
+    const implementationName = "MatchingEngine";
+    const implementationPath = 'src/MatchingEngine/MatchingEngine.sol';
+    const implementationAddress = getContractAddress("MatchingEngineImplementation", chain.chainId);
+    const implementationDeploymentArgs = getDeploymentArgs("MatchingEngineImplementation", chain.chainId);
+    const implementationConstructorSignature = "constructor(address,address,address,uint24,uint24,uint8,uint8,uint8)";
+    const verifyImplementationCommand = getVerifyCommand(
+      chain,
+      implementationName, 
+      implementationPath,
+      implementationAddress, 
+      implementationConstructorSignature, 
+      implementationDeploymentArgs, 
+      name,
+      apiKey
+    );
+    
+    // Proxy data
+    const proxyName = "ERC1967Proxy";
+    const proxyPath = 'lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol';
+    const proxyAddress = getContractAddress("MatchingEngineProxy", chain.chainId);
+    const proxyDeploymentArgs = getDeploymentArgs("MatchingEngineProxy", chain.chainId);
+    const proxyConstructorSignature = "constructor(address,bytes)";
+    const verifyProxyCommand = getVerifyCommand(
+      chain,
+      proxyName,
+      proxyPath, 
+      proxyAddress, 
+      proxyConstructorSignature, 
+      proxyDeploymentArgs, 
+      name,
+      apiKey
+    );
+
+    log(chalk.green(`Verifying bytecode on ${name}...`));
+    log(chalk.green("Verifying implementation bytecode..."));
+    execSync(verifyImplementationCommand, { stdio: "inherit", cwd: rootPath });
+    console.log()
+
+    log(chalk.green("Verifying proxy bytecode..."));
+    execSync(verifyProxyCommand, { stdio: "inherit", cwd: rootPath });
+    console.log()
+  }
 });

deployment/scripts/evm/TokenRouter/cross-registration-token-router.ts

@@ -0,0 +1,37 @@
+import { ChainInfo, LoggerFn, getContractInstance, getContractAddress, runOnEvms, contracts, getUniversalAddress } from "../../../helpers";
+import { ethers } from "ethers";
+import { TokenRouter } from "../../../contract-bindings";
+import { circle } from "@wormhole-foundation/sdk-base";
+
+runOnEvms("cross-registration-token-router", async (chain: ChainInfo, signer: ethers.Signer, log: LoggerFn) => {
+  const tokenRouterAddress = getContractAddress("TokenRouterProxy", chain.chainId);
+  const tokenRouter = (await getContractInstance("TokenRouter", tokenRouterAddress, chain)) as TokenRouter;
+  const deployedTokenRouters = contracts['TokenRouterProxy'].filter((router) => router.chainId !== chain.chainId);
+
+  for (const router of deployedTokenRouters) {
+    const circleDomain = circle.toCircleChainId(chain.network, router.chainId);
+    const endpoint = {
+      router: getUniversalAddress(router.address),
+      mintRecipient: getUniversalAddress(router.address)
+    };
+
+
+    // check if is already registered
+    
+    if (router.chainId === 0) 
+      throw new Error('Invalid chainId when register new router endpoint');
+
+    if (Number(router.address) === 0)
+      throw new Error(`Invalid router address for chainId ${router.chainId}`);
+
+    const isAlreadyRegistered = 
+
+    await tokenRouter.addRouterEndpoint(router.chainId, endpoint, circleDomain);
+    log(`Router endpoint added for chainId ${router.chainId}`);
+  }
+});
+
+function isRouterEndpointRegistered(router: TokenRouter, chainId: number, endpoint: { router: string; mintRecipient: string }) {
+  const mintRecipient = await tokenRouter.getMintRecipient(router.chainId, endpoint);
+  return Number(mintRecipient) !== 0;
+}