@pioneer-platform/uniswap-client 0.0.26 → 0.0.28

package/lib/constants/chainInfo.d.ts

@@ -1,7 +1,7 @@
 import { ChainId } from '@uniswap/sdk-core';
 import { SupportedL1ChainId, SupportedL2ChainId } from './chains';
-export declare const AVERAGE_L1_BLOCK_TIME: any;
-export declare const DEFAULT_MS_BEFORE_WARNING: any;
+export declare const AVERAGE_L1_BLOCK_TIME: number;
+export declare const DEFAULT_MS_BEFORE_WARNING: number;
 /**
  *
  * @param chainId

package/lib/index.js

@@ -62,12 +62,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var TAG = " | Uniswap | ";
 var axios_1 = __importDefault(require("axios"));
+// @ts-ignore
+var pioneer_discovery_1 = require("@pioneer-platform/pioneer-discovery");
 var _a = require("@pioneer-platform/pioneer-caip"), caipToNetworkId = _a.caipToNetworkId, shortListSymbolToCaip = _a.shortListSymbolToCaip, ChainToNetworkId = _a.ChainToNetworkId;
 var uuid = require('uuidv4').uuid;
 var log = require('@pioneer-platform/loggerdog')();
 var _b = require('ethers'), ethers = _b.ethers, BigNumber = _b.BigNumber;
 var ethers_1 = require("ethers");
 var sdk_core_1 = require("@uniswap/sdk-core");
+var clientSideSmartOrderRouter_1 = require("./routing/clientSideSmartOrderRouter");
+var universal_router_sdk_1 = require("@uniswap/universal-router-sdk");
 var v3_sdk_1 = require("@uniswap/v3-sdk");
 var networkSupport = [
     ChainToNetworkId["ETH"],
@@ -105,6 +109,11 @@ var ERC20_ABI = [
     "function symbol() view returns (string)",
     "function decimals() view returns (uint8)"
 ];
+function toDeadline(expiration) {
+    return Math.floor((Date.now() + expiration) / 1000);
+}
+var PERMIT_EXPIRATION = 2592000000; // 30 days in milliseconds
+var PERMIT_SIG_EXPIRATION = 1800000; // 30 minutes in milliseconds
 module.exports = {
     init: function (settings) {
         return true;
@@ -112,13 +121,719 @@ module.exports = {
     networkSupport: function () {
         return networkSupport;
     },
+    assetSupport: function () {
+        return getAssetSupport();
+    },
+    buildPermitTx: function (permit) {
+        return get_permit(permit);
+    },
+    buildLpTx: function (quote) {
+        return build_lp_tx(quote);
+    },
     getQuote: function (quote) {
-        return get_quote(quote);
+        return get_quote_local(quote);
     }
+    //ProvideLP
+    // getQuote: function (quote:any) {
+    //     return get_quote_api(quote);
+    // }
 };
-var get_quote = function (quote) {
+// const build_lp_tx = async function (input: any) {
+//     let tag = "build_lp_tx | ";
+//     try {
+//         log.info("input: ", input);
+//         let output: any = {};
+//
+//         let inputChain = input.chain;
+//         let fromAddress = input.fromAddress;
+//         log.info("inputChain: ", inputChain);
+//         let providerUrl = EIP155_MAINNET_CHAINS[inputChain].rpc;
+//         if (!providerUrl) throw new Error("missing providerUrl");
+//         log.info("providerUrl: ", providerUrl);
+//
+//         const provider = new ethers.providers.JsonRpcProvider(providerUrl); // Set your Ethereum RPC URL
+//
+//         const positionManagerAddress = '0x03a520b32c04bf3beef7beb72e919cf822ed34f1';
+//         const positionManagerABI = [
+//             "function mint((address token0, address token1, uint24 fee, int24 tickLower, int24 tickUpper, uint128 amount0Desired, uint128 amount1Desired, uint128 amount0Min, uint128 amount1Min, address recipient, uint256 deadline)) external returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)"
+//         ];
+//
+//         const walletPrivateKey = process.env.WALLET_PRIVATE_KEY; // Ensure you have the private key in environment variables
+//         if (!walletPrivateKey) throw new Error("missing wallet private key");
+//
+//         const wallet = new ethers.Wallet(walletPrivateKey, provider);
+//         const positionManager = new ethers.Contract(positionManagerAddress, positionManagerABI, wallet);
+//
+//         const token0 = '0x4200000000000000000000000000000000000006'; // Address of token0
+//         const token1 = '0xef743df8eda497bcf1977393c401a636518dd630'; // Address of token1
+//         const fee = 3000; // Fee tier, for example 0.3%
+//         const tickLower = -60000; // Lower tick
+//         const tickUpper = 60000; // Upper tick
+//         const amount0Desired = ethers.utils.parseUnits("0.01", 18); // 10 token0
+//         const amount1Desired = ethers.utils.parseUnits("41.2", 18); // 10 token1
+//         const amount0Min = ethers.utils.parseUnits("0.001", 18); // Min token0
+//         const amount1Min = ethers.utils.parseUnits(".9", 18); // Min token1
+//         const recipient = fromAddress; // Recipient address
+//         const deadline = Math.floor(Date.now() / 1000) + 60 * 20; // Transaction deadline
+//
+//         const params = {
+//             token0,
+//             token1,
+//             fee,
+//             tickLower,
+//             tickUpper,
+//             amount0Desired,
+//             amount1Desired,
+//             amount0Min,
+//             amount1Min,
+//             recipient,
+//             deadline
+//         };
+//         log.info(tag, "params: ", params);
+//
+//         const txData = await positionManager.populateTransaction.mint(params);
+//         log.info(tag, "Transaction data prepared:", txData);
+//
+//         const value = token0 === ethers.constants.AddressZero ? amount0Desired : ethers.BigNumber.from(0); // Assuming token0 is ETH
+//         log.info("calldata: ", txData.data);
+//         log.info("value: ", value);
+//
+//         const nonce = await provider.getTransactionCount(fromAddress, "latest");
+//         log.info("nonce: ", nonce);
+//         let gas = ethers.BigNumber.from("935120"); // 935120
+//         const gasPrice = await provider.getGasPrice();
+//         log.info("gasPrice: ", gasPrice.toString());
+//         const adjustedGasPrice = gasPrice.mul(ethers.BigNumber.from(110)).div(ethers.BigNumber.from(100)); // Example: Increase by 10%
+//
+//         let isZero = function isZero(hexNumberString: string) {
+//             return hexNumberString === '0' || /^0x0*$/.test(hexNumberString);
+//         };
+//
+//         output.txs = [];
+//         const tx = {
+//             from: fromAddress,
+//             to: positionManagerAddress,
+//             chainId: parseInt(inputChain.split(':')[1]),
+//             data: txData.data,
+//             ...(value && !isZero(value.toString()) ? { value: value } : {}),
+//             gasLimit: gas,
+//             gasPrice: adjustedGasPrice,
+//             nonce: nonce,
+//         };
+//
+//         log.info(tag, "Transaction params:", tx);
+//
+//         // Send the transaction
+//         const transactionResponse = await wallet.sendTransaction(tx);
+//         log.info(tag, "Transaction response:", transactionResponse);
+//
+//         // Wait for the transaction to be mined
+//         const receipt = await transactionResponse.wait();
+//         log.info(tag, "Transaction receipt:", receipt);
+//
+//         output.txs.push({
+//             type: "evm",
+//             description: 'mint PRO position',
+//             chain: inputChain,
+//             txParams: tx,
+//             txHash: transactionResponse.hash,
+//             receipt: receipt,
+//         });
+//
+//         output.meta = {
+//             quoteMode: "LP"
+//         };
+//         output.steps = 1;
+//         output.complete = true;
+//         output.type = 'EVM';
+//         output.id = uuid();
+//
+//         return output;
+//     } catch (e) {
+//         console.error(e);
+//     }
+// };
+var build_lp_tx = function (input) {
     return __awaiter(this, void 0, void 0, function () {
-        var tag, output, from, recipient, inputChain, outputChain, providerUrl, chainIdInt, chainId, provider, sellTokenContract, buyTokenContract, BUY_TOKEN, SELL_TOKEN, BUY_TOKEN_ADDRESS, SELL_TOKEN_ADDRESS, buyTokenAddress, symbolBuy, decimalsBuy, balance, sellTokenAddress, symbolSell, decimalsSell, FEE_AMOUNT, inputPRO, args, Protocol, QuoteIntent, CLIENT_PARAMS, tokenIn, tokenInChainId, tokenOut, tokenOutChainId, amount, tradeType, sendPortionEnabled, requestBody, response, uraQuoteResponse, calldata, value, nonce, gas, gasPrice, adjustedGasPrice, isZero, tx, e_1;
+        var tag, output, inputChain, fromAddress, providerUrl, provider, positionManagerAddress, positionManagerABI, positionManager, token0, token1, fee, tickLower, tickUpper, amount0Desired, amount1Desired, amount0Min, amount1Min, recipient, deadline, params, txData, value, nonce, gas, gasPrice, adjustedGasPrice, isZero, tx, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + " | build_lp_tx | ";
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 5, , 6]);
+                    log.info("input: ", input);
+                    output = {};
+                    inputChain = input.chain;
+                    fromAddress = input.fromAddress;
+                    log.info("inputChain: ", inputChain);
+                    providerUrl = EIP155_MAINNET_CHAINS[inputChain].rpc;
+                    if (!providerUrl)
+                        throw new Error("missing providerUrl");
+                    log.info("providerUrl: ", providerUrl);
+                    provider = new ethers.providers.JsonRpcProvider(providerUrl);
+                    positionManagerAddress = '0x03a520b32c04bf3beef7beb72e919cf822ed34f1';
+                    positionManagerABI = [
+                        "function mint((address token0, address token1, uint24 fee, int24 tickLower, int24 tickUpper, uint128 amount0Desired, uint128 amount1Desired, uint128 amount0Min, uint128 amount1Min, address recipient, uint256 deadline)) external returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)"
+                    ];
+                    positionManager = new ethers.Contract(positionManagerAddress, positionManagerABI);
+                    token0 = '0x4200000000000000000000000000000000000006';
+                    token1 = '0xef743df8eda497bcf1977393c401a636518dd630';
+                    fee = 3000;
+                    tickLower = -60000;
+                    tickUpper = 60000;
+                    amount0Desired = ethers.utils.parseUnits("0.01", 18);
+                    amount1Desired = ethers.utils.parseUnits("41.2", 18);
+                    amount0Min = ethers.utils.parseUnits("0.001", 18);
+                    amount1Min = ethers.utils.parseUnits(".9", 18);
+                    recipient = fromAddress;
+                    deadline = Math.floor(Date.now() / 1000) + 60 * 20;
+                    params = {
+                        token0: token0,
+                        token1: token1,
+                        fee: fee,
+                        tickLower: tickLower,
+                        tickUpper: tickUpper,
+                        amount0Desired: amount0Desired,
+                        amount1Desired: amount1Desired,
+                        amount0Min: amount0Min,
+                        amount1Min: amount1Min,
+                        recipient: recipient,
+                        deadline: deadline
+                    };
+                    log.info(tag, "params: ", params);
+                    return [4 /*yield*/, positionManager.mint.call(params)];
+                case 2:
+                    txData = _a.sent();
+                    log.info(tag, "Transaction data prepared:", txData);
+                    value = token0 === ethers.constants.AddressZero ? amount0Desired : '0x0';
+                    log.info("calldata: ", txData.data);
+                    log.info("value: ", value);
+                    return [4 /*yield*/, provider.getTransactionCount(fromAddress, "latest")];
+                case 3:
+                    nonce = _a.sent();
+                    log.info("nonce: ", nonce);
+                    gas = "0x".concat(BigInt("935120").toString(16)) // 935120
+                    ;
+                    return [4 /*yield*/, provider.getGasPrice()];
+                case 4:
+                    gasPrice = _a.sent();
+                    log.info("gasPrice: ", gasPrice.toString());
+                    adjustedGasPrice = gasPrice.mul(ethers.BigNumber.from(110)).div(ethers.BigNumber.from(100));
+                    isZero = function isZero(hexNumberString) {
+                        return hexNumberString === '0' || /^0x0*$/.test(hexNumberString);
+                    };
+                    output.txs = [];
+                    tx = __assign(__assign({ from: fromAddress, to: positionManagerAddress, chainId: inputChain.split(':')[1], data: txData.data }, (value && !isZero(value) ? { value: (0, v3_sdk_1.toHex)(value) } : {})), { gas: gas, gasPrice: (0, v3_sdk_1.toHex)(adjustedGasPrice), nonce: (0, v3_sdk_1.toHex)(nonce) });
+                    output.txs.push({
+                        type: "evm",
+                        description: 'mint PRO position',
+                        chain: inputChain,
+                        txParams: tx
+                    });
+                    output.meta = {
+                        quoteMode: "LP"
+                    };
+                    output.steps = 1;
+                    output.complete = true;
+                    output.type = 'EVM';
+                    output.id = uuid();
+                    return [2 /*return*/, output];
+                case 5:
+                    e_1 = _a.sent();
+                    console.error(e_1);
+                    return [3 /*break*/, 6];
+                case 6: return [2 /*return*/];
+            }
+        });
+    });
+};
+// const build_lp_tx = async function (input: any) {
+//     let tag = TAG + " | build_lp_tx | ";
+//     try {
+//         log.info("input: ", input);
+//         let output: any = {};
+//
+//         const { chain, fromAddress } = input;
+//
+//         log.info("inputChain: ", chain);
+//         let providerUrl = EIP155_MAINNET_CHAINS[chain].rpc;
+//         if (!providerUrl) throw new Error("missing providerUrl");
+//         log.info("providerUrl: ", providerUrl);
+//
+//         const provider = new ethers.providers.JsonRpcProvider(providerUrl);
+//         const nonce = await provider.getTransactionCount(fromAddress, "latest");
+//
+//         // Ensure that the deadline, nonce, and other dynamic parameters are set correctly
+//         const updatedDeadline = Math.floor(Date.now() / 1000) + 60 * 20; // Adjust the deadline as required
+//
+//         let rawData = "0xac9650d8000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000c4219f5d17000000000000000000000000000000000000000000000000000000000006e815" + updatedDeadline.toString(16).padStart(64, '0') + "00000000000000000000000000000000000000000000000000000000663daccf00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000412210e8a00000000000000000000000000000000000000000000000000000000";
+//
+//         let gas = `0x3a345`; // Example gas limit, adjust as needed
+//         let value = `0x2386f26fc10000`; // 0.01 ETH in wei
+//         const gasPrice = await provider.getGasPrice();
+//         const adjustedGasPrice = gasPrice.mul(ethers.BigNumber.from(110)).div(ethers.BigNumber.from(100)); // Example: Increase by 10%
+//
+//         output.txs = [{
+//             type: "evm",
+//             description: 'mint PRO position',
+//             chain,
+//             txParams: {
+//                 chainId:chain.split(':')[1],
+//                 from: fromAddress,
+//                 to: "0x03a520b32c04bf3beef7beb72e919cf822ed34f1",
+//                 data: rawData,
+//                 value: value,
+//                 gas,
+//                 gasPrice: toHex(adjustedGasPrice),
+//                 nonce: toHex(nonce),
+//             }
+//         }];
+//
+//         output.meta = {
+//             quoteMode: "LP"
+//         };
+//         output.steps = 1;
+//         output.complete = true;
+//         output.type = 'EVM';
+//         output.id = uuid();
+//
+//         return output;
+//     } catch (e) {
+//         console.error(tag, e);
+//     }
+// }
+// const build_lp_tx = async function (input:any) {
+//     let tag = TAG + " | build_lp_tx | "
+//     try{
+//         log.info("input: ",input)
+//         let output:any = {}
+//
+//         //
+//         let inputChain = input.chain
+//         let fromAddress = input.fromAddress
+//         log.info("inputChain: ",inputChain)
+//         let providerUrl = EIP155_MAINNET_CHAINS[inputChain].rpc
+//         if(!providerUrl) throw new Error("missing providerUrl")
+//         log.info("providerUrl: ",providerUrl)
+//
+//         //
+//         const provider = new ethers.providers.JsonRpcProvider(providerUrl); // Set your Ethereum RPC URL
+//
+//         const positionManagerAddress = '0x03a520b32c04bf3beef7beb72e919cf822ed34f1';
+//         const positionManagerABI = [
+//             // Include only the necessary part of the ABI for minting a position
+//             "function mint((address token0, address token1, uint24 fee, int24 tickLower, int24 tickUpper, uint128 amount0Desired, uint128 amount1Desired, uint128 amount0Min, uint128 amount1Min, address recipient, uint256 deadline))"
+//         ];
+//         const positionManager = new ethers.Contract(positionManagerAddress, positionManagerABI);
+//
+//         // Define the parameters for the liquidity position
+//         //ETH
+//         const token0 = '0x4200000000000000000000000000000000000006'; // Address of token0
+//         //PRO
+//         const token1 = '0xef743df8eda497bcf1977393c401a636518dd630'; // Address of token1
+//         const fee = 3000; // Fee tier, for example 0.3%
+//         const tickLower = -60000; // Lower tick
+//         const tickUpper = 60000; // Upper tick
+//         const amount0Desired = ethers.utils.parseUnits("0.01", 18); // 10 token0
+//         const amount1Desired = ethers.utils.parseUnits("41.2", 18); // 10 token1
+//         const amount0Min = ethers.utils.parseUnits("0.001", 18); // Min token0
+//         const amount1Min = ethers.utils.parseUnits(".9", 18); // Min token1
+//         const recipient = fromAddress; // Recipient address
+//         const deadline = Math.floor(Date.now() / 1000) + 60 * 20; // Transaction deadline
+//
+//         // Construct the mint parameters
+//         const params = {
+//             token0,
+//             token1,
+//             fee,
+//             tickLower,
+//             tickUpper,
+//             amount0Desired,
+//             amount1Desired,
+//             amount0Min,
+//             amount1Min,
+//             recipient,
+//             deadline
+//         };
+//         log.info(tag,"params: ",params)
+//         const txData = await positionManager.populateTransaction.mint(params);
+//         log.info(tag, "Transaction data prepared:", txData);
+//
+//         //output.tx = tx; // Store the transaction data for future signing
+//         const value = token0 === ethers.constants.AddressZero ? amount0Desired : '0x0'; // Assuming token0 is ETH
+//
+//         log.info("calldata: ",txData.data)
+//         log.info("value: ",value)
+//         const nonce = await provider.getTransactionCount(fromAddress, "latest");
+//         log.info("nonce: ",nonce)
+//         let gas = `0x${BigInt("935120").toString(16)}` // 935120
+//         const gasPrice = await provider.getGasPrice();
+//         log.info("gasPrice: ",gasPrice.toString())
+//         const adjustedGasPrice = gasPrice.mul(ethers.BigNumber.from(110)).div(ethers.BigNumber.from(100)); // Example: Increase by 10%
+//         let  isZero = function isZero(hexNumberString: string) {
+//             return hexNumberString === '0' || /^0x0*$/.test(hexNumberString)
+//         }
+//         output.txs = []
+//         const tx = {
+//             from:fromAddress,
+//             to: EIP155_MAINNET_CHAINS[inputChain].universalRouter,
+//             chainId:inputChain.split(':')[1],
+//             data: txData.data,
+//             // TODO: universal-router-sdk returns a non-hexlified value.
+//             ...(value && !isZero(value) ? { value: toHex(value) } : {}),
+//             gas,
+//             gasPrice: toHex(adjustedGasPrice),
+//             nonce: toHex(nonce),
+//         }
+//         output.txs.push({
+//             type:"evm",
+//             description:'mint PRO position',
+//             chain:inputChain,
+//             txParams: tx
+//         })
+//
+//         output.meta = {
+//             quoteMode: "LP"
+//         }
+//         output.steps = 1
+//         output.complete = true
+//         output.type = 'EVM'
+//         output.id = uuid()
+//
+//         return output;
+//     }catch(e){
+//         console.error(e)
+//     }
+// }
+var get_permit = function (permit) {
+    var tag = TAG + " | get_permit | ";
+    try {
+        var from = permit.from;
+        var token = permit.token;
+        var amount = permit.amount;
+        var chainId = permit.chainId;
+        //iterate over chains
+        var permit712 = {
+            "types": {
+                "PermitSingle": [
+                    {
+                        "name": "details",
+                        "type": "PermitDetails"
+                    },
+                    {
+                        "name": "spender",
+                        "type": "address"
+                    },
+                    {
+                        "name": "sigDeadline",
+                        "type": "uint256"
+                    }
+                ],
+                "PermitDetails": [
+                    {
+                        "name": "token",
+                        "type": "address"
+                    },
+                    {
+                        "name": "amount",
+                        "type": "uint160"
+                    },
+                    {
+                        "name": "expiration",
+                        "type": "uint48"
+                    },
+                    {
+                        "name": "nonce",
+                        "type": "uint48"
+                    }
+                ],
+                "EIP712Domain": [
+                    {
+                        "name": "name",
+                        "type": "string"
+                    },
+                    {
+                        "name": "chainId",
+                        "type": "uint256"
+                    },
+                    {
+                        "name": "verifyingContract",
+                        "type": "address"
+                    }
+                ]
+            },
+            "domain": {
+                "name": "Permit2",
+                "chainId": permit.chainId,
+                "verifyingContract": "0x000000000022d473030f116ddee9f6b43ac78ba3"
+            },
+            "primaryType": "PermitSingle",
+            "message": {
+                "details": {
+                    "token": permit.token,
+                    "amount": permit.amount,
+                    "expiration": permit.expiry,
+                    "nonce": "1"
+                },
+                "spender": EIP155_MAINNET_CHAINS['eip155:' + chainId].universalRouter,
+                "sigDeadline": permit.sigDeadline
+            }
+        };
+        return permit712;
+    }
+    catch (e) {
+        console.error(e);
+    }
+};
+var getAssetSupport = function () {
+    var tag = TAG + " | getAssetSupport | ";
+    try {
+        //iterate over chains
+        var allAssets = Object.keys(pioneer_discovery_1.assetData);
+        // log.info(tag,"allAssets: ",allAssets)
+        var supportedAssets = [];
+        for (var i = 0; i < allAssets.length; i++) {
+            var asset = allAssets[i];
+            var networkId = caipToNetworkId(asset);
+            // console.log("networkId: ",networkId)
+            if (networkSupport.indexOf(networkId) > -1) {
+                supportedAssets.push(asset);
+            }
+        }
+        return supportedAssets;
+    }
+    catch (e) {
+        console.error(e);
+    }
+};
+var get_quote_local = function (quote) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, output, from, recipient, inputChain, outputChain, providerUrl, chainIdInt, chainId, provider, sellTokenContract, buyTokenContract, BUY_TOKEN, SELL_TOKEN, BUY_TOKEN_ADDRESS, SELL_TOKEN_ADDRESS, buyTokenAddress, symbolBuy, decimalsBuy, balance, sellTokenAddress, symbolSell, decimalsSell, inputPRO, spender, allowance, FEE_AMOUNT, args, Protocol, QuoteIntent, CLIENT_PARAMS, router, quoteResult, trade, permit, _a, calldata, value, nonce, gas, gasPrice, adjustedGasPrice, isZero, tx, e_2;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    tag = TAG + " | get_quote_local | ";
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 16, , 17]);
+                    output = {};
+                    if (!quote.sellAsset)
+                        throw new Error("missing sellAsset");
+                    if (!quote.buyAsset)
+                        throw new Error("missing buyAsset");
+                    if (!quote.sellAmount)
+                        throw new Error("missing sellAmount");
+                    if (!quote.senderAddress)
+                        throw new Error("missing senderAddress");
+                    if (!quote.recipientAddress)
+                        throw new Error("missing recipientAddress");
+                    if (!quote.slippage)
+                        throw new Error("missing slippage");
+                    if (!networkSupport.includes(caipToNetworkId(quote.buyAsset))) {
+                        throw new Error("unsupported buyAsset");
+                    }
+                    if (!networkSupport.includes(caipToNetworkId(quote.sellAsset))) {
+                        throw new Error("unsupported sellAsset");
+                    }
+                    // if(!quote.permit2) throw new Error("missing permit2, required for uniswap")
+                    output.txs = [];
+                    from = quote.senderAddress;
+                    recipient = quote.recipientAddress;
+                    output.sellAsset = {};
+                    output.source = 'uniswap';
+                    output.sellAsset.caip = quote.sellAsset;
+                    output.sellAmount = quote.sellAmount;
+                    output.buyAsset = {};
+                    output.buyAsset.caip = quote.buyAsset;
+                    inputChain = caipToNetworkId(quote.sellAsset);
+                    outputChain = caipToNetworkId(quote.buyAsset);
+                    if (inputChain != outputChain)
+                        throw new Error("Cross Chain not supported");
+                    log.info("inputChain: ", inputChain);
+                    providerUrl = EIP155_MAINNET_CHAINS[inputChain].rpc;
+                    if (!providerUrl)
+                        throw new Error("missing providerUrl");
+                    log.info("providerUrl: ", providerUrl);
+                    chainIdInt = parseInt(inputChain.replace('eip155:', ''));
+                    log.info(tag, "chainIdInt: ", chainIdInt);
+                    chainId = chainIdInt;
+                    provider = new ethers.providers.JsonRpcProvider(providerUrl);
+                    sellTokenContract = void 0, buyTokenContract = void 0;
+                    BUY_TOKEN = void 0, SELL_TOKEN = void 0;
+                    BUY_TOKEN_ADDRESS = void 0, SELL_TOKEN_ADDRESS = void 0;
+                    if (!(quote.buyAsset.indexOf('erc20') > -1)) return [3 /*break*/, 5];
+                    buyTokenAddress = quote.buyAsset.split(":")[2].toLowerCase();
+                    BUY_TOKEN_ADDRESS = buyTokenAddress;
+                    log.info("buyTokenAddress: ", buyTokenAddress);
+                    buyTokenContract = new ethers.Contract(buyTokenAddress.toLowerCase(), ERC20_ABI, provider);
+                    return [4 /*yield*/, buyTokenContract.symbol()];
+                case 2:
+                    symbolBuy = _b.sent();
+                    return [4 /*yield*/, buyTokenContract.decimals()];
+                case 3:
+                    decimalsBuy = _b.sent();
+                    log.info("symbolBuy: ", symbolBuy);
+                    log.info("decimalsBuy: ", decimalsBuy);
+                    return [4 /*yield*/, buyTokenContract.balanceOf(quote.senderAddress)];
+                case 4:
+                    balance = _b.sent();
+                    log.info("balance: ", balance.toString());
+                    if (!symbolBuy)
+                        throw new Error("missing symbolBuy");
+                    if (!decimalsBuy)
+                        throw new Error("missing decimalsBuy");
+                    BUY_TOKEN = new sdk_core_1.Token(8453, buyTokenAddress, decimalsBuy, symbolBuy, symbolBuy.toLowerCase());
+                    log.info("BUY_TOKEN: ", BUY_TOKEN);
+                    return [3 /*break*/, 6];
+                case 5:
+                    BUY_TOKEN = new sdk_core_1.Token(8453, '0x4200000000000000000000000000000000000006', 18, 'WETH');
+                    BUY_TOKEN_ADDRESS = '0x4200000000000000000000000000000000000006';
+                    log.info("BUY_TOKEN: ", BUY_TOKEN);
+                    _b.label = 6;
+                case 6:
+                    if (!(quote.sellAsset.indexOf('erc20') > -1)) return [3 /*break*/, 9];
+                    sellTokenAddress = quote.sellAsset.split(":")[2].toLowerCase();
+                    SELL_TOKEN_ADDRESS = sellTokenAddress;
+                    log.info("sellTokenAddress: ", sellTokenAddress);
+                    sellTokenContract = new ethers.Contract(sellTokenAddress, ERC20_ABI, provider);
+                    return [4 /*yield*/, sellTokenContract.symbol()];
+                case 7:
+                    symbolSell = _b.sent();
+                    return [4 /*yield*/, sellTokenContract.decimals()];
+                case 8:
+                    decimalsSell = _b.sent();
+                    if (!symbolSell)
+                        throw new Error("missing symbolSell");
+                    if (!decimalsSell)
+                        throw new Error("missing decimalsSell");
+                    SELL_TOKEN = new sdk_core_1.Token(8453, sellTokenAddress, decimalsSell, symbolSell, symbolSell.toLowerCase());
+                    log.info("SELL_TOKEN: ", SELL_TOKEN);
+                    return [3 /*break*/, 10];
+                case 9:
+                    //WETH
+                    SELL_TOKEN = new sdk_core_1.Token(8453, '0x4200000000000000000000000000000000000006', 18, 'WETH');
+                    SELL_TOKEN_ADDRESS = '0x4200000000000000000000000000000000000006';
+                    _b.label = 10;
+                case 10:
+                    inputPRO = ethers_1.utils.parseUnits(quote.sellAmount, 18).toString();
+                    spender = EIP155_MAINNET_CHAINS['eip155:' + chainId].universalRouter;
+                    return [4 /*yield*/, sellTokenContract.allowance(from, spender)];
+                case 11:
+                    allowance = _b.sent();
+                    log.info(tag, "inputPRO: ", inputPRO.toString());
+                    log.info(tag, "allowance: ", allowance.toString());
+                    if (allowance.lt(inputPRO)) {
+                        log.info(tag, "allowance is less than sellAmount, approving...");
+                        // build approval tx
+                        throw Error('TODO APPROVE TOKENS');
+                    }
+                    FEE_AMOUNT = v3_sdk_1.FeeAmount.MEDIUM;
+                    args = {
+                        tokenInAddress: SELL_TOKEN_ADDRESS,
+                        tokenInDecimals: SELL_TOKEN.decimals,
+                        tokenInChainId: chainIdInt,
+                        tokenOutAddress: BUY_TOKEN_ADDRESS,
+                        tokenOutChainId: chainIdInt,
+                        tokenOutDecimals: BUY_TOKEN.decimals,
+                        amount: inputPRO,
+                        tradeType: 'EXACT_INPUT',
+                        sendPortionEnabled: false,
+                    };
+                    Protocol = void 0;
+                    (function (Protocol) {
+                        Protocol["V2"] = "V2";
+                        Protocol["V3"] = "V3";
+                        Protocol["MIXED"] = "MIXED";
+                    })(Protocol || (Protocol = {}));
+                    QuoteIntent = void 0;
+                    (function (QuoteIntent) {
+                        QuoteIntent["Pricing"] = "pricing";
+                        QuoteIntent["Quote"] = "quote";
+                    })(QuoteIntent || (QuoteIntent = {}));
+                    CLIENT_PARAMS = {
+                        protocols: [Protocol.V2, Protocol.V3, Protocol.MIXED],
+                    };
+                    router = (0, clientSideSmartOrderRouter_1.getRouter)(args.tokenInChainId);
+                    // log.info(tag,'router: ',router)
+                    log.info(tag, 'args: ', args);
+                    return [4 /*yield*/, (0, clientSideSmartOrderRouter_1.getClientSideQuote)(args, router, CLIENT_PARAMS)];
+                case 12:
+                    quoteResult = _b.sent();
+                    log.info(tag, 'quoteResult: ', quoteResult);
+                    if (!quoteResult)
+                        throw Error("quoteResult is undefined");
+                    return [4 /*yield*/, transformQuoteToTrade(args, quoteResult.data, QuoteMethod.CLIENT_SIDE_FALLBACK)];
+                case 13:
+                    trade = _b.sent();
+                    if (!trade)
+                        throw Error("trade is undefined");
+                    log.info(tag, 'trade: ', trade);
+                    permit = {
+                        details: {
+                            token: quote.sellAsset.split(":")[2].toLowerCase(),
+                            amount: '1000000000000000000000000',
+                            expiration: toDeadline(PERMIT_EXPIRATION),
+                            nonce: 0,
+                        },
+                        spender: EIP155_MAINNET_CHAINS['eip155:' + chainId].universalRouter,
+                        sigDeadline: toDeadline(PERMIT_SIG_EXPIRATION),
+                        signature: quote.permit2
+                    };
+                    _a = universal_router_sdk_1.SwapRouter.swapERC20CallParameters(trade, {
+                        // recipient: from,
+                        // @ts-ignore
+                        slippageTolerance: slippageTolerance,
+                        // deadlineOrPreviousBlockhash: deadline,
+                        // inputTokenPermit: undefined,
+                        // @ts-ignore
+                        inputTokenPermit: permit,
+                        // fee: options.feeOptions,
+                    }), calldata = _a.calldata, value = _a.value;
+                    log.info("calldata: ", calldata);
+                    log.info("value: ", value);
+                    return [4 /*yield*/, provider.getTransactionCount(from, "latest")];
+                case 14:
+                    nonce = _b.sent();
+                    log.info("nonce: ", nonce);
+                    gas = "0x".concat(BigInt("935120").toString(16)) // 935120
+                    ;
+                    return [4 /*yield*/, provider.getGasPrice()];
+                case 15:
+                    gasPrice = _b.sent();
+                    log.info("gasPrice: ", gasPrice.toString());
+                    adjustedGasPrice = gasPrice.mul(ethers.BigNumber.from(110)).div(ethers.BigNumber.from(100));
+                    isZero = function isZero(hexNumberString) {
+                        return hexNumberString === '0' || /^0x0*$/.test(hexNumberString);
+                    };
+                    tx = __assign(__assign({ from: from, to: EIP155_MAINNET_CHAINS['eip155:' + chainId].universalRouter, chainId: chainId, data: calldata }, (value && !isZero(value) ? { value: (0, v3_sdk_1.toHex)(value) } : {})), { gas: gas, gasPrice: (0, v3_sdk_1.toHex)(adjustedGasPrice), nonce: (0, v3_sdk_1.toHex)(nonce) });
+                    output.txs.push({
+                        type: "evm",
+                        description: 'swap tokens',
+                        chain: inputChain,
+                        txParams: tx
+                    });
+                    output.meta = {
+                        quoteMode: "ERC20-ERC20"
+                    };
+                    output.steps = 1;
+                    output.complete = true;
+                    output.type = 'EVM';
+                    output.id = uuid();
+                    return [2 /*return*/, output];
+                case 16:
+                    e_2 = _b.sent();
+                    console.error(e_2);
+                    return [3 /*break*/, 17];
+                case 17: return [2 /*return*/];
+            }
+        });
+    });
+};
+var get_quote_api = function (quote) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, output, from, recipient, inputChain, outputChain, providerUrl, chainIdInt, chainId, provider, sellTokenContract, buyTokenContract, BUY_TOKEN, SELL_TOKEN, BUY_TOKEN_ADDRESS, SELL_TOKEN_ADDRESS, buyTokenAddress, symbolBuy, decimalsBuy, balance, sellTokenAddress, symbolSell, decimalsSell, FEE_AMOUNT, inputPRO, args, Protocol, QuoteIntent, CLIENT_PARAMS, tokenIn, tokenInChainId, tokenOut, tokenOutChainId, amount, tradeType, sendPortionEnabled, requestBody, response, uraQuoteResponse, calldata, value, nonce, gas, gasPrice, adjustedGasPrice, isZero, tx, e_3;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -139,11 +854,18 @@ var get_quote = function (quote) {
                         throw new Error("missing recipientAddress");
                     if (!quote.slippage)
                         throw new Error("missing slippage");
+                    if (!networkSupport.includes(caipToNetworkId(quote.buyAsset))) {
+                        throw new Error("unsupported buyAsset");
+                    }
+                    if (!networkSupport.includes(caipToNetworkId(quote.sellAsset))) {
+                        throw new Error("unsupported sellAsset");
+                    }
                     // if(!quote.permit2) throw new Error("missing permit2, required for uniswap")
                     output.txs = [];
                     from = quote.senderAddress;
                     recipient = quote.recipientAddress;
                     output.sellAsset = {};
+                    output.source = 'uniswap';
                     output.sellAsset.caip = quote.sellAsset;
                     output.sellAmount = quote.sellAmount;
                     output.buyAsset = {};
@@ -214,7 +936,7 @@ var get_quote = function (quote) {
                         tokenOutChainId: chainIdInt,
                         amount: "10000000000000000000",
                         tradeType: 'EXACT_INPUT',
-                        sendPortionEnabled: false,
+                        sendPortionEnabled: true,
                     };
                     Protocol = void 0;
                     (function (Protocol) {
@@ -254,6 +976,9 @@ var get_quote = function (quote) {
                             }
                         ],
                     };
+                    // const UNISWAP_GATEWAY_DNS_URL = 'https://interface.gateway.uniswap.org/v2'
+                    log.info("requestBody: ", requestBody);
+                    log.info("requestBody: ", JSON.stringify(requestBody));
                     return [4 /*yield*/, (0, axios_1.default)({
                             method: 'POST',
                             url: 'https://interface.gateway.uniswap.org/v2/quote',
@@ -310,9 +1035,9 @@ var get_quote = function (quote) {
                     output.type = 'EVM';
                     return [2 /*return*/, output];
                 case 14:
-                    e_1 = _a.sent();
-                    console.error(tag, "e: ", e_1);
-                    throw e_1;
+                    e_3 = _a.sent();
+                    console.error(tag, "e: ", e_3);
+                    throw e_3;
                 case 15: return [2 /*return*/];
             }
         });

package/lib/routing/clientSideSmartOrderRouter.js

@@ -88,20 +88,35 @@ function getQuote(_a, router, routerConfig) {
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
+                    console.log("Checkpoint: getQuote");
                     tokenInIsNative = Object.values(types_1.SwapRouterNativeAssets).includes(tokenIn.address);
                     tokenOutIsNative = Object.values(types_1.SwapRouterNativeAssets).includes(tokenOut.address);
-                    currencyIn = tokenInIsNative
-                        ? (0, tokens_1.nativeOnChain)(tokenIn.chainId)
-                        : new sdk_core_1.Token(tokenIn.chainId, tokenIn.address, tokenIn.decimals, tokenIn.symbol);
-                    currencyOut = tokenOutIsNative
-                        ? (0, tokens_1.nativeOnChain)(tokenOut.chainId)
-                        : new sdk_core_1.Token(tokenOut.chainId, tokenOut.address, tokenOut.decimals, tokenOut.symbol);
+                    console.log("Checkpoint: getQuote2");
+                    if (tokenInIsNative) {
+                        console.log("Checkpoint: tokenInIsNative");
+                        currencyIn = (0, tokens_1.nativeOnChain)(tokenIn.chainId); // Use the native token for the chain if tokenIn is native
+                    }
+                    else {
+                        console.log("Checkpoint: !tokenInIsNative tokenIn: ", tokenIn);
+                        currencyIn = new sdk_core_1.Token(tokenIn.chainId, tokenIn.address, tokenIn.decimals, tokenIn.symbol); // Otherwise, create a new token
+                    }
+                    if (tokenOutIsNative) {
+                        console.log("Checkpoint: tokenOutIsNative");
+                        currencyOut = (0, tokens_1.nativeOnChain)(tokenOut.chainId); // Use the native token for the chain if tokenOut is native
+                    }
+                    else {
+                        console.log("Checkpoint: !tokenOutIsNative");
+                        currencyOut = new sdk_core_1.Token(tokenOut.chainId, tokenOut.address, tokenOut.decimals, tokenOut.symbol); // Otherwise, create a new token
+                    }
                     baseCurrency = tradeType === sdk_core_1.TradeType.EXACT_INPUT ? currencyIn : currencyOut;
                     quoteCurrency = tradeType === sdk_core_1.TradeType.EXACT_INPUT ? currencyOut : currencyIn;
+                    console.log("baseCurrency", baseCurrency);
+                    console.log("quoteCurrency", quoteCurrency);
                     amount = sdk_core_1.CurrencyAmount.fromRawAmount(baseCurrency, jsbi_1.default.BigInt(amountRaw));
                     return [4 /*yield*/, router.route(amount, quoteCurrency, tradeType, /*swapConfig=*/ undefined, routerConfig)];
                 case 1:
                     swapRoute = _b.sent();
+                    console.log("swapRoute", swapRoute);
                     if (!swapRoute) {
                         return [2 /*return*/, { state: types_1.QuoteState.NOT_FOUND }];
                     }

package/lib/rpc/ConfiguredJsonRpcProvider.d.ts

@@ -4,5 +4,5 @@ import { SupportedInterfaceChain } from '../constants/chains';
 export default class ConfiguredJsonRpcProvider extends StaticJsonRpcProvider {
     constructor(url: string | undefined, networkish: Networkish & {
         chainId: SupportedInterfaceChain;
-    }, pollingInterval?: any);
+    }, pollingInterval?: number);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/uniswap-client",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "dependencies": {
@@ -9,6 +9,7 @@
     "@pioneer-platform/maya-network": "^8.3.7",
     "@pioneer-platform/pioneer-caip": "^9.2.23",
     "@pioneer-platform/pioneer-coins": "^9.2.13",
+    "@pioneer-platform/pioneer-discovery": "^0.0.7",
     "@types/ms": "^0.7.34",
     "@types/ms.macro": "^2.0.2",
     "@uniswap/router-sdk": "1.9.0",
@@ -30,6 +31,7 @@
   "scripts": {
     "npm": "npm i",
     "test": "npm run build && node __tests__/test-module.js",
+    "test-sdk": "npm run build && node __tests__/test-module-sdk.js",
     "build": "tsc -p .",
     "prepublish": "npm run build",
     "refresh": "rm -rf ./node_modules ./package-lock.json && npm install"