@shapeshiftoss/swapper 20.4.0 → 20.6.0

package/dist/cjs/swappers/KyberSwapper/swapperApi/getKyberTradeQuote.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKyberTradeQuote = void 0;
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const constants_1 = require("../utils/constants");
+const fetchFromKyber_1 = require("../utils/fetchFromKyber");
+const getKyberStepData_1 = require("../utils/getKyberStepData");
+const getKyberTradeContext_1 = require("../utils/getKyberTradeContext");
+const helpers_1 = require("../utils/helpers");
+const getKyberTradeQuote = async (input, deps) => {
+    const { accountNumber } = input;
+    const maybeAddresses = (0, utils_1.assertQuoteAddresses)(input);
+    if (maybeAddresses.isErr())
+        return (0, monads_1.Err)(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeContext = await (0, getKyberTradeContext_1.getKyberTradeContext)({ input, deps });
+    if (maybeContext.isErr())
+        return (0, monads_1.Err)(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, chainId, route, stepDataArgs } = maybeContext.unwrap();
+    const deadline = Math.floor(Date.now() / 1000) + constants_1.KYBER_DEADLINE_SECONDS;
+    const maybeBuild = await (0, fetchFromKyber_1.fetchKyberBuild)({
+        chainId,
+        route,
+        slippageTolerancePercentageDecimal: tradeCommon.slippageTolerancePercentageDecimal,
+        baseUrl: deps.config.VITE_KYBER_BASE_URL,
+        sendAddress,
+        receiveAddress,
+        deadline,
+    });
+    if (maybeBuild.isErr())
+        return (0, monads_1.Err)(maybeBuild.unwrapErr());
+    const build = maybeBuild.unwrap();
+    // Kyber re-prices at build time and derives the calldata's minimum return from the built amount
+    const tradeAmounts = (0, helpers_1.getKyberTradeAmounts)({ input, amountOut: build.amountOut });
+    const maybeStepData = await (0, getKyberStepData_1.getKyberStepData)({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
+        build,
+    });
+    if (maybeStepData.isErr())
+        return (0, monads_1.Err)(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        rate: tradeAmounts.rate,
+        quoteOrRate: 'quote',
+        receiveAddress,
+        deadline: deadline * 1000,
+        steps: [
+            {
+                ...stepCommon,
+                ...tradeAmounts,
+                accountNumber,
+                transactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return (0, monads_1.Ok)([tradeQuote]);
+};
+exports.getKyberTradeQuote = getKyberTradeQuote;

package/dist/cjs/swappers/KyberSwapper/swapperApi/getKyberTradeRate.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types';
+import type { KyberTradeRateInput } from '../types';
+export declare const getKyberTradeRate: (input: KyberTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

package/dist/cjs/swappers/KyberSwapper/swapperApi/getKyberTradeRate.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKyberTradeRate = void 0;
+const monads_1 = require("@sniptt/monads");
+const getKyberStepData_1 = require("../utils/getKyberStepData");
+const getKyberTradeContext_1 = require("../utils/getKyberTradeContext");
+const getKyberTradeRate = async (input, deps) => {
+    const { accountNumber, receiveAddress } = input;
+    const maybeContext = await (0, getKyberTradeContext_1.getKyberTradeContext)({ input, deps });
+    if (maybeContext.isErr())
+        return (0, monads_1.Err)(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await (0, getKyberStepData_1.getKyberStepData)({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return (0, monads_1.Err)(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return (0, monads_1.Ok)([tradeRate]);
+};
+exports.getKyberTradeRate = getKyberTradeRate;

package/dist/cjs/swappers/KyberSwapper/types.d.ts

@@ -0,0 +1,62 @@
+import type { Address, Hex } from 'viem';
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../types';
+export type KyberTradeQuoteInput = GetEvmTradeQuoteInput;
+export type KyberTradeRateInput = GetEvmTradeRateInput;
+export type KyberExtraFee = {
+    feeAmount: string;
+    chargeFeeBy: '' | 'currency_in' | 'currency_out';
+    isInBps: boolean;
+    feeReceiver: string;
+};
+export type KyberFeeParams = {
+    feeAmount: string;
+    chargeFeeBy: 'currency_out';
+    isInBps: true;
+    feeReceiver: Address;
+};
+export type KyberRouteSummary = {
+    tokenIn: string;
+    amountIn: string;
+    amountInUsd: string;
+    tokenOut: string;
+    amountOut: string;
+    amountOutUsd: string;
+    gas: string;
+    gasPrice: string;
+    gasUsd: string;
+    l1FeeUsd: string;
+    extraFee: KyberExtraFee;
+    route: unknown;
+    routerAddress: Address;
+    routeID: string;
+    checksum: string;
+    timestamp: number;
+};
+export type KyberRouteData = {
+    routeSummary: KyberRouteSummary;
+    routerAddress: Address;
+};
+export type KyberRoutesResponse = {
+    code: number;
+    message: string;
+    data?: KyberRouteData;
+    requestId: string;
+};
+export type KyberBuildData = {
+    amountOut: string;
+    gas: string;
+    data: Hex;
+    routerAddress: Address;
+    transactionValue: string;
+};
+export type KyberBuildResponse = {
+    code: number;
+    message: string;
+    data?: KyberBuildData;
+    requestId: string;
+};
+export type KyberErrorResponse = {
+    code: number;
+    message: string;
+    requestId?: string;
+};

package/dist/cjs/swappers/KyberSwapper/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,22 @@
+import type { Address } from 'viem';
+export declare const KYBER_CLIENT_ID = "shapeshift";
+export declare const KYBER_DEADLINE_SECONDS = 1200;
+export declare const KYBER_CHAINS: {
+    readonly "eip155:1": "ethereum";
+    readonly "eip155:10": "optimism";
+    readonly "eip155:56": "bsc";
+    readonly "eip155:137": "polygon";
+    readonly "eip155:42161": "arbitrum";
+    readonly "eip155:8453": "base";
+    readonly "eip155:43114": "avalanche";
+    readonly "eip155:130": "unichain";
+    readonly "eip155:4663": "robinhood";
+    readonly "eip155:143": "monad";
+    readonly "eip155:999": "hyperevm";
+    readonly "eip155:4326": "megaeth";
+    readonly "eip155:9745": "plasma";
+    readonly "eip155:99901": "elysium";
+};
+export type KyberSupportedChainId = keyof typeof KYBER_CHAINS;
+export declare const KYBER_ROUTER_ADDRESS: Address;
+export declare const KYBER_NATIVE_TOKEN: Address;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KYBER_NATIVE_TOKEN = exports.KYBER_ROUTER_ADDRESS = exports.KYBER_CHAINS = exports.KYBER_DEADLINE_SECONDS = exports.KYBER_CLIENT_ID = void 0;
+const types_1 = require("@shapeshiftoss/types");
+exports.KYBER_CLIENT_ID = 'shapeshift';
+exports.KYBER_DEADLINE_SECONDS = 1200;
+exports.KYBER_CHAINS = {
+    [types_1.KnownChainIds.EthereumMainnet]: 'ethereum',
+    [types_1.KnownChainIds.OptimismMainnet]: 'optimism',
+    [types_1.KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+    [types_1.KnownChainIds.PolygonMainnet]: 'polygon',
+    [types_1.KnownChainIds.ArbitrumMainnet]: 'arbitrum',
+    [types_1.KnownChainIds.BaseMainnet]: 'base',
+    [types_1.KnownChainIds.AvalancheMainnet]: 'avalanche',
+    [types_1.KnownChainIds.UnichainMainnet]: 'unichain',
+    [types_1.KnownChainIds.RobinhoodMainnet]: 'robinhood',
+    [types_1.KnownChainIds.MonadMainnet]: 'monad',
+    [types_1.KnownChainIds.HyperEvmMainnet]: 'hyperevm',
+    [types_1.KnownChainIds.MegaEthMainnet]: 'megaeth',
+    [types_1.KnownChainIds.PlasmaMainnet]: 'plasma',
+    [types_1.KnownChainIds.ElysiumMainnet]: 'elysium',
+};
+// MetaAggregationRouterV2, same address on every chain: https://docs.kyberswap.com/developer-guide/aggregator-api/contracts
+exports.KYBER_ROUTER_ADDRESS = '0x6131B5fae19EA4f9D964eAc0408E4408b66337b5';
+exports.KYBER_NATIVE_TOKEN = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';

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>;