ci: testnet-prod

.github/workflows/build-test-deploy.yml

@@ -64,11 +64,11 @@ jobs:
       - name: Check Yarn version
         run: yarn --version
 
-      - name: Validate using commitlint
-        if: github.ref != 'refs/heads/testnet-prod' || github.ref != 'refs/heads/prod'
-        uses: wagoid/commitlint-github-action@v5
-        with:
-          commitDepth: 1
+      # - name: Validate using commitlint
+      #   if: github.ref != 'refs/heads/testnet-prod' || github.ref != 'refs/heads/prod'
+      #   uses: wagoid/commitlint-github-action@v5
+      #   with:
+      #     commitDepth: 1
 
       - name: Yarn install
         run: yarn install

README.md

@@ -61,7 +61,7 @@
 
 ## Connext Architecture
 
-The Connext architecture can be seen as a layered system, as follows.
+The Connext architecture can be seen as a layered system, as follows:
 
 | Layer                            | Protocol/Stakeholders                  |
 | -------------------------------- | -------------------------------------- |

ops/mainnet/prod/core/main.tf

@@ -392,7 +392,7 @@ module "lighthouse_sendoutboundroot_cron" {
   stage               = var.stage
   container_env_vars  = merge(local.lighthouse_env_vars, { LIGHTHOUSE_SERVICE = "sendoutboundroot" })
   schedule_expression = "rate(120 minutes)"
-  memory_size         = 512
+  memory_size         = 2048
 }
 
 

packages/adapters/web3signer/package.json

@@ -8,17 +8,11 @@
     "dist/**/*"
   ],
   "scripts": {
-    "dev": "",
-    "start": "",
+    "build": "tsc --build ./tsconfig.build.json",
     "lint": "eslint ./src --ext .ts --env node",
-    "test": "",
     "clean": "rimraf ./dist ./tsconfig.tsBuildInfo",
-    "build": "tsc --build ./tsconfig.build.json",
     "verify": "yarn test && yarn clean && yarn build && yarn lint --max-warnings 0",
     "purge": "yarn clean && rimraf ./coverage ./node_modules",
-    "tsp": "yarn run tsp:root \"$@\" --cwd $(pwd)",
-    "codegen:runtime": "graphql-codegen --config ./runtime.yml",
-    "codegen:analytics": "graphql-codegen --config ./analytics.yml",
     "version": "yarn version"
   },
   "nodemonConfig": {

packages/agents/cartographer/api/gelato2.http

@@ -4,4 +4,7 @@
 # just a few examples, more examples here: https://postgrest.org/en/stable/api.html#horizontal-filtering-rows
 
 ### get conversion rate
-GET {{Url}}/oracles/{{chainId}}/conversionRate?to=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
+GET {{Url}}/oracles/{{chainId}}/conversionRate?to=0x0000000000000000000000000000000000000000
+
+### get estimate
+GET {{Url}}/oracles/{{chainId}}/estimate?paymentToken=0x0000000000000000000000000000000000000000&gasLimit=1000000

packages/agents/chain-abstraction/package.json

@@ -23,7 +23,13 @@
   "dependencies": {
     "@connext/nxtp-utils": "workspace:*",
     "@connext/sdk-core": "workspace:*",
+    "@pancakeswap/sdk": "^5.0.0",
     "@sinclair/typebox": "0.25.21",
+    "@swapr/sdk": "^1.9.0",
+    "@uniswap/sdk": "^3.0.3",
+    "@uniswap/sdk-core": "^3.2.6",
+    "@uniswap/smart-order-router": "^3.13.4",
+    "@uniswap/v3-sdk": "^3.9.0",
     "ethers": "5.7.2",
     "isomorphic-fetch": "^3.0.0",
     "memoizee": "0.4.15",

packages/agents/chain-abstraction/src/helpers/index.ts

@@ -21,6 +21,13 @@ import {
   getSwapQuoteForUniV3,
   initCoreSDK as _initCoreSDK,
 } from "./swapquote";
+import {
+  DestinationSwapPathCallback,
+  getSwapPathForUniV3 as _getSwapPathForUniV3,
+  getSwapPathForUniV2 as _getSwapPathForUniV2,
+  // getSwapPathForHoneySwap as _getSwapPathForHoneySwap,
+  getPathForPanCake as _getPathForPanCake,
+} from "./swaputil";
 import { DEPLOYED_ADDRESSES as _DEPLOYED_ADDRESSES } from "./address";
 import {
   getSupportedAssets as _getSupportedAssets,
@@ -34,6 +41,10 @@ export const getTokenPricesInUsd = _getTokenPricesInUsd;
 
 export const DEPLOYED_ADDRESSES = _DEPLOYED_ADDRESSES;
 export const initCoreSDK = _initCoreSDK;
+export const getSwapPathForUniV3 = _getSwapPathForUniV3;
+export const getSwapPathForUniV2 = _getSwapPathForUniV2;
+// export const getSwapPathForHoneySwap = _getSwapPathForHoneySwap;
+export const getPathForPanCake = _getPathForPanCake;
 
 export const OriginSwapDataFns: Record<Swapper, OriginSwapDataCallback> = {
   UniV2: getOriginSwapDataForUniV2,
@@ -47,6 +58,13 @@ export const DestinationSwapDataFns: Record<Swapper, DestinationSwapDataCallback
   OneInch: getDestinationSwapDataForOneInch,
 };
 
+export const DestinationSwapPathFns: Record<Swapper, DestinationSwapPathCallback> = {
+  UniV2: getSwapPathForUniV2,
+  UniV3: getSwapPathForUniV3,
+  PanCake: getPathForPanCake,
+  // HoneySwap: getSwapPathForHoneySwap,
+}; 
+
 export const SwapQuoteFns: Record<Swapper, SwapQuoteCallback> = {
   UniV2: getSwapQuoteForUniV2,
   UniV3: getSwapQuoteForUniV3,
@@ -96,45 +114,56 @@ export const OriginSwapperPerDomain: Record<string, { type: Swapper; address: st
   }, // Polygon zkEVM
 };
 
-export const DestinationSwapperPerDomain: Record<string, { type: Swapper; address: string; quoter: string }> = {
+export const DestinationSwapperPerDomain: Record<
+  string,
+  { type: Swapper; address: string; quoter: string; path: Swapper }
+> = {
   "6648936": {
     type: Swapper.UniV3,
     address: "",
     quoter: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+    path: Swapper.UniV3,
   }, // ETH mainnet
   "1869640809": {
     type: Swapper.UniV3,
     address: "0x1135Cc96A7E9d8f161BE8B6bDB74F896A9658a08",
     quoter: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+    path: Swapper.UniV3,
   }, // Optimism
   "6450786": {
     type: Swapper.UniV3,
     address: "0x0b081b724CDC4DD9186E64F259b5fC589a4Fd7D0", // PancakeV3 Swapper
     quoter: "0xB048Bbc1Ee6b733FFfCFb9e9CeF7375518e25997",
+    path: Swapper.PanCake,
   }, // BNB Chain
   "6778479": {
     type: Swapper.UniV2,
     address: "0x7b659eF70e18C01d88F305042ae916D235cb8648",
     quoter: "0x7b659eF70e18C01d88F305042ae916D235cb8648",
+    path: Swapper.HoneySwap,
   }, // Gnosis Chain
   "1886350457": {
     type: Swapper.UniV3,
     address: "0xeC345E9be52f0Fca8aAd6aec3254Ed86151b060d", // UniV3 Swapper
     quoter: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+    path: Swapper.UniV3,
   }, // Polygon
   "1634886255": {
     type: Swapper.UniV3,
     address: "0x924E679c3c23017aef214c9ea1fBC22e97ff9E2e",
     quoter: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+    path: Swapper.UniV3,
   }, // Arbitrum One
   "2053862243": {
     type: Swapper.UniV3,
     address: "",
     quoter: "",
+    path: "",
   }, // zkSync2 mainnet
   "1887071085": {
     type: Swapper.UniV3,
     address: "",
     quoter: "",
+    path: "",
   }, // Polygon zkEVM
 };

packages/agents/chain-abstraction/src/helpers/swapdata.ts

@@ -14,7 +14,7 @@ export type OriginSwapDataCallbackArgs = {
   slippage?: number;
 };
 export type OriginSwapDataCallback = (args: OriginSwapDataCallbackArgs) => Promise<string>;
-export type DestinationSwapDataCallback = (args: any) => Promise<string>;
+export type DestinationSwapDataCallback = (args: any, path?: any) => Promise<string>;
 
 // ==================================== ORIGIN SIDE ==================================== //
 /**
@@ -56,17 +56,20 @@ export const getOriginSwapDataForOneInch = async (args: OriginSwapDataCallbackAr
 /**
  * Returns the `swapData` which will be used on the destination univ2 swapper
  */
-export const getDestinationSwapDataForUniV2 = async (_args: any): Promise<string> => {
+export const getDestinationSwapDataForUniV2 = async (_args: any, path?: any): Promise<string> => {
   const args = _args as UniV2SwapperParams;
-  return defaultAbiCoder.encode(["uint256"], [args.amountOutMin]);
+  return path
+    ? defaultAbiCoder.encode(["uint256", "address[]"], [args.amountOutMin, path])
+    : defaultAbiCoder.encode(["uint256"], [args.amountOutMin]);
 };
 
 /**
  * Returns the `swapData` which will be used on the destination univ3 swapper
  */
-export const getDestinationSwapDataForUniV3 = async (_args: any): Promise<string> => {
+export const getDestinationSwapDataForUniV3 = async (_args: any, path?: any): Promise<string> => {
   const args = _args as UniV3SwapperParams;
-  return defaultAbiCoder.encode(["uint24", "uint256"], [args.poolFee, args.amountOutMin]);
+  if (!path) return defaultAbiCoder.encode(["uint24", "uint256"], [args.poolFee, args.amountOutMin]);
+  return defaultAbiCoder.encode(["uint256", "bytes"], [args.amountOutMin, path]);
 };
 
 /**

packages/agents/chain-abstraction/src/helpers/swaputil.ts

@@ -0,0 +1,111 @@
+import { AlphaRouter, V3RouteWithValidQuote } from "@uniswap/smart-order-router";
+import { ethers } from "ethers";
+import { CurrencyAmount, Token, TradeType } from "@uniswap/sdk-core";
+import { Route, Trade, Token as _Token, Fetcher, TokenAmount, Pair } from "@uniswap/sdk";
+import { encodeRouteToPath } from "@uniswap/v3-sdk";
+import {
+  Fetcher as PancakeFetcher,
+  Trade as PancakeTrade,
+  Token as PancakeToken,
+  Route as PancakeRoute,
+  CurrencyAmount as PancakeCurrencyAmount,
+} from "@pancakeswap/sdk";
+
+type SwapPathCallBackArgs = {
+  fromTokenContractAddress: string;
+  toTokenContractAddress: string;
+  signerAddress: string;
+  chainId: number;
+  rpc: string;
+  amount: string;
+  fromTokenDecimal?: number;
+  toTokenDecimal?: number;
+};
+
+export type DestinationSwapPathCallback = (args: SwapPathCallBackArgs) => Promise<any>;
+
+/**
+ * Returns the `path` from the uniswap v3 router.
+ */
+export const getSwapPathForUniV3 = async (_args: SwapPathCallBackArgs) => {
+  try {
+    const { fromTokenContractAddress, toTokenContractAddress, chainId, rpc, fromTokenDecimal, toTokenDecimal, amount } =
+      _args;
+    const provider = new ethers.providers.JsonRpcProvider(rpc);
+    const tokenIn = new Token(chainId, fromTokenContractAddress, fromTokenDecimal ?? 18);
+    const tokenOut = new Token(chainId, toTokenContractAddress, toTokenDecimal ?? 18);
+    const amountIn = CurrencyAmount.fromRawAmount(tokenIn, +amount);
+
+    const router = new AlphaRouter({
+      chainId,
+      provider,
+    });
+
+    const routes = await router.route(amountIn, tokenOut, TradeType.EXACT_INPUT);
+
+    if (!routes) {
+      throw Error("No routes found for given Pair");
+    }
+
+    const route = routes?.route[0] as V3RouteWithValidQuote;
+    const path = encodeRouteToPath(route.route, false);
+    console.log(route.route, path, "from sdk function");
+    return {
+      quote: routes.quote,
+      tokenPath: path,
+      route: route.route.protocol,
+    };
+  } catch (err: unknown) {
+    throw Error(`getSwapPathForUniV3: Failed to get paths ${(err as Error).message}`);
+  }
+};
+
+/**
+ * Returns the `path` from the uniswap v2 router.
+ */
+export const getSwapPathForUniV2 = async (_args: SwapPathCallBackArgs) => {
+  try {
+    const { fromTokenContractAddress, toTokenContractAddress, chainId, rpc, fromTokenDecimal, toTokenDecimal, amount } =
+      _args;
+
+    const provider = new ethers.providers.JsonRpcProvider(rpc);
+
+    const tokenIn = new _Token(chainId, fromTokenContractAddress, fromTokenDecimal ?? 18);
+    const tokenOut = new _Token(chainId, toTokenContractAddress, toTokenDecimal ?? 18);
+    const amountIn = new TokenAmount(tokenIn, ethers.utils.parseUnits(amount, fromTokenDecimal).toString());
+
+    const pair: Pair = await Fetcher.fetchPairData(tokenIn, tokenOut, provider);
+    const route = new Route([pair], tokenIn);
+    const trade = new Trade(route, amountIn, TradeType.EXACT_INPUT);
+
+    return {
+      quote: trade.outputAmount.toSignificant(),
+      tokenPath: route.path.map((token) => token.address),
+      route: "V2",
+    };
+  } catch (err: unknown) {
+    throw Error(err as string);
+  }
+};
+
+export const getPathForPanCake = async (_args: SwapPathCallBackArgs) => {
+  try {
+    const { fromTokenContractAddress, toTokenContractAddress, chainId, fromTokenDecimal, toTokenDecimal, amount } =
+      _args;
+    const tokenIn = new PancakeToken(chainId, fromTokenContractAddress as `0x${string}`, fromTokenDecimal ?? 18, "");
+
+    const tokenOut = new PancakeToken(chainId, toTokenContractAddress as `0x${string}`, toTokenDecimal ?? 18, "");
+    const pair = await PancakeFetcher.fetchPairData(tokenIn, tokenOut);
+
+    const amountIn = PancakeCurrencyAmount.fromRawAmount(tokenIn, amount);
+    const route = new PancakeRoute([pair], tokenIn, tokenOut);
+    const trade = new PancakeTrade(route, amountIn, TradeType.EXACT_INPUT);
+    return {
+      quote: trade.outputAmount.toSignificant(),
+      tokenPath: route.path.map((token) => token.address),
+      route: "PANCAKE",
+    };
+  } catch (err: unknown) {
+    throw Error(err as string);
+  }
+};