@shapeshiftoss/swapper 20.4.0 → 20.5.0

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

@@ -0,0 +1,60 @@
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { KYBER_DEADLINE_SECONDS } from '../utils/constants.js';
+import { fetchKyberBuild } from '../utils/fetchFromKyber.js';
+import { getKyberStepData } from '../utils/getKyberStepData.js';
+import { getKyberTradeContext } from '../utils/getKyberTradeContext.js';
+import { getKyberTradeAmounts } from '../utils/helpers.js';
+export const getKyberTradeQuote = async (input, deps) => {
+    const { accountNumber } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeContext = await getKyberTradeContext({ input, deps });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, chainId, route, stepDataArgs } = maybeContext.unwrap();
+    const deadline = Math.floor(Date.now() / 1000) + KYBER_DEADLINE_SECONDS;
+    const maybeBuild = await fetchKyberBuild({
+        chainId,
+        route,
+        slippageTolerancePercentageDecimal: tradeCommon.slippageTolerancePercentageDecimal,
+        baseUrl: deps.config.VITE_KYBER_BASE_URL,
+        sendAddress,
+        receiveAddress,
+        deadline,
+    });
+    if (maybeBuild.isErr())
+        return 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 = getKyberTradeAmounts({ input, amountOut: build.amountOut });
+    const maybeStepData = await getKyberStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        from: sendAddress,
+        build,
+    });
+    if (maybeStepData.isErr())
+        return 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 Ok([tradeQuote]);
+};

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

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

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

@@ -0,0 +1,27 @@
+import { Err, Ok } from '@sniptt/monads';
+import { getKyberStepData } from '../utils/getKyberStepData.js';
+import { getKyberTradeContext } from '../utils/getKyberTradeContext.js';
+export const getKyberTradeRate = async (input, deps) => {
+    const { accountNumber, receiveAddress } = input;
+    const maybeContext = await getKyberTradeContext({ input, deps });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getKyberStepData({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeRate]);
+};

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

@@ -0,0 +1,62 @@
+import type { Address, Hex } from 'viem';
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../types.js';
+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/esm/swappers/KyberSwapper/types.js

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

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

@@ -0,0 +1,21 @@
+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";
+};
+export type KyberSupportedChainId = keyof typeof KYBER_CHAINS;
+export declare const KYBER_ROUTER_ADDRESS: Address;
+export declare const KYBER_NATIVE_TOKEN: Address;

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

@@ -0,0 +1,21 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const KYBER_CLIENT_ID = 'shapeshift';
+export const KYBER_DEADLINE_SECONDS = 1200;
+export const KYBER_CHAINS = {
+    [KnownChainIds.EthereumMainnet]: 'ethereum',
+    [KnownChainIds.OptimismMainnet]: 'optimism',
+    [KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+    [KnownChainIds.PolygonMainnet]: 'polygon',
+    [KnownChainIds.ArbitrumMainnet]: 'arbitrum',
+    [KnownChainIds.BaseMainnet]: 'base',
+    [KnownChainIds.AvalancheMainnet]: 'avalanche',
+    [KnownChainIds.UnichainMainnet]: 'unichain',
+    [KnownChainIds.RobinhoodMainnet]: 'robinhood',
+    [KnownChainIds.MonadMainnet]: 'monad',
+    [KnownChainIds.HyperEvmMainnet]: 'hyperevm',
+    [KnownChainIds.MegaEthMainnet]: 'megaeth',
+    [KnownChainIds.PlasmaMainnet]: 'plasma',
+};
+// MetaAggregationRouterV2, same address on every chain: https://docs.kyberswap.com/developer-guide/aggregator-api/contracts
+export const KYBER_ROUTER_ADDRESS = '0x6131B5fae19EA4f9D964eAc0408E4408b66337b5';
+export const KYBER_NATIVE_TOKEN = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';

package/dist/esm/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.js';
+import type { KyberBuildData, KyberFeeParams, KyberRouteSummary } from '../types.js';
+import type { KyberSupportedChainId } from './constants.js';
+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/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>;