@pioneer-platform/uniswap-client 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,38 @@
+export declare const MAX_UINT = "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+export declare const MAX_UINT160 = "0xffffffffffffffffffffffffffffffffffffffff";
+export declare const DEADLINE = 2000000000;
+export declare const CONTRACT_BALANCE = "0x8000000000000000000000000000000000000000000000000000000000000000";
+export declare const ALREADY_PAID = 0;
+export declare const ALICE_ADDRESS = "0x28c6c06298d514db089934071355e5743bf21d60";
+export declare const ETH_ADDRESS: any;
+export declare const ZERO_ADDRESS: any;
+export declare const ONE_PERCENT_BIPS = 100;
+export declare const MSG_SENDER: string;
+export declare const ADDRESS_THIS: string;
+export declare const SOURCE_MSG_SENDER: boolean;
+export declare const SOURCE_ROUTER: boolean;
+export declare const OPENSEA_CONDUIT = "0x1E0049783F008A0085193E00003D00cd54003c71";
+export declare const OPENSEA_CONDUIT_KEY = "0x0000007b02230091a7ed01230072f7006a004d60a8d4e71d599b8104250f0000";
+export declare const COVEN_ADDRESS = "0x5180db8f5c931aae63c74266b211f580155ecac8";
+export declare const DECENTRA_DRAGON_ADDRESS = "0xAA107cCFe230a29C345Fd97bc6eb9Bd2fccD0750";
+export declare const TOWNSTAR_ADDRESS = "0xc36cF0cFcb5d905B8B513860dB0CFE63F6Cf9F5c";
+export declare const TWERKY_ADDRESS = "0xf4680c917a873e2dd6ead72f9f433e74eb9c623c";
+export declare const MILADY_ADDRESS = "0x5af0d9827e0c53e4799bb226655a1de152a425a5";
+export declare const ALPHABETTIES_ADDRESS = "0x6d05064fe99e40f1c3464e7310a23ffaded56e20";
+export declare const MENTAL_WORLDS_ADDRESS = "0xEf96021Af16BD04918b0d87cE045d7984ad6c38c";
+export declare const CAMEO_ADDRESS = "0x93317E87a3a47821803CAADC54Ae418Af80603DA";
+export declare const ENS_NFT_ADDRESS = "0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85";
+export declare const CRYPTOPUNKS_MARKET_ADDRESS = "0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB";
+export declare const NFTX_COVEN_VAULT = "0xd89b16331f39ab3878daf395052851d3ac8cf3cd";
+export declare const NFTX_COVEN_VAULT_ID = "333";
+export declare const NFTX_MILADY_VAULT = "0x227c7df69d3ed1ae7574a1a7685fded90292eb48";
+export declare const NFTX_MILADY_VAULT_ID = "392";
+export declare const NFTX_ERC_1155_VAULT = "0x78e09c5ec42d505742a52fd10078a57ea186002a";
+export declare const NFTX_ERC_1155_VAULT_ID = "61";
+export declare const V2_FACTORY_MAINNET = "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f";
+export declare const V3_FACTORY_MAINNET = "0x1F98431c8aD98523631AE4a59f267346ea31F984";
+export declare const V3_INIT_CODE_HASH_MAINNET = "0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54";
+export declare const V2_INIT_CODE_HASH_MAINNET = "0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f";
+export declare const ROUTER_REWARDS_DISTRIBUTOR = "0x0000000000000000000000000000000000000000";
+export declare const LOOKSRARE_REWARDS_DISTRIBUTOR = "0x0554f068365eD43dcC98dcd7Fd7A8208a5638C72";
+export declare const LOOKSRARE_TOKEN = "0xf4d2888d29D722226FafA5d9B24F9164c092421E";

package/lib/index.js

@@ -0,0 +1,492 @@
+"use strict";
+/*
+        Uniswap Integration
+                - Highlander
+
+    BASE
+    https://docs.base.org/contracts/
+
+
+
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOOKSRARE_TOKEN = exports.LOOKSRARE_REWARDS_DISTRIBUTOR = exports.ROUTER_REWARDS_DISTRIBUTOR = exports.V2_INIT_CODE_HASH_MAINNET = exports.V3_INIT_CODE_HASH_MAINNET = exports.V3_FACTORY_MAINNET = exports.V2_FACTORY_MAINNET = exports.NFTX_ERC_1155_VAULT_ID = exports.NFTX_ERC_1155_VAULT = exports.NFTX_MILADY_VAULT_ID = exports.NFTX_MILADY_VAULT = exports.NFTX_COVEN_VAULT_ID = exports.NFTX_COVEN_VAULT = exports.CRYPTOPUNKS_MARKET_ADDRESS = exports.ENS_NFT_ADDRESS = exports.CAMEO_ADDRESS = exports.MENTAL_WORLDS_ADDRESS = exports.ALPHABETTIES_ADDRESS = exports.MILADY_ADDRESS = exports.TWERKY_ADDRESS = exports.TOWNSTAR_ADDRESS = exports.DECENTRA_DRAGON_ADDRESS = exports.COVEN_ADDRESS = exports.OPENSEA_CONDUIT_KEY = exports.OPENSEA_CONDUIT = exports.SOURCE_ROUTER = exports.SOURCE_MSG_SENDER = exports.ADDRESS_THIS = exports.MSG_SENDER = exports.ONE_PERCENT_BIPS = exports.ZERO_ADDRESS = exports.ETH_ADDRESS = exports.ALICE_ADDRESS = exports.ALREADY_PAID = exports.CONTRACT_BALANCE = exports.DEADLINE = exports.MAX_UINT160 = exports.MAX_UINT = void 0;
+var TAG = " | Uniswap | ";
+var uuid = require('uuidv4').uuid;
+var log = require('@pioneer-platform/loggerdog')();
+var _a = require("@pioneer-platform/pioneer-caip"), caipToNetworkId = _a.caipToNetworkId, shortListSymbolToCaip = _a.shortListSymbolToCaip, ChainToNetworkId = _a.ChainToNetworkId;
+var _b = require('@pioneer-platform/pioneer-coins'), createMemo = _b.createMemo, parseMemo = _b.parseMemo;
+var _c = require('@uniswap/v2-sdk'), Pair = _c.Pair, WETH = _c.WETH, Route = _c.Route, Trade = _c.Trade, TokenAmount = _c.TokenAmount; // Import necessary components from v2-sdk
+var jsbi_1 = __importDefault(require("jsbi"));
+// import { ethers } from 'ethers'
+var sdk_core_1 = require("@uniswap/sdk-core");
+var v3_sdk_1 = require("@uniswap/v3-sdk");
+var router_sdk_1 = require("@uniswap/router-sdk");
+var universal_router_sdk_1 = require("@uniswap/universal-router-sdk");
+var ethers = require('ethers').ethers;
+var PERMIT2_BASE = '0x000000000022D473030F116dDEE9F6B43aC78BA3';
+// This file is lazy-loaded, so the import of smart-order-router is intentional.
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+var smart_order_router_1 = require("@uniswap/smart-order-router");
+//TODO - add all networks
+var networkSupport = [
+    ChainToNetworkId["ETH"],
+    ChainToNetworkId["BASE"],
+];
+var router_sdk_2 = require("@uniswap/router-sdk");
+var protocols = [router_sdk_2.Protocol.V2, router_sdk_2.Protocol.V3, router_sdk_2.Protocol.MIXED];
+module.exports = {
+    init: function (settings) {
+        return true;
+    },
+    networkSupport: function () {
+        return networkSupport;
+    },
+    getQuote: function (quote) {
+        return get_quote(quote);
+    },
+};
+// Router Helpers
+exports.MAX_UINT = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+exports.MAX_UINT160 = '0xffffffffffffffffffffffffffffffffffffffff';
+exports.DEADLINE = 2000000000;
+exports.CONTRACT_BALANCE = '0x8000000000000000000000000000000000000000000000000000000000000000';
+exports.ALREADY_PAID = 0;
+exports.ALICE_ADDRESS = '0x28c6c06298d514db089934071355e5743bf21d60';
+exports.ETH_ADDRESS = ethers.constants.AddressZero;
+exports.ZERO_ADDRESS = ethers.constants.AddressZero;
+exports.ONE_PERCENT_BIPS = 100;
+exports.MSG_SENDER = '0x0000000000000000000000000000000000000001';
+exports.ADDRESS_THIS = '0x0000000000000000000000000000000000000002';
+exports.SOURCE_MSG_SENDER = true;
+exports.SOURCE_ROUTER = false;
+// Protocol Data
+exports.OPENSEA_CONDUIT = '0x1E0049783F008A0085193E00003D00cd54003c71';
+exports.OPENSEA_CONDUIT_KEY = '0x0000007b02230091a7ed01230072f7006a004d60a8d4e71d599b8104250f0000';
+// NFT Addresses
+exports.COVEN_ADDRESS = '0x5180db8f5c931aae63c74266b211f580155ecac8';
+exports.DECENTRA_DRAGON_ADDRESS = '0xAA107cCFe230a29C345Fd97bc6eb9Bd2fccD0750';
+exports.TOWNSTAR_ADDRESS = '0xc36cF0cFcb5d905B8B513860dB0CFE63F6Cf9F5c';
+exports.TWERKY_ADDRESS = '0xf4680c917a873e2dd6ead72f9f433e74eb9c623c';
+exports.MILADY_ADDRESS = '0x5af0d9827e0c53e4799bb226655a1de152a425a5';
+exports.ALPHABETTIES_ADDRESS = '0x6d05064fe99e40f1c3464e7310a23ffaded56e20';
+exports.MENTAL_WORLDS_ADDRESS = '0xEf96021Af16BD04918b0d87cE045d7984ad6c38c';
+exports.CAMEO_ADDRESS = '0x93317E87a3a47821803CAADC54Ae418Af80603DA';
+exports.ENS_NFT_ADDRESS = '0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85';
+exports.CRYPTOPUNKS_MARKET_ADDRESS = '0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB';
+exports.NFTX_COVEN_VAULT = '0xd89b16331f39ab3878daf395052851d3ac8cf3cd';
+exports.NFTX_COVEN_VAULT_ID = '333';
+exports.NFTX_MILADY_VAULT = '0x227c7df69d3ed1ae7574a1a7685fded90292eb48';
+exports.NFTX_MILADY_VAULT_ID = '392';
+exports.NFTX_ERC_1155_VAULT = '0x78e09c5ec42d505742a52fd10078a57ea186002a';
+exports.NFTX_ERC_1155_VAULT_ID = '61';
+// Constructor Params
+exports.V2_FACTORY_MAINNET = '0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f';
+exports.V3_FACTORY_MAINNET = '0x1F98431c8aD98523631AE4a59f267346ea31F984';
+exports.V3_INIT_CODE_HASH_MAINNET = '0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54';
+exports.V2_INIT_CODE_HASH_MAINNET = '0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f';
+exports.ROUTER_REWARDS_DISTRIBUTOR = '0x0000000000000000000000000000000000000000';
+exports.LOOKSRARE_REWARDS_DISTRIBUTOR = '0x0554f068365eD43dcC98dcd7Fd7A8208a5638C72';
+exports.LOOKSRARE_TOKEN = '0xf4d2888d29D722226FafA5d9B24F9164c092421E';
+var BASE_UNIVERSIAL_ROUTER = {
+    "UniversalRouterV1_2": "0xeC8B0F7Ffe3ae75d7FfAb09429e3675bb63503e4",
+    "UniversalRouterV1_2_V2Support": "0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD",
+    "UnsupportedProtocol": "0x9E18Efb3BE848940b0C92D300504Fb08C287FE85"
+};
+var ETH_UNIVERSIAL_ROUTER = {
+    "UniversalRouter": "0xEf1c6E67703c7BD7107eed8303Fbe6EC2554BF6B",
+    "UniversalRouterV1_2": "0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD",
+    "UnsupportedProtocol": "0x76D631990d505E4e5b432EEDB852A60897824D68"
+};
+var BASE_CONTRACTS = {
+    Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+    UniversalRouter: "0x198EF79F1F515F02dFE9e3115eD9fC07183f02fC",
+    V3CoreFactory: "0x33128a8fC17869897dcE68Ed026d694621f6FDfD",
+    Multicall: "0x091e99cb1C49331a94dD62755D168E941AbD0693",
+    ProxyAdmin: "0x3334d83e224aF5ef9C2E7DDA7c7C98Efd9621fA9",
+    TickLens: "0x0CdeE061c75D43c82520eD998C23ac2991c9ac6d",
+    NftDescriptor: "0xF9d1077fd35670d4ACbD27af82652a8d84577d9F",
+    NonfungibleTokenPositionDescriptor: "0x4f225937EDc33EFD6109c4ceF7b560B2D6401009",
+    DescriptorProxy: "0x4615C383F85D0a2BbED973d83ccecf5CB7121463",
+    NonfungibleTokenPositionManager: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1",
+    V3Migrator: "0x23cF10b1ee3AdfCA73B0eF17C07F7577e7ACd2d7",
+    V3Staker: "0x42bE4D6527829FeFA1493e1fb9F3676d2425C3C1",
+    QuoterV2: "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a",
+    SwapRouter: "0x2626664c2603336E57B271c5C0b26F421741e481"
+};
+var EIP155_MAINNET_CHAINS = {
+    'eip155:1': {
+        chainId: 1,
+        WETH: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+        name: 'Ethereum',
+        logo: '/chain-logos/eip155-1.png',
+        rgb: '99, 125, 234',
+        permit2: universal_router_sdk_1.PERMIT2_ADDRESS,
+        rpc: 'https://eth.llamarpc.com',
+        namespace: 'eip155'
+    },
+    // 'eip155:43114': {
+    //     chainId: 43114,
+    //     name: 'Avalanche C-Chain',
+    //     logo: '/chain-logos/eip155-43113.png',
+    //     rgb: '232, 65, 66',
+    //     rpc: 'https://api.avax.network/ext/bc/C/rpc',
+    //     namespace: 'eip155'
+    // },
+    // 'eip155:137': {
+    //     chainId: 137,
+    //     name: 'Polygon',
+    //     logo: '/chain-logos/eip155-137.png',
+    //     rgb: '130, 71, 229',
+    //     rpc: 'https://polygon-rpc.com/',
+    //     namespace: 'eip155'
+    // },
+    // 'eip155:10': {
+    //     chainId: 10,
+    //     name: 'Optimism',
+    //     logo: '/chain-logos/eip155-10.png',
+    //     rgb: '235, 0, 25',
+    //     rpc: 'https://mainnet.optimism.io',
+    //     namespace: 'eip155'
+    // },
+    // 'eip155:324': {
+    //     chainId: 324,
+    //     name: 'zkSync Era',
+    //     logo: '/chain-logos/eip155-324.svg',
+    //     rgb: '242, 242, 242',
+    //     rpc: 'https://mainnet.era.zksync.io/',
+    //     namespace: 'eip155'
+    // },
+    'eip155:8453': {
+        chainId: 8453,
+        WETH: '0x4200000000000000000000000000000000000006',
+        name: 'Base',
+        logo: '/chain-logos/base.png',
+        rgb: '242, 242, 242',
+        permit2: BASE_CONTRACTS.Permit2,
+        rpc: 'https://mainnet.base.org',
+        namespace: 'eip155'
+    }
+};
+var ERC20_ABI = [
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function decimals() view returns (uint8)",
+    "function balanceOf(address owner) view returns (uint256)",
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function transfer(address to, uint256 amount) returns (bool)"
+];
+var routersCache = new WeakMap();
+function getRouter(chainId, provider) {
+    var routers = routersCache.get(provider) || {};
+    var cached = routers[chainId];
+    if (cached)
+        return cached;
+    // V2 is unsupported for chains other than mainnet.
+    // TODO(zzmp): Upstream to @uniswap/smart-order-router, exporting an enum of supported v2 chains for clarity.
+    var v2SubgraphProvider;
+    if (chainId !== sdk_core_1.ChainId.MAINNET) {
+        v2SubgraphProvider = new smart_order_router_1.StaticV2SubgraphProvider(chainId);
+    }
+    // V3 computes on-chain, so the quoter must have gas limits appropriate to the provider.
+    // Most defaults are fine, but polygon needs a lower gas limit.
+    // TODO(zzmp): Upstream to @uniswap/smart-order-router, possibly making this easier to modify
+    // (eg allowing configuration without an instance to avoid duplicating multicall2Provider).
+    var onChainQuoteProvider;
+    var multicall2Provider;
+    if ([sdk_core_1.ChainId.POLYGON, sdk_core_1.ChainId.POLYGON_MUMBAI].includes(chainId)) {
+        multicall2Provider = new smart_order_router_1.UniswapMulticallProvider(chainId, provider, 375000);
+        // See https://github.com/Uniswap/smart-order-router/blob/98c58bdee9981fd9ffac9e7d7a97b18302d5f77a/src/routers/alpha-router/alpha-router.ts#L464-L487
+        onChainQuoteProvider = new smart_order_router_1.OnChainQuoteProvider(chainId, provider, multicall2Provider, {
+            retries: 2,
+            minTimeout: 100,
+            maxTimeout: 1000,
+        }, {
+            multicallChunk: 10,
+            gasLimitPerCall: 5000000,
+            quoteMinSuccessRate: 0.1,
+        }, {
+            gasLimitOverride: 5000000,
+            multicallChunk: 5,
+        }, {
+            gasLimitOverride: 6250000,
+            multicallChunk: 4,
+        });
+    }
+    var router = new smart_order_router_1.AlphaRouter({ chainId: chainId, provider: provider, v2SubgraphProvider: v2SubgraphProvider, multicall2Provider: multicall2Provider, onChainQuoteProvider: onChainQuoteProvider });
+    routers[chainId] = router;
+    routersCache.set(provider, routers);
+    return router;
+}
+var SwapRouterNativeAssets;
+(function (SwapRouterNativeAssets) {
+    SwapRouterNativeAssets["MATIC"] = "MATIC";
+    SwapRouterNativeAssets["ETH"] = "ETH";
+})(SwapRouterNativeAssets || (SwapRouterNativeAssets = {}));
+// interface SwapOptions {
+//     slippageTolerance: Percent
+//     deadline?: BigNumber
+//     permit?: PermitSignature
+//     feeOptions?: FeeOptions
+// }
+var getRoute = function (_a) {
+    var sellToken = _a.sellToken, buyToken = _a.buyToken, chainId = _a.chainId, amountIn = _a.amountIn, provider = _a.provider;
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, router, amount, route, e_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    tag = " | getMinAmountOut | ";
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    log.info(tag, "sellToken: ", sellToken);
+                    log.info(tag, "buyToken: ", buyToken);
+                    router = getRouter(chainId, provider);
+                    amount = sdk_core_1.CurrencyAmount.fromRawAmount(buyToken, jsbi_1.default.BigInt(amountIn !== null && amountIn !== void 0 ? amountIn : '1')) // a null amountRaw should initialize the route
+                    ;
+                    log.info(tag, "amount: ", amount);
+                    return [4 /*yield*/, router.route(amount, sellToken, sdk_core_1.TradeType.EXACT_INPUT, /*swapConfig=*/ undefined, { protocols: protocols })];
+                case 2:
+                    route = _b.sent();
+                    log.info(tag, "route: ", route);
+                    return [2 /*return*/, route];
+                case 3:
+                    e_1 = _b.sent();
+                    console.error(tag, "Error in getMinAmountOut: ", e_1);
+                    throw e_1;
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+};
+var isZero = function isZero(hexNumberString) {
+    return hexNumberString === '0' || /^0x0*$/.test(hexNumberString);
+};
+var buildTx = function (_a) {
+    var trade = _a.trade, from = _a.from, chainId = _a.chainId;
+    return __awaiter(this, void 0, void 0, function () {
+        var BIPS_BASE, _b, data, value, tx;
+        return __generator(this, function (_c) {
+            try {
+                BIPS_BASE = jsbi_1.default.BigInt(10000);
+                _b = router_sdk_1.SwapRouter.swapCallParameters(trade, {
+                    // @ts-ignore
+                    slippageTolerance: new sdk_core_1.Percent(jsbi_1.default.BigInt(200), BIPS_BASE),
+                    // deadlineOrPreviousBlockhash: options.deadline?.toString(),
+                    // inputTokenPermit: options.permit,
+                    // fee: options.feeOptions,
+                }), data = _b.calldata, value = _b.value;
+                tx = __assign({ from: from, to: (0, universal_router_sdk_1.UNIVERSAL_ROUTER_ADDRESS)(chainId), data: data }, (value && !isZero(value) ? { value: (0, v3_sdk_1.toHex)(value) } : {}));
+                return [2 /*return*/, tx];
+            }
+            catch (e) {
+                console.error(e);
+            }
+            return [2 /*return*/];
+        });
+    });
+};
+var get_quote = function (quote) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, output, slippageTolerance, recipient, inputChain, outputChain, providerUrl, provider, sellTokenContract, buyTokenContract, buyTokenAddress_1, balance, sellTokenAddress_1, permit2, router, planner, sellAmountBigNumber, path, permit2Address, currentAllowance, _a, sellTokenAddress, buyTokenAddress, sellTokenDecimals, _b, buyTokenDecimals, _c, amountInBigNumber, chainIdInt, sellToken, buyToken, route, trade, amountOut, tx, e_2;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    tag = TAG + " | get_quote | ";
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 14, , 15]);
+                    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");
+                    slippageTolerance = quote.slippage;
+                    recipient = quote.recipientAddress;
+                    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);
+                    provider = new ethers.providers.JsonRpcProvider(providerUrl);
+                    sellTokenContract = void 0, buyTokenContract = void 0;
+                    if (!(quote.buyAsset.indexOf('erc20') > -1)) return [3 /*break*/, 3];
+                    buyTokenAddress_1 = quote.buyAsset.split(":")[2];
+                    log.info("buyTokenAddress: ", buyTokenAddress_1);
+                    buyTokenContract = new ethers.Contract(buyTokenAddress_1, ERC20_ABI, provider);
+                    return [4 /*yield*/, buyTokenContract.balanceOf(quote.senderAddress)];
+                case 2:
+                    balance = _d.sent();
+                    log.info("balance: ", balance.toString());
+                    _d.label = 3;
+                case 3:
+                    if (quote.sellAsset.indexOf('erc20') > -1) {
+                        sellTokenAddress_1 = quote.sellAsset.split(":")[2];
+                        log.info("sellTokenAddress: ", sellTokenAddress_1);
+                        sellTokenContract = new ethers.Contract(sellTokenAddress_1, ERC20_ABI, provider);
+                    }
+                    permit2 = universal_router_sdk_1.PERMIT2_ADDRESS;
+                    router = universal_router_sdk_1.UNIVERSAL_ROUTER_ADDRESS;
+                    planner = new universal_router_sdk_1.RoutePlanner();
+                    sellAmountBigNumber = ethers.utils.parseUnits(quote.sellAmount.toString(), 'ether');
+                    path = void 0;
+                    //build path
+                    if (sellTokenContract && !buyTokenContract) {
+                        path = [sellTokenContract.address, EIP155_MAINNET_CHAINS[inputChain].WETH];
+                    }
+                    else if (!sellTokenContract && buyTokenContract) {
+                        path = [EIP155_MAINNET_CHAINS[inputChain].WETH, buyTokenContract.address];
+                    }
+                    else if (sellTokenContract && buyTokenContract) {
+                        path = [sellTokenContract.address, buyTokenContract.address];
+                    }
+                    log.info("path: ", path);
+                    // @ts-ignore
+                    if ((path[0] !== undefined && path[1] !== undefined) && path[0] === path[1]) {
+                        throw new Error("Both tokens are the same");
+                    }
+                    if (!path)
+                        throw new Error("missing path");
+                    if (!sellTokenContract) return [3 /*break*/, 5];
+                    permit2Address = EIP155_MAINNET_CHAINS[inputChain].permit2;
+                    if (!permit2Address)
+                        throw new Error("missing permit2Address for chain: " + inputChain);
+                    console.log("sellTokenContract: ", sellTokenContract.toString());
+                    return [4 /*yield*/, sellTokenContract.allowance(quote.senderAddress, permit2Address)];
+                case 4:
+                    currentAllowance = _d.sent();
+                    console.log("currentAllowance: ", currentAllowance.toString());
+                    console.log("sellAmountBigNumber: ", sellAmountBigNumber.toString());
+                    if (currentAllowance.lt(sellAmountBigNumber)) {
+                        // Requesting approval: Setting allowance to Max UINT256 for simplicity
+                        throw Error("TODO write code for allowance!");
+                    }
+                    _d.label = 5;
+                case 5:
+                    _a = path.map(function (address) { return ethers.utils.getAddress(address); }), sellTokenAddress = _a[0], buyTokenAddress = _a[1];
+                    console.info("".concat(tag, " sellTokenAddress: ").concat(sellTokenAddress, ", buyTokenAddress: ").concat(buyTokenAddress));
+                    if (!(sellTokenAddress !== ethers.constants.AddressZero)) return [3 /*break*/, 7];
+                    return [4 /*yield*/, new ethers.Contract(sellTokenAddress, ERC20_ABI, provider).decimals()];
+                case 6:
+                    _b = _d.sent();
+                    return [3 /*break*/, 8];
+                case 7:
+                    _b = 18;
+                    _d.label = 8;
+                case 8:
+                    sellTokenDecimals = _b;
+                    if (!(buyTokenAddress !== ethers.constants.AddressZero)) return [3 /*break*/, 10];
+                    return [4 /*yield*/, new ethers.Contract(buyTokenAddress, ERC20_ABI, provider).decimals()];
+                case 9:
+                    _c = _d.sent();
+                    return [3 /*break*/, 11];
+                case 10:
+                    _c = 18;
+                    _d.label = 11;
+                case 11:
+                    buyTokenDecimals = _c;
+                    log.info("".concat(tag, " sellTokenDecimals: ").concat(sellTokenDecimals, ", buyTokenDecimals: ").concat(buyTokenDecimals));
+                    amountInBigNumber = ethers.utils.parseUnits(quote.sellAmount.toString(), sellTokenDecimals);
+                    log.info("".concat(tag, " amountInBigNumber: ").concat(amountInBigNumber.toString()));
+                    chainIdInt = parseInt(inputChain.replace('eip155:', ''));
+                    log.info(tag, "chainIdInt: ", chainIdInt);
+                    sellToken = sellTokenAddress === ethers.constants.AddressZero ?
+                        WETH[sdk_core_1.ChainId.MAINNET] : new sdk_core_1.Token(chainIdInt, sellTokenAddress, sellTokenDecimals);
+                    buyToken = buyTokenAddress === ethers.constants.AddressZero ?
+                        WETH[sdk_core_1.ChainId.MAINNET] : new sdk_core_1.Token(chainIdInt, buyTokenAddress, buyTokenDecimals);
+                    return [4 /*yield*/, getRoute({
+                            sellToken: sellToken,
+                            buyToken: buyToken,
+                            chainId: chainIdInt,
+                            amountIn: amountInBigNumber,
+                            provider: provider
+                        })];
+                case 12:
+                    route = _d.sent();
+                    console.log("route: ", route);
+                    if (!route)
+                        throw new Error("missing route, failed to find route");
+                    trade = route.trade;
+                    log.info(tag, "trade: ", trade);
+                    amountOut = trade.swaps[0].outputAmount;
+                    log.info(tag, "amountOut: ", amountOut);
+                    output.amountOut = amountOut.toFixed(18);
+                    return [4 /*yield*/, buildTx({ trade: trade, from: quote.senderAddress, chainId: chainIdInt })];
+                case 13:
+                    tx = _d.sent();
+                    log.info(tag, "tx: ", tx);
+                    output.type = 'EVM';
+                    output.id = uuid();
+                    output.tx = tx;
+                    return [2 /*return*/, output];
+                case 14:
+                    e_2 = _d.sent();
+                    console.error(tag, "e: ", e_2);
+                    throw e_2;
+                case 15: return [2 /*return*/];
+            }
+        });
+    });
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@pioneer-platform/uniswap-client",
+  "version": "0.0.1",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "dependencies": {
+    "@pioneer-platform/loggerdog": "^8.3.1",
+    "@pioneer-platform/maya-network": "^8.3.7",
+    "@pioneer-platform/pioneer-caip": "^9.2.23",
+    "@pioneer-platform/pioneer-coins": "^9.2.13",
+    "@uniswap/sdk": "^3.0.3",
+    "@uniswap/sdk-core": "^4.0.7",
+    "@uniswap/smart-order-router": "^3.16.25",
+    "@uniswap/token-lists": "^1.0.0-beta.34",
+    "@uniswap/v2-sdk": "^3.2.1",
+    "@uniswap/v3-sdk": "^3.10.0",
+    "axios": "^1.3.4",
+    "dotenv": "^8.2.0",
+    "jsbi": "^4.3.0",
+    "rango-sdk": "^0.1.45",
+    "uuidv4": "^6.2.13"
+  },
+  "scripts": {
+    "npm": "npm i",
+    "test": "npm run build && node __tests__/test-module.js",
+    "build": "tsc -p .",
+    "prepublish": "npm run build",
+    "refresh": "rm -rf ./node_modules ./package-lock.json && npm install"
+  },
+  "devDependencies": {
+    "@types/async-retry": "^1.4.8",
+    "@types/bunyan": "^1.8.11",
+    "@types/jest": "^25.2.3",
+    "@types/node": "^13.13.21",
+    "@types/source-map-support": "^0.5.3",
+    "jest": "^26.4.2",
+    "onchange": "^7.0.2",
+    "serve": "^11.3.2",
+    "ts-jest": "^29.0.5",
+    "typescript": "^5.0.2"
+  },
+  "gitHead": "a76012f6693a12181c4744e53e977a9eaeef0ed3"
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "lib": ["es6", "es2015", "dom"],
+    "declaration": true,
+    "outDir": "lib",
+    "rootDir": "src",
+    "strict": true,
+    "types": ["node"],
+    "esModuleInterop": true,
+    "resolveJsonModule": true
+  }
+}