@shapeshiftoss/swapper 20.3.0 → 20.5.0

package/dist/esm/swappers/FyndSwapper/utils/getFyndTradeContext.js

@@ -0,0 +1,90 @@
+import { bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName } from '../../../types.js';
+import { getInputOutputRate } from '../../../utils/index.js';
+import { isNativeEvmAsset, normalizeEpochToMs } from '../../../utils/helpers.js';
+import { fetchFromFynd } from './fetchFromFynd.js';
+import { assertValidTrade, getFyndClientFeeBps, getFyndRouteProtocols } from './helpers.js';
+export const getFyndTradeContext = async ({ input, deps, from, to, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const maybeChainId = assertValidTrade({ sellAsset, buyAsset });
+    if (maybeChainId.isErr())
+        return Err(maybeChainId.unwrapErr());
+    const chainId = maybeChainId.unwrap();
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Fynd);
+    const clientFeeBps = getFyndClientFeeBps(affiliateBps);
+    const maybeQuote = await fetchFromFynd({
+        input,
+        chainId,
+        sender: from,
+        receiver: to,
+        slippageTolerancePercentageDecimal,
+        clientFeeBps,
+        baseUrl: deps.config.VITE_FYND_BASE_URL,
+    });
+    if (maybeQuote.isErr())
+        return Err(maybeQuote.unwrapErr());
+    const quote = maybeQuote.unwrap();
+    const { router_fee: routerFee, client_fee: clientFee } = quote.fee_breakdown;
+    const buyAmountBeforeFeesCryptoBaseUnit = quote.amount_out;
+    const buyAmountAfterFeesCryptoBaseUnit = bn(quote.amount_out)
+        .minus(routerFee)
+        .minus(clientFee)
+        .toFixed();
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: quote.amount_in,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const protocols = getFyndRouteProtocols(quote.route?.swaps);
+    const source = protocols.length
+        ? `${SwapperName.Fynd} • ${protocols.join(', ')}`
+        : SwapperName.Fynd;
+    const allowanceContract = isNativeEvmAsset(sellAsset.assetId) ? '' : quote.transaction.to;
+    const protocolFees = bn(routerFee).gt(0)
+        ? {
+            [buyAsset.assetId]: {
+                amountCryptoBaseUnit: routerFee,
+                asset: buyAsset,
+                requiresBalance: false,
+            },
+        }
+        : {};
+    return Ok({
+        tradeCommon: {
+            id: uuid(),
+            rate,
+            swapperName: SwapperName.Fynd,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            estimatedExecutionTimeMs: 0,
+            allowanceContract,
+            rate,
+            sellAsset,
+            buyAsset,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            source,
+            affiliateFee: bn(clientFee).gt(0)
+                ? { assetId: buyAsset.assetId, amountCryptoBaseUnit: clientFee, asset: buyAsset }
+                : undefined,
+        },
+        protocolFees,
+        deadline: quote.client_fee_deadline ? normalizeEpochToMs(quote.client_fee_deadline) : undefined,
+        stepDataArgs: {
+            quote,
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            spenderAddress: allowanceContract,
+            from,
+            deps,
+        },
+    });
+};

package/dist/esm/swappers/FyndSwapper/utils/helpers.d.ts

@@ -0,0 +1,24 @@
+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 } from '../../../types.js';
+import type { FyndEncodedQuote, FyndQuoteResponse, FyndRouteSwap } from '../types.js';
+import type { FyndSupportedChainId } from './constants.js';
+export declare const getFyndRouteProtocols: (swaps: FyndRouteSwap[] | undefined) => string[];
+export declare const getFyndClientFeeBps: (affiliateBps: string) => number;
+export declare const convertAssetIdToFyndToken: (assetId: AssetId) => Address;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<FyndSupportedChainId, SwapErrorRight>;
+export declare const getFyndRequestError: (error: SwapErrorRight) => SwapErrorRight;
+type FyndQuoteContext = {
+    chainId: FyndSupportedChainId;
+    sellAsset: Asset;
+    sellAmountCryptoBaseUnit: string;
+    slippageTolerancePercentageDecimal: string;
+    clientFeeBps: number;
+};
+export declare const validateFyndQuoteResponse: (response: FyndQuoteResponse, context: FyndQuoteContext) => Result<FyndEncodedQuote, SwapErrorRight>;
+export {};

package/dist/esm/swappers/FyndSwapper/utils/helpers.js

@@ -0,0 +1,162 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { BigNumber, bn } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import axios from 'axios';
+import { getAddress, isAddress, isAddressEqual, zeroAddress } from 'viem';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
+import { FYND_CHAINS, FYND_CLIENT_FEE_SHARE, FYND_CLIENT_FEE_SIGNATURE_BYTES } from './constants.js';
+const isFyndSupportedChainId = (chainId) => chainId in FYND_CHAINS;
+// Protocol ids look like uniswap_v3, vm:balancer_v2 or fallback:rfq:bebop
+const formatFyndProtocol = (protocol) => protocol
+    .slice(protocol.lastIndexOf(':') + 1)
+    .split('_')
+    .map(word => /^v\d+$/.test(word) ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+// The native_wrapper hop is only the WETH wrap/unwrap around the real venues
+export const getFyndRouteProtocols = (swaps) => {
+    const venues = (swaps ?? [])
+        .map(swap => swap.protocol)
+        .filter(protocol => !protocol.endsWith('native_wrapper'));
+    return [...new Set(venues)].map(formatFyndProtocol);
+};
+export const getFyndClientFeeBps = (affiliateBps) => bn(affiliateBps).div(FYND_CLIENT_FEE_SHARE).integerValue(BigNumber.ROUND_CEIL).toNumber();
+export const convertAssetIdToFyndToken = (assetId) => {
+    if (isNativeEvmAsset(assetId))
+        return zeroAddress;
+    return getAddress(fromAssetId(assetId).assetReference);
+};
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (sellAsset.chainId !== buyAsset.chainId) {
+        return Err(makeSwapErrorRight({
+            message: 'Fynd does not support cross-chain trades',
+            code: TradeQuoteError.CrossChainNotSupported,
+        }));
+    }
+    if (!isFyndSupportedChainId(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: 'Fynd only supports configured EVM chains',
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return Ok(sellAsset.chainId);
+};
+const getFyndStatusError = (status, detail) => {
+    const code = (() => {
+        switch (status.toLowerCase()) {
+            case 'no_route_found':
+            case 'insufficient_liquidity':
+                return TradeQuoteError.NoRouteFound;
+            case 'timeout':
+                return TradeQuoteError.Timeout;
+            default:
+                return TradeQuoteError.QueryFailed;
+        }
+    })();
+    return makeSwapErrorRight({
+        message: `Fynd quote failed: ${status}${detail ? ` (${detail})` : ''}`,
+        code,
+    });
+};
+const isFyndErrorResponse = (value) => typeof value === 'object' &&
+    value !== null &&
+    'error' in value &&
+    typeof value.error === 'string' &&
+    'code' in value &&
+    typeof value.code === 'string';
+export const getFyndRequestError = (error) => {
+    const { cause } = error;
+    if (!axios.isAxiosError(cause))
+        return error;
+    if (cause.response?.status === 429) {
+        return makeSwapErrorRight({
+            message: 'Fynd rate limit exceeded',
+            code: TradeQuoteError.RateLimitExceeded,
+        });
+    }
+    const body = cause.response?.data;
+    if (isFyndErrorResponse(body))
+        return getFyndStatusError(body.code, body.error);
+    return makeSwapErrorRight({
+        message: `Fynd request failed with status ${cause.response?.status}`,
+        code: TradeQuoteError.QueryFailed,
+        cause,
+    });
+};
+const invalidResponse = (message, details) => makeSwapErrorRight({ message, details, code: TradeQuoteError.InvalidResponse });
+const getQuoteError = (quote, { chainId, sellAsset, sellAmountCryptoBaseUnit, slippageTolerancePercentageDecimal, clientFeeBps, }) => {
+    const { transaction, fee_breakdown: fees } = quote;
+    const pinnedRouter = FYND_CHAINS[chainId].routerAddress;
+    if (!isAddress(transaction.to, { strict: false }) ||
+        !isAddressEqual(transaction.to, pinnedRouter)) {
+        return invalidResponse(`Fynd router ${transaction.to} is not the pinned router ${pinnedRouter} for ${chainId}`);
+    }
+    if (!bn(quote.amount_in).eq(sellAmountCryptoBaseUnit)) {
+        return invalidResponse('Fynd quoted a different sell amount', {
+            amountIn: quote.amount_in,
+            sellAmountCryptoBaseUnit,
+        });
+    }
+    const expectedValue = isNativeEvmAsset(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0';
+    if (!bn(transaction.value).eq(expectedValue)) {
+        return invalidResponse('Fynd transaction value does not match the sell amount', {
+            value: transaction.value,
+            expectedValue,
+        });
+    }
+    // The router enforces min_amount_received, which may not be looser than the requested slippage
+    const netOutput = bn(quote.amount_out).minus(fees.router_fee).minus(fees.client_fee);
+    const outputFloor = netOutput
+        .times(bn(1).minus(slippageTolerancePercentageDecimal))
+        .integerValue(BigNumber.ROUND_DOWN);
+    if (bn(fees.min_amount_received).lt(outputFloor)) {
+        return invalidResponse('Fynd output floor is below the requested slippage', {
+            minAmountReceived: fees.min_amount_received,
+            outputFloor: outputFloor.toFixed(),
+            slippageTolerancePercentageDecimal,
+        });
+    }
+    if (clientFeeBps === 0) {
+        if (!bn(fees.client_fee).isZero()) {
+            return invalidResponse('Fynd returned an unexpected client fee', {
+                clientFee: fees.client_fee,
+            });
+        }
+        return;
+    }
+    // Our share of the gross client fee, allowing one unit of rounding
+    const minClientFee = bn(quote.amount_out)
+        .times(clientFeeBps)
+        .div(10_000)
+        .times(FYND_CLIENT_FEE_SHARE)
+        .integerValue(BigNumber.ROUND_DOWN)
+        .minus(1);
+    if (bn(fees.client_fee).lt(minClientFee)) {
+        return invalidResponse('Fynd client fee is below the requested share', {
+            clientFee: fees.client_fee,
+            amountOut: quote.amount_out,
+            clientFeeBps,
+        });
+    }
+    // The proxy patches the signature over Fynd's zeroed placeholder at the reported offset
+    const offset = transaction.client_fee_signature_offset;
+    const signature = typeof offset === 'number'
+        ? transaction.data.slice(2 + offset * 2, 2 + (offset + FYND_CLIENT_FEE_SIGNATURE_BYTES) * 2)
+        : '';
+    if (signature.length !== FYND_CLIENT_FEE_SIGNATURE_BYTES * 2 || /^0+$/.test(signature)) {
+        return invalidResponse('Fynd quote is not signed for the client fee', { offset });
+    }
+    if (!quote.client_fee_deadline) {
+        return invalidResponse('Fynd quote is missing its client fee deadline');
+    }
+};
+export const validateFyndQuoteResponse = (response, context) => {
+    const order = Array.isArray(response?.orders) ? response.orders[0] : undefined;
+    if (!order)
+        return Err(invalidResponse('Fynd returned no order'));
+    if (order.status !== 'success')
+        return Err(getFyndStatusError(order.status));
+    const error = getQuoteError(order, context);
+    return error ? Err(error) : Ok(order);
+};

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

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

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

@@ -0,0 +1,99 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { describe, expect, it } from 'vitest';
+import { ETH, WETH } from '../../../utils/test-data/assets.js';
+import { FYND_CHAINS } from './constants.js';
+import { getFyndClientFeeBps, validateFyndQuoteResponse } from './helpers.js';
+describe('getFyndClientFeeBps', () => {
+    it.each([
+        ['nets the default fee after the 20% share', '60', 75],
+        ['rounds up so the net never falls short', '55', 69],
+        ['requests nothing for a fee-free swap', '0', 0],
+    ])('%s', (_label, affiliateBps, grossBps) => {
+        expect(getFyndClientFeeBps(affiliateBps)).toBe(grossBps);
+    });
+});
+describe('validateFyndQuoteResponse', () => {
+    const router = FYND_CHAINS['eip155:1'].routerAddress;
+    const unpinnedRouter = '0x1111111111111111111111111111111111111111';
+    const transaction = {
+        to: router,
+        value: '0',
+        data: '0x12345678',
+        client_fee_signature_offset: null,
+    };
+    const fees = { router_fee: '10', client_fee: '0', max_slippage: '4', min_amount_received: '986' };
+    const order = {
+        status: 'success',
+        amount_in: '1000',
+        amount_out: '1000',
+        gas_estimate: '21000',
+        transaction,
+        fee_breakdown: fees,
+    };
+    const context = {
+        chainId: KnownChainIds.EthereumMainnet,
+        sellAsset: WETH,
+        sellAmountCryptoBaseUnit: '1000',
+        slippageTolerancePercentageDecimal: '0.005',
+        clientFeeBps: 0,
+    };
+    const validate = (overrides, contextOverrides = {}) => validateFyndQuoteResponse({ orders: [{ ...order, ...overrides }] }, { ...context, ...contextOverrides });
+    it('accepts a quote that matches the request', () => {
+        expect(validate({}).isOk()).toBe(true);
+    });
+    it.each([
+        ['an unpinned router', { transaction: { ...transaction, to: unpinnedRouter } }],
+        ['a different sell amount', { amount_in: '999' }],
+        ['native value on a token sell', { transaction: { ...transaction, value: '1' } }],
+        [
+            'an output floor looser than the slippage',
+            { fee_breakdown: { ...fees, min_amount_received: '984' } },
+        ],
+        ['a client fee we did not request', { fee_breakdown: { ...fees, client_fee: '1' } }],
+    ])('rejects %s', (_label, overrides) => {
+        expect(validate(overrides).isErr()).toBe(true);
+    });
+    it('binds native transaction value to the requested sell amount', () => {
+        expect(validate({}, { sellAsset: ETH }).isErr()).toBe(true);
+        expect(validate({ transaction: { ...transaction, value: '1000' } }, { sellAsset: ETH }).isOk()).toBe(true);
+    });
+    it('maps a missing route to NoRouteFound', () => {
+        const result = validateFyndQuoteResponse({ orders: [{ status: 'no_route_found' }] }, context);
+        expect(result.unwrapErr().code).toBe('NoRouteFound');
+    });
+    describe('with a client fee', () => {
+        const feeContext = { clientFeeBps: 75 };
+        const feeOrder = {
+            transaction: {
+                ...transaction,
+                data: `0x12345678${'ab'.repeat(65)}`,
+                client_fee_signature_offset: 4,
+            },
+            fee_breakdown: {
+                router_fee: '2',
+                client_fee: '6',
+                max_slippage: '4',
+                min_amount_received: '988',
+            },
+            client_fee_deadline: 1_900_000_000,
+        };
+        it('accepts a signed quote carrying our share of the fee', () => {
+            expect(validate(feeOrder, feeContext).isOk()).toBe(true);
+        });
+        it.each([
+            [
+                'a fee below our share',
+                {
+                    fee_breakdown: { ...feeOrder.fee_breakdown, client_fee: '4', min_amount_received: '990' },
+                },
+            ],
+            [
+                'an unsigned placeholder',
+                { transaction: { ...feeOrder.transaction, data: `0x12345678${'00'.repeat(65)}` } },
+            ],
+            ['a missing deadline', { client_fee_deadline: null }],
+        ])('rejects %s', (_label, overrides) => {
+            expect(validate({ ...feeOrder, ...overrides }, feeContext).isErr()).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types.js';
+export declare const kyberSwapper: Swapper;

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

@@ -0,0 +1,2 @@
+import { executeEvmTransaction } from '../../utils/index.js';
+export const kyberSwapper = { executeEvmTransaction };

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

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const kyberApi: SwapperApi;

package/dist/esm/swappers/KyberSwapper/endpoints.js

@@ -0,0 +1,11 @@
+import { checkEvmSwapStatus } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getKyberTradeQuote } from './swapperApi/getKyberTradeQuote.js';
+import { getKyberTradeRate } from './swapperApi/getKyberTradeRate.js';
+export const kyberApi = {
+    getTradeQuote: (input, deps) => getKyberTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getKyberTradeRate(input, deps),
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
+    checkTradeStatus: checkEvmSwapStatus,
+};

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

@@ -0,0 +1,2 @@
+export { kyberApi } from './endpoints.js';
+export { kyberSwapper } from './KyberSwapper.js';

package/dist/esm/swappers/KyberSwapper/index.js

@@ -0,0 +1,2 @@
+export { kyberApi } from './endpoints.js';
+export { kyberSwapper } from './KyberSwapper.js';

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

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

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