@shapeshiftoss/swapper 20.3.0 → 20.5.0

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

@@ -0,0 +1,33 @@
+import { convertDecimalPercentageToBasisPoints } from '@shapeshiftoss/utils';
+import { Err } from '@sniptt/monads';
+import { KYBER_CHAINS, KYBER_CLIENT_ID } from './constants.js';
+import { getKyberRequestError, validateKyberBuild, validateKyberRoute } from './helpers.js';
+import { kyberService } from './kyberService.js';
+export const fetchKyberRoute = async ({ chainId, tokenIn, tokenOut, sellAmountCryptoBaseUnit, feeParams, sendAddress, baseUrl, }) => {
+    const maybeResponse = await kyberService.get(`${baseUrl}/${KYBER_CHAINS[chainId]}/api/v1/routes`, {
+        params: {
+            tokenIn,
+            tokenOut,
+            amountIn: sellAmountCryptoBaseUnit,
+            ...(sendAddress ? { origin: sendAddress } : {}),
+            ...feeParams,
+        },
+    });
+    if (maybeResponse.isErr())
+        return Err(getKyberRequestError(maybeResponse.unwrapErr()));
+    return validateKyberRoute(maybeResponse.unwrap().data, feeParams);
+};
+export const fetchKyberBuild = async ({ chainId, route, slippageTolerancePercentageDecimal, baseUrl, sendAddress, receiveAddress, deadline, }) => {
+    const maybeResponse = await kyberService.post(`${baseUrl}/${KYBER_CHAINS[chainId]}/api/v1/route/build`, {
+        routeSummary: route,
+        sender: sendAddress,
+        recipient: receiveAddress,
+        origin: sendAddress,
+        slippageTolerance: convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal).toNumber(),
+        deadline,
+        source: KYBER_CLIENT_ID,
+    });
+    if (maybeResponse.isErr())
+        return Err(getKyberRequestError(maybeResponse.unwrapErr()));
+    return validateKyberBuild(maybeResponse.unwrap().data);
+};

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

@@ -0,0 +1,27 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { KyberBuildData, KyberRouteSummary } from '../types.js';
+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/esm/swappers/KyberSwapper/utils/getKyberStepData.js

@@ -0,0 +1,43 @@
+import { fromChainId } from '@shapeshiftoss/caip';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit, getEvmRateNetworkFeeCryptoBaseUnit, } from '../../../utils/evm/index.js';
+import { KYBER_ROUTER_ADDRESS } from './constants.js';
+export 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 getEvmRateNetworkFeeCryptoBaseUnit({
+            adapter,
+            supportsEIP1559,
+            providerGasLimit: route.gas,
+        }).catch(() => bnOrZero(route.gas).times(bnOrZero(route.gasPrice)).toFixed(0));
+        const stepData = { networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    const { build, from } = args;
+    const transactionData = {
+        type: 'evm',
+        chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+        to: KYBER_ROUTER_ADDRESS,
+        data: build.data,
+        value: build.transactionValue,
+    };
+    try {
+        const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+            adapter,
+            supportsEIP1559,
+            transactionData,
+            from,
+            stateOverride: { sellAsset, sellAmountCryptoBaseUnit, spenderAddress },
+            providerGasLimit: build.gas,
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    catch (error) {
+        return Err(makeNetworkFeeEstimationFailedErr('getKyberStepData', error));
+    }
+}

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

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

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

@@ -0,0 +1,90 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { describe, expect, it, vi } from 'vitest';
+import { ETH } from '../../../utils/test-data/assets.js';
+import { KYBER_ROUTER_ADDRESS } from './constants.js';
+import { getKyberStepData } from './getKyberStepData.js';
+// The override path reads live chain state, so resolve to no override and hit the mocked adapter
+vi.mock('../../../utils/evm/stateOverride', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getMinimalStateOverride: vi.fn().mockResolvedValue(undefined),
+}));
+const HYPE = {
+    ...ETH,
+    assetId: 'eip155:999/slip44:60',
+    chainId: 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' },
+};
+describe('getKyberStepData', () => {
+    it('prices the provider gas limit for a rate', async () => {
+        const actual = await getKyberStepData({
+            ...baseArgs,
+            type: 'rate',
+            input: rateInput,
+            deps: makeDeps(evmAdapter()),
+        });
+        // gas 679101 * gasPrice 1000000000
+        expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '679101000000000' });
+    });
+    it('falls back to the provider gas price when rate pricing fails', async () => {
+        const actual = await getKyberStepData({
+            ...baseArgs,
+            type: 'rate',
+            input: rateInput,
+            deps: makeDeps(evmAdapter({ throwOnGasFeeData: true })),
+        });
+        // gas 679101 * provider gasPrice 2000000000
+        expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '1358202000000000' });
+    });
+    it('builds the router transaction and sets the buffered on chain estimate for a quote', async () => {
+        const actual = await getKyberStepData({
+            ...baseArgs,
+            type: 'quote',
+            input: quoteInput,
+            from: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+            build,
+            deps: makeDeps(evmAdapter({ estimatedGasLimit: '500000' })),
+        });
+        expect(actual.unwrap()).toEqual({
+            networkFeeCryptoBaseUnit: '600000000000000',
+            transactionData: {
+                type: 'evm',
+                chainId: 999,
+                to: KYBER_ROUTER_ADDRESS,
+                data: build.data,
+                value: '3000000000000000000',
+                gasLimit: '600000',
+            },
+        });
+    });
+});

package/dist/esm/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.js';
+import type { KyberRouteSummary, KyberTradeQuoteInput, KyberTradeRateInput } from '../types.js';
+import type { KyberSupportedChainId } from './constants.js';
+import type { GetKyberStepDataArgs } from './getKyberStepData.js';
+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/esm/swappers/KyberSwapper/utils/getKyberTradeContext.js

@@ -0,0 +1,59 @@
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName } from '../../../types.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
+import { KYBER_ROUTER_ADDRESS } from './constants.js';
+import { fetchKyberRoute } from './fetchFromKyber.js';
+import { assertValidTrade, assetIdToKyberToken, getKyberFeeParams, getKyberTradeAmounts, } from './helpers.js';
+export const getKyberTradeContext = async ({ input, deps, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, sendAddress, } = input;
+    const maybeChainId = assertValidTrade({ sellAsset, buyAsset });
+    if (maybeChainId.isErr())
+        return Err(maybeChainId.unwrapErr());
+    const chainId = maybeChainId.unwrap();
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.KyberSwap);
+    const maybeRoute = await fetchKyberRoute({
+        chainId,
+        tokenIn: assetIdToKyberToken(sellAsset.assetId),
+        tokenOut: assetIdToKyberToken(buyAsset.assetId),
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        feeParams: getKyberFeeParams({ chainId, affiliateBps }),
+        sendAddress,
+        baseUrl: deps.config.VITE_KYBER_BASE_URL,
+    });
+    if (maybeRoute.isErr())
+        return Err(maybeRoute.unwrapErr());
+    const route = maybeRoute.unwrap();
+    const tradeAmounts = getKyberTradeAmounts({ input, amountOut: route.amountOut });
+    const allowanceContract = isNativeEvmAsset(sellAsset.assetId) ? '' : KYBER_ROUTER_ADDRESS;
+    return Ok({
+        tradeCommon: {
+            id: uuid(),
+            rate: tradeAmounts.rate,
+            swapperName: SwapperName.KyberSwap,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            estimatedExecutionTimeMs: 0,
+            allowanceContract,
+            sellAsset,
+            buyAsset,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            ...tradeAmounts,
+            source: SwapperName.KyberSwap,
+        },
+        protocolFees: {},
+        chainId,
+        route,
+        stepDataArgs: {
+            deps,
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            spenderAddress: allowanceContract,
+            route,
+        },
+    });
+};

package/dist/esm/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.js';
+import type { KyberBuildData, KyberBuildResponse, KyberFeeParams, KyberRoutesResponse, KyberRouteSummary, KyberTradeQuoteInput, KyberTradeRateInput } from '../types.js';
+import type { KyberSupportedChainId } from './constants.js';
+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/esm/swappers/KyberSwapper/utils/helpers.js

@@ -0,0 +1,158 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { BigNumber, bn, bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import axios from 'axios';
+import { getAddress, isAddress, isAddressEqual } from 'viem';
+import { TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../../utils/helpers.js';
+import { KYBER_CHAINS, KYBER_NATIVE_TOKEN, KYBER_ROUTER_ADDRESS } from './constants.js';
+const isKyberSupportedChainId = (chainId) => chainId in KYBER_CHAINS;
+const invalidResponse = (message, details) => makeSwapErrorRight({ message, details, code: TradeQuoteError.InvalidResponse });
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (sellAsset.chainId !== buyAsset.chainId) {
+        return Err(makeSwapErrorRight({
+            message: 'KyberSwap does not support cross-chain trades',
+            code: TradeQuoteError.CrossChainNotSupported,
+        }));
+    }
+    if (!isKyberSupportedChainId(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: 'KyberSwap only supports configured EVM chains',
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return Ok(sellAsset.chainId);
+};
+export const assetIdToKyberToken = (assetId) => isNativeEvmAsset(assetId) ? KYBER_NATIVE_TOKEN : getAddress(fromAssetId(assetId).assetReference);
+export const getKyberFeeParams = ({ chainId, affiliateBps, }) => {
+    if (bnOrZero(affiliateBps).lte(0))
+        return undefined;
+    return {
+        feeAmount: affiliateBps,
+        chargeFeeBy: 'currency_out',
+        isInBps: true,
+        feeReceiver: getAddress(getTreasuryAddressFromChainId(chainId)),
+    };
+};
+// Kyber only returns the post-fee amountOut; the inverse is at most one base unit off
+export const getKyberBuyAmountBeforeFees = ({ buyAmountAfterFeesCryptoBaseUnit, affiliateBps, }) => {
+    if (bnOrZero(affiliateBps).lte(0))
+        return buyAmountAfterFeesCryptoBaseUnit;
+    return bn(buyAmountAfterFeesCryptoBaseUnit)
+        .times(10_000)
+        .div(bn(10_000).minus(affiliateBps))
+        .integerValue(BigNumber.ROUND_DOWN)
+        .toFixed();
+};
+export const getKyberTradeAmounts = ({ input, amountOut, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const buyAmountAfterFeesCryptoBaseUnit = amountOut;
+    const buyAmountBeforeFeesCryptoBaseUnit = getKyberBuyAmountBeforeFees({
+        buyAmountAfterFeesCryptoBaseUnit,
+        affiliateBps,
+    });
+    return {
+        rate: getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        }),
+        buyAmountBeforeFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        affiliateFee: buildAffiliateFee({
+            strategy: 'buy_asset',
+            affiliateBps,
+            sellAsset,
+            buyAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountBeforeFeesCryptoBaseUnit,
+        }),
+    };
+};
+const getKyberCodeError = ({ code, message, requestId }) => {
+    const tradeQuoteError = (() => {
+        switch (code) {
+            case 4008:
+            case 4009:
+            case 4010:
+                return TradeQuoteError.NoRouteFound;
+            case 4011:
+            case 4221:
+                return TradeQuoteError.UnsupportedTradePair;
+            case 4005:
+            case 4007:
+                return TradeQuoteError.SellAmountBelowTradeFee;
+            default:
+                return TradeQuoteError.QueryFailed;
+        }
+    })();
+    return 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';
+export const getKyberRequestError = (error) => {
+    const { cause } = error;
+    if (!axios.isAxiosError(cause))
+        return error;
+    const status = cause.response?.status;
+    if (status === 429) {
+        return makeSwapErrorRight({
+            message: 'KyberSwap rate limit exceeded',
+            code: TradeQuoteError.RateLimitExceeded,
+        });
+    }
+    if (status === 404) {
+        return makeSwapErrorRight({
+            message: 'KyberSwap does not serve this chain',
+            code: TradeQuoteError.UnsupportedChain,
+        });
+    }
+    const body = cause.response?.data;
+    if (isKyberErrorResponse(body))
+        return getKyberCodeError(body);
+    return makeSwapErrorRight({
+        message: `KyberSwap request failed with status ${status}`,
+        code: TradeQuoteError.QueryFailed,
+        cause,
+    });
+};
+const isPinnedRouter = (routerAddress) => isAddress(routerAddress) && isAddressEqual(routerAddress, KYBER_ROUTER_ADDRESS);
+const unpinnedRouterError = (routerAddress) => invalidResponse(`KyberSwap router ${routerAddress} is not the pinned router`);
+export const validateKyberRoute = (response, feeParams) => {
+    if (response.code !== 0)
+        return Err(getKyberCodeError(response));
+    if (!response.data)
+        return Err(invalidResponse('KyberSwap returned no route'));
+    const { routeSummary, routerAddress } = response.data;
+    if (!isPinnedRouter(routerAddress))
+        return 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 Err(makeSwapErrorRight({
+            message: 'Wrapping or unwrapping the native asset is not supported through KyberSwap',
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return Ok(routeSummary);
+};
+export const validateKyberBuild = (response) => {
+    if (response.code !== 0)
+        return Err(getKyberCodeError(response));
+    if (!response.data)
+        return Err(invalidResponse('KyberSwap returned no transaction'));
+    const { routerAddress } = response.data;
+    if (!isPinnedRouter(routerAddress))
+        return Err(unpinnedRouterError(routerAddress));
+    return Ok(response.data);
+};

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

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

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

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

package/dist/esm/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("../../../index.js").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("../../../index.js").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("../../../index.js").SwapErrorRight>>;
+};

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

@@ -0,0 +1,3 @@
+import axios from 'axios';
+import { makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
+export const kyberService = makeSwapperAxiosServiceMonadic(axios.create({ timeout: 10_000 }));

package/dist/esm/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",

package/dist/esm/swappers/NearIntentsSwapper/NearIntentsSwapper.js

@@ -1,4 +1,4 @@
-import { executeEvmTransaction, executeNearTransaction, executeSolanaTransaction, executeStarknetTransaction, executeSuiTransaction, executeTonTransaction, executeTronTransaction, } from '../../utils/index.js';
+import { executeAptosTransaction, executeEvmTransaction, executeNearTransaction, executeSolanaTransaction, executeStarknetTransaction, executeSuiTransaction, executeTonTransaction, executeTronTransaction, } from '../../utils/index.js';
 export const nearIntentsSwapper = {
     supportsExternalPayment: true,
     executeEvmTransaction,
@@ -8,6 +8,7 @@ export const nearIntentsSwapper = {
     executeSuiTransaction,
     executeNearTransaction,
     executeTonTransaction,
+    executeAptosTransaction,
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
         return signAndBroadcastTransaction(txToSign);
     },