butterjs-sdk/dist/utils/requestUtils.js

Butter Network SDK

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.assembleNearVersionTargetSwapParamArrayFromRoutes = exports.assembleNearSwapParamArrayFromRoutes = exports.assembleNearSwapMsgFromRoute = exports.assembleNearSwapDataFromRoute = exports.assembleCrossChainRouteFromJson = exports.assembleEVMSwapDataFromRoute = exports.assembleTargetSwapDataFromRoute = exports.assembleSrcSwapDataFromRoute = exports.assembleButterRouterParamFromRoute = void 0;
const ethers_1 = require("ethers");
const constants_1 = require("../constants");
const addressUtil_1 = require("./addressUtil");
const constants_2 = require("../constants/constants");
const routeUtil_1 = require("./routeUtil");
const abi = ethers_1.ethers.utils.defaultAbiCoder;
async function assembleButterRouterParamFromRoute(routes, amount, fromChainId, targetChainTokenOut, toAddress) {
    const targetSwapData = await assembleTargetSwapDataFromRoute(routes, targetChainTokenOut);
    const tokenIn = routes.srcChain[0].tokenIn;
    const tokenOut = routes.srcChain[0].tokenOut;
    const butterRouterAddress = constants_1.BUTTER_ROUTER_ADDRESS_SET[(0, constants_1.ID_TO_CHAIN_ID)(fromChainId)];
    const coreSwapData = await assembleSrcSwapDataFromRoute(routes, tokenIn.address, tokenOut.address, butterRouterAddress);
    const toChainId = targetChainTokenOut.chainId;
    return {
        coreSwapData: coreSwapData,
        targetSwapData: targetSwapData,
        amount: amount,
        toChainId: toChainId,
        toAddress: toAddress,
    };
}
exports.assembleButterRouterParamFromRoute = assembleButterRouterParamFromRoute;
async function assembleSrcSwapDataFromRoute(route, tokenIn, tokenOut, toAddress) {
    const srcRoute = route.srcChain;
    let amountInArr = [];
    let paramsArr = [];
    let routerIndexArr = [];
    for (let swapRoute of srcRoute) {
        amountInArr.push(swapRoute.amountIn);
        const routerIndex = (0, routeUtil_1.getRouterIndexByChainIdAndDexName)(swapRoute.chainId, swapRoute.dexName);
        if (routerIndex === undefined) {
            throw new Error('assembleSrcSwapDataFromRoute: routerIndex is undefined');
        }
        routerIndexArr.push(routerIndex.toString());
        const amountIn = swapRoute.amountIn;
        const amountOut = swapRoute.amountOut;
        let tokenAddressArr = [];
        for (let i = 0; i < swapRoute.path.length; i++) {
            const butterPath = swapRoute.path[i];
            if (i == 0) {
                tokenAddressArr.push(butterPath.tokenIn.address);
                tokenAddressArr.push(butterPath.tokenOut.address);
            }
            else {
                tokenAddressArr.push(butterPath.tokenOut.address);
            }
        }
        /**
         struct AccessParams {
      uint256[]  amountInArr;
      bytes[]    paramsArr;
      uint32[]  routerIndex;
      address[2]  inputOutAddre;  // 0 -input  1- Out
    }
         **/
        const coreParamAbi = [
            'uint256',
            'uint256',
            'address[]',
            'address',
            'uint256',
            'address',
            'address',
        ];
        paramsArr.push(abi.encode(coreParamAbi, [
            amountIn,
            amountOut,
            tokenAddressArr,
            toAddress,
            (Math.floor(Date.now() / 1000) + 1000).toString(),
            tokenIn,
            tokenOut,
        ]));
    }
    return {
        amountInArr: amountInArr,
        paramsArr: paramsArr,
        routerIndex: routerIndexArr,
        inputOutAddre: [tokenIn, tokenOut],
    };
}
exports.assembleSrcSwapDataFromRoute = assembleSrcSwapDataFromRoute;
async function assembleTargetSwapDataFromRoute(routes, targetChainTokenOut, toAddress) {
    if ((0, constants_1.IS_EVM)(targetChainTokenOut.chainId)) {
        return await assembleEVMSwapDataFromRoute(routes, targetChainTokenOut);
    }
    else if ((0, constants_1.IS_NEAR)(targetChainTokenOut.chainId)) {
        return assembleNearSwapDataFromRoute(routes, targetChainTokenOut);
    }
    else {
        throw new Error(`chainId ${targetChainTokenOut.chainId} not supported`);
    }
}
exports.assembleTargetSwapDataFromRoute = assembleTargetSwapDataFromRoute;
const swapDataAbi = [
    'tuple(uint256, uint256, bytes, uint64)[]',
    'bytes',
    'address',
];
async function assembleEVMSwapDataFromRoute(route, targetChainTokenOut) {
    const mapRoute = route.mapChain;
    const mapTargetTokenAddress = mapRoute[0].tokenOut.address;
    let swapData = [];
    let swapParamArr = [];
    const targetRoute = route.targetChain;
    if (targetRoute === undefined ||
        targetRoute.length === 0 ||
        targetRoute[0].path === undefined ||
        targetRoute[0].path.length === 0) {
        swapData.push([]);
        swapData.push(targetChainTokenOut.address);
        swapData.push(mapTargetTokenAddress);
        return abi.encode(swapDataAbi, swapData);
    }
    for (let swapRoute of targetRoute) {
        let swapParam = [];
        swapParam.push(swapRoute.amountIn);
        swapParam.push(swapRoute.amountOut);
        const toChainId = swapRoute.chainId;
        let tokenAddressArr = [];
        for (let i = 0; i < swapRoute.path.length; i++) {
            const butterPath = swapRoute.path[i];
            if (i == 0) {
                tokenAddressArr.push((0, addressUtil_1.getHexAddress)(butterPath.tokenIn.address, toChainId, false));
                tokenAddressArr.push((0, addressUtil_1.getHexAddress)(butterPath.tokenOut.address, toChainId, false));
            }
            else {
                tokenAddressArr.push((0, addressUtil_1.getHexAddress)(butterPath.tokenOut.address, toChainId, false));
            }
        }
        // console.log('tokenAddressArr', tokenAddressArr);
        swapParam.push(abi.encode(['address[]'], [tokenAddressArr]));
        const routerIndex = (0, routeUtil_1.getRouterIndexByChainIdAndDexName)(swapRoute.chainId, swapRoute.dexName);
        if (routerIndex === undefined) {
            throw new Error('assembleSrcSwapDataFromRoute: routerIndex is undefined');
        }
        swapParam.push(routerIndex.toString());
        swapParamArr.push(swapParam);
    }
    swapData.push(swapParamArr);
    swapData.push(targetChainTokenOut.address);
    swapData.push(mapTargetTokenAddress);
    console.log('swap Data', swapData);
    return abi.encode(swapDataAbi, swapData);
}
exports.assembleEVMSwapDataFromRoute = assembleEVMSwapDataFromRoute;
function assembleCrossChainRouteFromJson(jsonStr, slippage) {
    let route = JSON.parse(jsonStr);
    if (route.srcChain != undefined) {
        for (let swapRoute of route.srcChain) {
            swapRoute.amountIn = ethers_1.ethers.utils
                .parseUnits(swapRoute.amountIn, swapRoute.tokenIn.decimals)
                .toString();
            swapRoute.amountOut = ethers_1.ethers.utils
                .parseUnits(swapRoute.amountOut, swapRoute.tokenOut.decimals)
                .mul(10000 - slippage)
                .div(10000)
                .toString();
        }
    }
    for (let swapRoute of route.mapChain) {
        swapRoute.amountIn = ethers_1.ethers.utils
            .parseUnits(swapRoute.amountIn, swapRoute.tokenIn.decimals)
            .toString();
        swapRoute.amountOut = ethers_1.ethers.utils
            .parseUnits(swapRoute.amountOut, swapRoute.tokenIn.decimals)
            .toString();
    }
    if (route.targetChain != undefined) {
        for (let swapRoute of route.targetChain) {
            swapRoute.amountIn = ethers_1.ethers.utils
                .parseUnits(swapRoute.amountIn, swapRoute.tokenIn.decimals)
                .toString();
            swapRoute.amountOut = ethers_1.ethers.utils
                .parseUnits(swapRoute.amountOut, swapRoute.tokenOut.decimals)
                .mul(10000 - slippage)
                .div(10000)
                .toString();
            // swapRoute.amountOut = '0';
        }
    }
    return route;
}
exports.assembleCrossChainRouteFromJson = assembleCrossChainRouteFromJson;
function assembleNearSwapDataFromRoute(routes, targetChainTokenOut) {
    const mapRoute = routes.mapChain;
    const mapTargetTokenAddress = mapRoute[0].tokenOut.address;
    let swapData = [];
    let swapParamArr = [];
    const targetRoute = routes.targetChain;
    if (targetRoute === undefined ||
        targetRoute.length === 0 ||
        targetRoute[0].path === undefined ||
        targetRoute[0].path.length === 0) {
        swapData.push([]);
        swapData.push((0, addressUtil_1.asciiToHex)(targetChainTokenOut.address, false));
        swapData.push(mapTargetTokenAddress);
        return abi.encode(swapDataAbi, swapData);
    }
    for (let swapRoute of targetRoute) {
        let swapParam = [];
        for (let i = 0; i < swapRoute.path.length; i++) {
            const butterPath = swapRoute.path[i];
            const path = butterPath.tokenIn.address +
                constants_2.NEAR_TOKEN_SEPARATOR +
                butterPath.tokenOut.address;
            const amountIn = 0;
            const minAmountOut = i === swapRoute.path.length - 1 ? swapRoute.amountOut : '0';
            const routerIndex = butterPath.id;
            swapParam.push(amountIn);
            swapParam.push(minAmountOut);
            swapParam.push((0, addressUtil_1.asciiToHex)(path, false));
            swapParam.push(routerIndex);
        }
        swapParamArr.push(swapParam);
    }
    swapData.push(swapParamArr);
    swapData.push((0, addressUtil_1.asciiToHex)(targetChainTokenOut.isNative
        ? targetChainTokenOut.wrapped.address
        : targetChainTokenOut.address, false));
    swapData.push(mapTargetTokenAddress);
    return abi.encode(swapDataAbi, swapData);
}
exports.assembleNearSwapDataFromRoute = assembleNearSwapDataFromRoute;
function assembleNearSwapMsgFromRoute(routes, fromToken, targetChainTokenOut, toAddress) {
    const toChainId = targetChainTokenOut.chainId;
    // assemble near source swap
    let srcSwap = assembleNearSwapParamArrayFromRoutes(routes.srcChain);
    const targetSwapData = {
        target_token: targetChainTokenOut.address,
        map_target_token: routes.mapChain[0].tokenOut.address,
    };
    targetSwapData.swap_param = assembleNearVersionTargetSwapParamArrayFromRoutes(routes.targetChain);
    const swapInfo = {
        src_swap: srcSwap,
        dst_swap: targetSwapData,
    };
    console.log('dst_swap', targetSwapData);
    if (fromToken.isNative) {
        return JSON.stringify(swapInfo);
    }
    let msg = {
        type: 'Swap',
        to: toAddress,
        to_chain: toChainId,
        swap_info: swapInfo,
    };
    return JSON.stringify(msg);
}
exports.assembleNearSwapMsgFromRoute = assembleNearSwapMsgFromRoute;
function assembleNearSwapParamArrayFromRoutes(routes) {
    let swapParamArray = [];
    for (let route of routes) {
        for (let i = 0; i < route.path.length; i++) {
            const path = route.path[i];
            swapParamArray.push({
                amount_in: '0',
                min_amount_out: i === route.path.length - 1 ? route.amountOut : '0',
                path: (0, addressUtil_1.asciiToHex)(path.tokenIn.address + constants_2.NEAR_TOKEN_SEPARATOR + path.tokenOut.address, false),
                router_index: path.id,
            });
        }
    }
    return swapParamArray;
}
exports.assembleNearSwapParamArrayFromRoutes = assembleNearSwapParamArrayFromRoutes;
function assembleNearVersionTargetSwapParamArrayFromRoutes(routes) {
    let swapParamArray = [];
    for (let route of routes) {
        let swapParam = {};
        swapParam.amount_in = route.amountIn;
        swapParam.min_amount_out = route.amountOut;
        const routerIndex = (0, routeUtil_1.getRouterIndexByChainIdAndDexName)(route.chainId, route.dexName);
        if (routerIndex === undefined) {
            throw new Error('assembleSrcSwapDataFromRoute: routerIndex is undefined');
        }
        swapParam.router_index = routerIndex.toString();
        let tokenArr = [];
        for (let i = 0; i < route.path.length; i++) {
            const path = route.path[i];
            if (i == 0) {
                tokenArr.push(path.tokenIn.address);
                tokenArr.push(path.tokenOut.address);
            }
            else {
                tokenArr.push(path.tokenOut.address);
            }
        }
        swapParam.path = abi.encode(['address[]'], [tokenArr]);
        swapParamArray.push(swapParam);
    }
    return swapParamArray;
}
exports.assembleNearVersionTargetSwapParamArrayFromRoutes = assembleNearVersionTargetSwapParamArrayFromRoutes;