@shapeshiftoss/swapper 20.3.0 → 20.5.0

package/dist/cjs/swappers/KyberSwapper/utils/fetchFromKyber.d.ts

@@ -0,0 +1,23 @@
+import type { Result } from '@sniptt/monads';
+import type { Address } from 'viem';
+import type { SwapErrorRight } from '../../../types';
+import type { KyberBuildData, KyberFeeParams, KyberRouteSummary } from '../types';
+import type { KyberSupportedChainId } from './constants';
+export declare const fetchKyberRoute: ({ chainId, tokenIn, tokenOut, sellAmountCryptoBaseUnit, feeParams, sendAddress, baseUrl, }: {
+    chainId: KyberSupportedChainId;
+    tokenIn: Address;
+    tokenOut: Address;
+    sellAmountCryptoBaseUnit: string;
+    feeParams: KyberFeeParams | undefined;
+    sendAddress: string | undefined;
+    baseUrl: string;
+}) => Promise<Result<KyberRouteSummary, SwapErrorRight>>;
+export declare const fetchKyberBuild: ({ chainId, route, slippageTolerancePercentageDecimal, baseUrl, sendAddress, receiveAddress, deadline, }: {
+    chainId: KyberSupportedChainId;
+    route: KyberRouteSummary;
+    slippageTolerancePercentageDecimal: string;
+    baseUrl: string;
+    sendAddress: string;
+    receiveAddress: string;
+    deadline: number;
+}) => Promise<Result<KyberBuildData, SwapErrorRight>>;

package/dist/cjs/swappers/KyberSwapper/utils/fetchFromKyber.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchKyberBuild = exports.fetchKyberRoute = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+const kyberService_1 = require("./kyberService");
+const fetchKyberRoute = async ({ chainId, tokenIn, tokenOut, sellAmountCryptoBaseUnit, feeParams, sendAddress, baseUrl, }) => {
+    const maybeResponse = await kyberService_1.kyberService.get(`${baseUrl}/${constants_1.KYBER_CHAINS[chainId]}/api/v1/routes`, {
+        params: {
+            tokenIn,
+            tokenOut,
+            amountIn: sellAmountCryptoBaseUnit,
+            ...(sendAddress ? { origin: sendAddress } : {}),
+            ...feeParams,
+        },
+    });
+    if (maybeResponse.isErr())
+        return (0, monads_1.Err)((0, helpers_1.getKyberRequestError)(maybeResponse.unwrapErr()));
+    return (0, helpers_1.validateKyberRoute)(maybeResponse.unwrap().data, feeParams);
+};
+exports.fetchKyberRoute = fetchKyberRoute;
+const fetchKyberBuild = async ({ chainId, route, slippageTolerancePercentageDecimal, baseUrl, sendAddress, receiveAddress, deadline, }) => {
+    const maybeResponse = await kyberService_1.kyberService.post(`${baseUrl}/${constants_1.KYBER_CHAINS[chainId]}/api/v1/route/build`, {
+        routeSummary: route,
+        sender: sendAddress,
+        recipient: receiveAddress,
+        origin: sendAddress,
+        slippageTolerance: (0, utils_1.convertDecimalPercentageToBasisPoints)(slippageTolerancePercentageDecimal).toNumber(),
+        deadline,
+        source: constants_1.KYBER_CLIENT_ID,
+    });
+    if (maybeResponse.isErr())
+        return (0, monads_1.Err)((0, helpers_1.getKyberRequestError)(maybeResponse.unwrapErr()));
+    return (0, helpers_1.validateKyberBuild)(maybeResponse.unwrap().data);
+};
+exports.fetchKyberBuild = fetchKyberBuild;

package/dist/cjs/swappers/KyberSwapper/utils/getKyberStepData.d.ts

@@ -0,0 +1,27 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types';
+import type { KyberBuildData, KyberRouteSummary } from '../types';
+type BaseArgs = {
+    sellAmountCryptoBaseUnit: string;
+    spenderAddress: string;
+    route: KyberRouteSummary;
+};
+export type GetKyberStepDataArgs = StepDataArgs<BaseArgs, {
+    build?: undefined;
+}, {
+    build: KyberBuildData;
+}>;
+type KyberRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type KyberQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getKyberStepData(args: Extract<GetKyberStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<KyberRateStepData, SwapErrorRight>>;
+export declare function getKyberStepData(args: Extract<GetKyberStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<KyberQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/cjs/swappers/KyberSwapper/utils/getKyberStepData.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKyberStepData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const utils_2 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+const constants_1 = require("./constants");
+async function getKyberStepData(args) {
+    const { sellAsset, sellAmountCryptoBaseUnit, spenderAddress, route, input, deps } = args;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    if (args.type === 'rate') {
+        const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmRateNetworkFeeCryptoBaseUnit)({
+            adapter,
+            supportsEIP1559,
+            providerGasLimit: route.gas,
+        }).catch(() => (0, utils_1.bnOrZero)(route.gas).times((0, utils_1.bnOrZero)(route.gasPrice)).toFixed(0));
+        const stepData = { networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    const { build, from } = args;
+    const transactionData = {
+        type: 'evm',
+        chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+        to: constants_1.KYBER_ROUTER_ADDRESS,
+        data: build.data,
+        value: build.transactionValue,
+    };
+    try {
+        const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+            adapter,
+            supportsEIP1559,
+            transactionData,
+            from,
+            stateOverride: { sellAsset, sellAmountCryptoBaseUnit, spenderAddress },
+            providerGasLimit: build.gas,
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getKyberStepData', error));
+    }
+}
+exports.getKyberStepData = getKyberStepData;

package/dist/cjs/swappers/KyberSwapper/utils/getKyberStepData.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/swappers/KyberSwapper/utils/getKyberStepData.test.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@shapeshiftoss/types");
+const vitest_1 = require("vitest");
+const assets_1 = require("../../../utils/test-data/assets");
+const constants_1 = require("./constants");
+const getKyberStepData_1 = require("./getKyberStepData");
+// The override path reads live chain state, so resolve to no override and hit the mocked adapter
+vitest_1.vi.mock('../../../utils/evm/stateOverride', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getMinimalStateOverride: vitest_1.vi.fn().mockResolvedValue(undefined),
+}));
+const HYPE = {
+    ...assets_1.ETH,
+    assetId: 'eip155:999/slip44:60',
+    chainId: types_1.KnownChainIds.HyperEvmMainnet,
+    symbol: 'HYPE',
+    name: 'HYPE',
+};
+const build = {
+    amountOut: '255332539',
+    gas: '679101',
+    data: '0xe21fd0e9',
+    routerAddress: '0x6131B5fae19EA4f9D964eAc0408E4408b66337b5',
+    transactionValue: '3000000000000000000',
+};
+const makeDeps = (adapter) => ({ assertGetEvmChainAdapter: () => adapter });
+const evmAdapter = ({ gasPrice = '1000000000', estimatedGasLimit = '500000', throwOnGasFeeData = false, throwOnFeeData = false, } = {}) => ({
+    getGasFeeData: () => {
+        if (throwOnGasFeeData)
+            return Promise.reject(new Error('rpc down'));
+        return Promise.resolve({ average: { gasPrice, maxFeePerGas: '0', maxPriorityFeePerGas: '0' } });
+    },
+    getFeeData: () => {
+        if (throwOnFeeData)
+            return Promise.reject(new Error('execution reverted'));
+        return Promise.resolve({
+            average: { chainSpecific: { gasLimit: estimatedGasLimit, gasPrice } },
+        });
+    },
+});
+const rateInput = { supportsEIP1559: false };
+const quoteInput = { supportsEIP1559: false };
+const baseArgs = {
+    sellAsset: HYPE,
+    sellAmountCryptoBaseUnit: '3000000000000000000',
+    spenderAddress: '',
+    route: { gas: '679101', gasPrice: '2000000000' },
+};
+(0, vitest_1.describe)('getKyberStepData', () => {
+    (0, vitest_1.it)('prices the provider gas limit for a rate', async () => {
+        const actual = await (0, getKyberStepData_1.getKyberStepData)({
+            ...baseArgs,
+            type: 'rate',
+            input: rateInput,
+            deps: makeDeps(evmAdapter()),
+        });
+        // gas 679101 * gasPrice 1000000000
+        (0, vitest_1.expect)(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '679101000000000' });
+    });
+    (0, vitest_1.it)('falls back to the provider gas price when rate pricing fails', async () => {
+        const actual = await (0, getKyberStepData_1.getKyberStepData)({
+            ...baseArgs,
+            type: 'rate',
+            input: rateInput,
+            deps: makeDeps(evmAdapter({ throwOnGasFeeData: true })),
+        });
+        // gas 679101 * provider gasPrice 2000000000
+        (0, vitest_1.expect)(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '1358202000000000' });
+    });
+    (0, vitest_1.it)('builds the router transaction and sets the buffered on chain estimate for a quote', async () => {
+        const actual = await (0, getKyberStepData_1.getKyberStepData)({
+            ...baseArgs,
+            type: 'quote',
+            input: quoteInput,
+            from: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+            build,
+            deps: makeDeps(evmAdapter({ estimatedGasLimit: '500000' })),
+        });
+        (0, vitest_1.expect)(actual.unwrap()).toEqual({
+            networkFeeCryptoBaseUnit: '600000000000000',
+            transactionData: {
+                type: 'evm',
+                chainId: 999,
+                to: constants_1.KYBER_ROUTER_ADDRESS,
+                data: build.data,
+                value: '3000000000000000000',
+                gasLimit: '600000',
+            },
+        });
+    });
+});

package/dist/cjs/swappers/KyberSwapper/utils/getKyberTradeContext.d.ts

@@ -0,0 +1,20 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { KyberRouteSummary, KyberTradeQuoteInput, KyberTradeRateInput } from '../types';
+import type { KyberSupportedChainId } from './constants';
+import type { GetKyberStepDataArgs } from './getKyberStepData';
+type KyberTradeContext = {
+    tradeCommon: TradeCommon & {
+        slippageTolerancePercentageDecimal: string;
+    };
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    chainId: KyberSupportedChainId;
+    route: KyberRouteSummary;
+    stepDataArgs: Omit<GetKyberStepDataArgs, 'type' | 'input' | 'from' | 'build'>;
+};
+export declare const getKyberTradeContext: ({ input, deps, }: {
+    input: KyberTradeQuoteInput | KyberTradeRateInput;
+    deps: SwapperDeps;
+}) => Promise<Result<KyberTradeContext, SwapErrorRight>>;
+export {};

package/dist/cjs/swappers/KyberSwapper/utils/getKyberTradeContext.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKyberTradeContext = void 0;
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const helpers_1 = require("../../../utils/helpers");
+const constants_2 = require("./constants");
+const fetchFromKyber_1 = require("./fetchFromKyber");
+const helpers_2 = require("./helpers");
+const getKyberTradeContext = async ({ input, deps, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, sendAddress, } = input;
+    const maybeChainId = (0, helpers_2.assertValidTrade)({ sellAsset, buyAsset });
+    if (maybeChainId.isErr())
+        return (0, monads_1.Err)(maybeChainId.unwrapErr());
+    const chainId = maybeChainId.unwrap();
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.KyberSwap);
+    const maybeRoute = await (0, fetchFromKyber_1.fetchKyberRoute)({
+        chainId,
+        tokenIn: (0, helpers_2.assetIdToKyberToken)(sellAsset.assetId),
+        tokenOut: (0, helpers_2.assetIdToKyberToken)(buyAsset.assetId),
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        feeParams: (0, helpers_2.getKyberFeeParams)({ chainId, affiliateBps }),
+        sendAddress,
+        baseUrl: deps.config.VITE_KYBER_BASE_URL,
+    });
+    if (maybeRoute.isErr())
+        return (0, monads_1.Err)(maybeRoute.unwrapErr());
+    const route = maybeRoute.unwrap();
+    const tradeAmounts = (0, helpers_2.getKyberTradeAmounts)({ input, amountOut: route.amountOut });
+    const allowanceContract = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) ? '' : constants_2.KYBER_ROUTER_ADDRESS;
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: (0, uuid_1.v4)(),
+            rate: tradeAmounts.rate,
+            swapperName: types_1.SwapperName.KyberSwap,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            estimatedExecutionTimeMs: 0,
+            allowanceContract,
+            sellAsset,
+            buyAsset,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            ...tradeAmounts,
+            source: types_1.SwapperName.KyberSwap,
+        },
+        protocolFees: {},
+        chainId,
+        route,
+        stepDataArgs: {
+            deps,
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            spenderAddress: allowanceContract,
+            route,
+        },
+    });
+};
+exports.getKyberTradeContext = getKyberTradeContext;

package/dist/cjs/swappers/KyberSwapper/utils/helpers.d.ts

@@ -0,0 +1,27 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { Address } from 'viem';
+import type { SwapErrorRight, TradeStepCommon } from '../../../types';
+import type { KyberBuildData, KyberBuildResponse, KyberFeeParams, KyberRoutesResponse, KyberRouteSummary, KyberTradeQuoteInput, KyberTradeRateInput } from '../types';
+import type { KyberSupportedChainId } from './constants';
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<KyberSupportedChainId, SwapErrorRight>;
+export declare const assetIdToKyberToken: (assetId: AssetId) => Address;
+export declare const getKyberFeeParams: ({ chainId, affiliateBps, }: {
+    chainId: KyberSupportedChainId;
+    affiliateBps: string;
+}) => KyberFeeParams | undefined;
+export declare const getKyberBuyAmountBeforeFees: ({ buyAmountAfterFeesCryptoBaseUnit, affiliateBps, }: {
+    buyAmountAfterFeesCryptoBaseUnit: string;
+    affiliateBps: string;
+}) => string;
+export declare const getKyberTradeAmounts: ({ input, amountOut, }: {
+    input: KyberTradeQuoteInput | KyberTradeRateInput;
+    amountOut: string;
+}) => Pick<TradeStepCommon, 'rate' | 'buyAmountBeforeFeesCryptoBaseUnit' | 'buyAmountAfterFeesCryptoBaseUnit' | 'affiliateFee'>;
+export declare const getKyberRequestError: (error: SwapErrorRight) => SwapErrorRight;
+export declare const validateKyberRoute: (response: KyberRoutesResponse, feeParams: KyberFeeParams | undefined) => Result<KyberRouteSummary, SwapErrorRight>;
+export declare const validateKyberBuild: (response: KyberBuildResponse) => Result<KyberBuildData, SwapErrorRight>;

package/dist/cjs/swappers/KyberSwapper/utils/helpers.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateKyberBuild = exports.validateKyberRoute = exports.getKyberRequestError = exports.getKyberTradeAmounts = exports.getKyberBuyAmountBeforeFees = exports.getKyberFeeParams = exports.assetIdToKyberToken = exports.assertValidTrade = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const axios_1 = __importDefault(require("axios"));
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const affiliateFee_1 = require("../../../utils/affiliateFee");
+const helpers_1 = require("../../../utils/helpers");
+const constants_1 = require("./constants");
+const isKyberSupportedChainId = (chainId) => chainId in constants_1.KYBER_CHAINS;
+const invalidResponse = (message, details) => (0, utils_2.makeSwapErrorRight)({ message, details, code: types_1.TradeQuoteError.InvalidResponse });
+const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (sellAsset.chainId !== buyAsset.chainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'KyberSwap does not support cross-chain trades',
+            code: types_1.TradeQuoteError.CrossChainNotSupported,
+        }));
+    }
+    if (!isKyberSupportedChainId(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'KyberSwap only supports configured EVM chains',
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return (0, monads_1.Ok)(sellAsset.chainId);
+};
+exports.assertValidTrade = assertValidTrade;
+const assetIdToKyberToken = (assetId) => (0, helpers_1.isNativeEvmAsset)(assetId) ? constants_1.KYBER_NATIVE_TOKEN : (0, viem_1.getAddress)((0, caip_1.fromAssetId)(assetId).assetReference);
+exports.assetIdToKyberToken = assetIdToKyberToken;
+const getKyberFeeParams = ({ chainId, affiliateBps, }) => {
+    if ((0, utils_1.bnOrZero)(affiliateBps).lte(0))
+        return undefined;
+    return {
+        feeAmount: affiliateBps,
+        chargeFeeBy: 'currency_out',
+        isInBps: true,
+        feeReceiver: (0, viem_1.getAddress)((0, helpers_1.getTreasuryAddressFromChainId)(chainId)),
+    };
+};
+exports.getKyberFeeParams = getKyberFeeParams;
+// Kyber only returns the post-fee amountOut; the inverse is at most one base unit off
+const getKyberBuyAmountBeforeFees = ({ buyAmountAfterFeesCryptoBaseUnit, affiliateBps, }) => {
+    if ((0, utils_1.bnOrZero)(affiliateBps).lte(0))
+        return buyAmountAfterFeesCryptoBaseUnit;
+    return (0, utils_1.bn)(buyAmountAfterFeesCryptoBaseUnit)
+        .times(10_000)
+        .div((0, utils_1.bn)(10_000).minus(affiliateBps))
+        .integerValue(utils_1.BigNumber.ROUND_DOWN)
+        .toFixed();
+};
+exports.getKyberBuyAmountBeforeFees = getKyberBuyAmountBeforeFees;
+const getKyberTradeAmounts = ({ input, amountOut, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const buyAmountAfterFeesCryptoBaseUnit = amountOut;
+    const buyAmountBeforeFeesCryptoBaseUnit = (0, exports.getKyberBuyAmountBeforeFees)({
+        buyAmountAfterFeesCryptoBaseUnit,
+        affiliateBps,
+    });
+    return {
+        rate: (0, utils_2.getInputOutputRate)({
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        }),
+        buyAmountBeforeFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        affiliateFee: (0, affiliateFee_1.buildAffiliateFee)({
+            strategy: 'buy_asset',
+            affiliateBps,
+            sellAsset,
+            buyAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountBeforeFeesCryptoBaseUnit,
+        }),
+    };
+};
+exports.getKyberTradeAmounts = getKyberTradeAmounts;
+const getKyberCodeError = ({ code, message, requestId }) => {
+    const tradeQuoteError = (() => {
+        switch (code) {
+            case 4008:
+            case 4009:
+            case 4010:
+                return types_1.TradeQuoteError.NoRouteFound;
+            case 4011:
+            case 4221:
+                return types_1.TradeQuoteError.UnsupportedTradePair;
+            case 4005:
+            case 4007:
+                return types_1.TradeQuoteError.SellAmountBelowTradeFee;
+            default:
+                return types_1.TradeQuoteError.QueryFailed;
+        }
+    })();
+    return (0, utils_2.makeSwapErrorRight)({
+        message: `KyberSwap request failed: ${message}`,
+        code: tradeQuoteError,
+        details: { code, requestId },
+    });
+};
+const isKyberErrorResponse = (value) => typeof value === 'object' &&
+    value !== null &&
+    'code' in value &&
+    typeof value.code === 'number' &&
+    'message' in value &&
+    typeof value.message === 'string';
+const getKyberRequestError = (error) => {
+    const { cause } = error;
+    if (!axios_1.default.isAxiosError(cause))
+        return error;
+    const status = cause.response?.status;
+    if (status === 429) {
+        return (0, utils_2.makeSwapErrorRight)({
+            message: 'KyberSwap rate limit exceeded',
+            code: types_1.TradeQuoteError.RateLimitExceeded,
+        });
+    }
+    if (status === 404) {
+        return (0, utils_2.makeSwapErrorRight)({
+            message: 'KyberSwap does not serve this chain',
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        });
+    }
+    const body = cause.response?.data;
+    if (isKyberErrorResponse(body))
+        return getKyberCodeError(body);
+    return (0, utils_2.makeSwapErrorRight)({
+        message: `KyberSwap request failed with status ${status}`,
+        code: types_1.TradeQuoteError.QueryFailed,
+        cause,
+    });
+};
+exports.getKyberRequestError = getKyberRequestError;
+const isPinnedRouter = (routerAddress) => (0, viem_1.isAddress)(routerAddress) && (0, viem_1.isAddressEqual)(routerAddress, constants_1.KYBER_ROUTER_ADDRESS);
+const unpinnedRouterError = (routerAddress) => invalidResponse(`KyberSwap router ${routerAddress} is not the pinned router`);
+const validateKyberRoute = (response, feeParams) => {
+    if (response.code !== 0)
+        return (0, monads_1.Err)(getKyberCodeError(response));
+    if (!response.data)
+        return (0, monads_1.Err)(invalidResponse('KyberSwap returned no route'));
+    const { routeSummary, routerAddress } = response.data;
+    if (!isPinnedRouter(routerAddress))
+        return (0, monads_1.Err)(unpinnedRouterError(routerAddress));
+    // Kyber skips the integrator fee on wrap and unwrap routes, so reject them rather than swap fee-free
+    if (feeParams && routeSummary.extraFee.feeAmount === '') {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Wrapping or unwrapping the native asset is not supported through KyberSwap',
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return (0, monads_1.Ok)(routeSummary);
+};
+exports.validateKyberRoute = validateKyberRoute;
+const validateKyberBuild = (response) => {
+    if (response.code !== 0)
+        return (0, monads_1.Err)(getKyberCodeError(response));
+    if (!response.data)
+        return (0, monads_1.Err)(invalidResponse('KyberSwap returned no transaction'));
+    const { routerAddress } = response.data;
+    if (!isPinnedRouter(routerAddress))
+        return (0, monads_1.Err)(unpinnedRouterError(routerAddress));
+    return (0, monads_1.Ok)(response.data);
+};
+exports.validateKyberBuild = validateKyberBuild;

package/dist/cjs/swappers/KyberSwapper/utils/helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/swappers/KyberSwapper/utils/helpers.test.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@shapeshiftoss/types");
+const vitest_1 = require("vitest");
+const types_2 = require("../../../types");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+const TREASURY = '0xF5AA59151bE6515C4Ca68A0282CF68B3eA4846fC';
+const UNPINNED_ROUTER = '0x1111111111111111111111111111111111111111';
+const EMPTY_EXTRA_FEE = {
+    feeAmount: '',
+    chargeFeeBy: '',
+    isInBps: false,
+    feeReceiver: '',
+};
+const hyperEvmFeeParams = (0, helpers_1.getKyberFeeParams)({
+    chainId: types_1.KnownChainIds.HyperEvmMainnet,
+    affiliateBps: '60',
+});
+const ROUTE = {
+    amountOut: '255332541',
+    gas: '679101',
+    gasPrice: '100000000',
+    extraFee: {
+        feeAmount: '60',
+        chargeFeeBy: 'currency_out',
+        isInBps: true,
+        feeReceiver: TREASURY.toLowerCase(),
+    },
+};
+const ROUTES_RESPONSE = {
+    code: 0,
+    message: 'successfully',
+    data: { routeSummary: ROUTE, routerAddress: constants_1.KYBER_ROUTER_ADDRESS },
+    requestId: 'route-request',
+};
+const BUILD_RESPONSE = {
+    code: 0,
+    message: 'successfully',
+    data: {
+        amountOut: '255332539',
+        gas: '679101',
+        data: '0xe21fd0e9',
+        routerAddress: constants_1.KYBER_ROUTER_ADDRESS,
+        transactionValue: '3000000000000000000',
+    },
+    requestId: 'build-request',
+};
+(0, vitest_1.describe)('getKyberFeeParams', () => {
+    (0, vitest_1.it)('sends no fee for a fee-free swap', () => {
+        (0, vitest_1.expect)((0, helpers_1.getKyberFeeParams)({ chainId: types_1.KnownChainIds.HyperEvmMainnet, affiliateBps: '0' })).toBeUndefined();
+    });
+    (0, vitest_1.it)('charges the output in bps to the chain treasury', () => {
+        (0, vitest_1.expect)(hyperEvmFeeParams).toEqual({
+            feeAmount: '60',
+            chargeFeeBy: 'currency_out',
+            isInBps: true,
+            feeReceiver: TREASURY,
+        });
+    });
+});
+(0, vitest_1.describe)('getKyberBuyAmountBeforeFees', () => {
+    vitest_1.it.each([
+        ['255332541', '60', '256873783'],
+        ['54334339666759063267443', '60', '54662313548047347351552'],
+        ['123', '0', '123'],
+    ])('grosses up %s at %s bps to %s', (buyAmountAfterFeesCryptoBaseUnit, affiliateBps, gross) => {
+        (0, vitest_1.expect)((0, helpers_1.getKyberBuyAmountBeforeFees)({ buyAmountAfterFeesCryptoBaseUnit, affiliateBps })).toBe(gross);
+    });
+});
+(0, vitest_1.describe)('validateKyberRoute', () => {
+    const validate = (summaryOverrides, dataOverrides = {}, feeParams = hyperEvmFeeParams) => (0, helpers_1.validateKyberRoute)({
+        ...ROUTES_RESPONSE,
+        data: {
+            ...ROUTES_RESPONSE.data,
+            routeSummary: { ...ROUTE, ...summaryOverrides },
+            ...dataOverrides,
+        },
+    }, feeParams);
+    (0, vitest_1.it)('returns the route summary', () => {
+        (0, vitest_1.expect)((0, helpers_1.validateKyberRoute)(ROUTES_RESPONSE, hyperEvmFeeParams).unwrap()).toBe(ROUTE);
+    });
+    (0, vitest_1.it)('rejects an unpinned router', () => {
+        (0, vitest_1.expect)(validate({}, { routerAddress: UNPINNED_ROUTER }).unwrapErr().code).toBe(types_2.TradeQuoteError.InvalidResponse);
+    });
+    (0, vitest_1.it)('rejects a route that dropped the requested fee', () => {
+        (0, vitest_1.expect)(validate({ extraFee: EMPTY_EXTRA_FEE }).unwrapErr().code).toBe(types_2.TradeQuoteError.UnsupportedTradePair);
+    });
+    (0, vitest_1.it)('accepts a fee-free route when no fee was requested', () => {
+        (0, vitest_1.expect)((0, helpers_1.validateKyberRoute)({
+            ...ROUTES_RESPONSE,
+            data: {
+                ...ROUTES_RESPONSE.data,
+                routeSummary: { ...ROUTE, extraFee: EMPTY_EXTRA_FEE },
+            },
+        }, undefined).isOk()).toBe(true);
+    });
+});
+(0, vitest_1.describe)('validateKyberBuild', () => {
+    (0, vitest_1.it)('returns the build data', () => {
+        (0, vitest_1.expect)((0, helpers_1.validateKyberBuild)(BUILD_RESPONSE).unwrap()).toBe(BUILD_RESPONSE.data);
+    });
+    (0, vitest_1.it)('rejects an unpinned router', () => {
+        const result = (0, helpers_1.validateKyberBuild)({
+            ...BUILD_RESPONSE,
+            data: { ...BUILD_RESPONSE.data, routerAddress: UNPINNED_ROUTER },
+        });
+        (0, vitest_1.expect)(result.unwrapErr().code).toBe(types_2.TradeQuoteError.InvalidResponse);
+    });
+});

package/dist/cjs/swappers/KyberSwapper/utils/kyberService.d.ts

@@ -0,0 +1,5 @@
+export declare const kyberService: {
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../..").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../..").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../..").SwapErrorRight>>;
+};

package/dist/cjs/swappers/KyberSwapper/utils/kyberService.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kyberService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../../../utils");
+exports.kyberService = (0, utils_1.makeSwapperAxiosServiceMonadic)(axios_1.default.create({ timeout: 10_000 }));

package/dist/cjs/swappers/MayachainSwapper/generated/generatedTradableAssetMap.json

@@ -4,7 +4,6 @@
     "ARB.ETH": "eip155:42161/slip44:60",
     "ARB.GLD-0XAFD091F140C21770F4E5D53D26B2859AE97555AA": "eip155:42161/erc20:0xafd091f140c21770f4e5d53d26b2859ae97555aa",
     "ARB.LEO-0X93864D81175095DD93360FFA2A529B8642F76A6E": "eip155:42161/erc20:0x93864d81175095dd93360ffa2a529b8642f76a6e",
-    "ARB.LINK-0XF97F4DF75117A78C1A5A0DBB814AF92458539FB4": "eip155:42161/erc20:0xf97f4df75117a78c1a5a0dbb814af92458539fb4",
     "ARB.PEPE-0X25D887CE7A35172C62FEBFD67A1856F20FAEBB00": "eip155:42161/erc20:0x25d887ce7a35172c62febfd67a1856f20faebb00",
     "ARB.TGT-0X429FED88F10285E61B12BDF00848315FBDFCC341": "eip155:42161/erc20:0x429fed88f10285e61b12bdf00848315fbdfcc341",
     "ARB.USDC-0XAF88D065E77C8CC2239327C5EDB3A432268E5831": "eip155:42161/erc20:0xaf88d065e77c8cc2239327c5edb3a432268e5831",