@yoroi/swap

import {Portfolio, Swap} from '@yoroi/types' import { BuildRequest, BuildResponse, CancelRequest, CancelResponse, EstimateRequest, EstimateResponse, LimitBuildRequest, LimitBuildResponse, LimitEstimateRequest, LimitEstimateResponse, OrdersResponse, Dex, ReverseEstimateRequest, ReverseEstimateResponse, Split, TokensResponse, DexhunterApiConfig, } from './types' import {isDex} from './validators' export const ptIdDh = '000000000000000000000000000000000000000000000000000000006c6f76656c616365' export const toSwapSplit = ({ amount_in = 0, batcher_fee = 0, deposits = 0, dex, expected_output = 0, expected_output_without_slippage = 0, fee = 0, final_price = 0, initial_price = 0, pool_fee = 0, pool_id = '', price_distortion = 0, price_impact = 0, }: Split): Swap.Split => ({ amountIn: amount_in, batcherFee: batcher_fee, deposits, protocol: toSwapProtocol(dex), expectedOutput: expected_output, expectedOutputWithoutSlippage: expected_output_without_slippage, fee, finalPrice: final_price, initialPrice: initial_price, poolFee: pool_fee, poolId: pool_id, priceDistortion: price_distortion, priceImpact: price_impact, }) export const toPriceImpact = (splits: Array<Partial<Split>>): number => { const totalAmountIn = splits.reduce( (sum, split) => sum + (split.amount_in ?? 0), 0, ) if (totalAmountIn === 0) return 0 // Avoid division by zero const weightedPriceImpact = splits.reduce( (sum, split) => sum + (split.price_impact ?? 0) * (split.amount_in ?? 0), 0, ) return weightedPriceImpact / totalAmountIn } export const transformersMaker = ({ primaryTokenInfo, address, isPrimaryToken, }: DexhunterApiConfig) => { const fromTokenId = (tokenId: string): Portfolio.Token.Id => tokenId === ptIdDh ? primaryTokenInfo.id : `${tokenId.slice(0, 56)}.${tokenId.slice(56)}` const toTokenId = (tokenId: Portfolio.Token.Id) => isPrimaryToken(tokenId) ? 'ADA' : tokenId.replace('.', '') return { tokens: { fromId: fromTokenId, toId: toTokenId, response: (res: TokensResponse): Array<Portfolio.Token.Info> => res.map( ({ token_id, is_verified, token_decimals = 0, token_ascii = '', ticker = '', }) => { if (token_id === ptIdDh) return primaryTokenInfo return { id: fromTokenId(token_id), decimals: token_decimals, ticker: ticker, name: token_ascii, status: is_verified ? Portfolio.Token.Status.Valid : Portfolio.Token.Status.Invalid, type: Portfolio.Token.Type.FT, nature: Portfolio.Token.Nature.Secondary, application: Portfolio.Token.Application.General, symbol: '', tag: '', reference: '', fingerprint: '', description: '', website: '', originalImage: '', } }, ), }, orders: { response: (res: OrdersResponse): Array<Swap.Order> => res.map( ({ _id, dex, last_update, submission_time, output_index, actual_out_amount = 0, expected_out_amount = 0, amount_in = 0, is_dexhunter = false, status, token_id_in = '', token_id_out = '', tx_hash = '', update_tx_hash = '', }) => ({ status: ( { COMPLETE: 'matched', CANCELLED: 'canceled', PENDING: 'open', } as const )[status], amountIn: amount_in, actualAmountOut: actual_out_amount, expectedAmountOut: expected_out_amount, txHash: tx_hash, outputIndex: output_index, updateTxHash: update_tx_hash, customId: _id, placedAt: submission_time ? new Date(submission_time).getTime() : undefined, lastUpdate: last_update ? new Date(last_update).getTime() : undefined, aggregator: is_dexhunter ? Swap.Aggregator.Dexhunter : Swap.Aggregator.Muesliswap, protocol: toSwapProtocol(dex), tokenIn: fromTokenId(token_id_in), tokenOut: fromTokenId(token_id_out), }), ), }, cancel: { request: ({order}: Swap.CancelRequest): CancelRequest => ({ address, order_id: order.customId, }), response: ({ additional_cancellation_fee, cbor = '', }: CancelResponse): Swap.CancelResponse => ({ cbor, additionalCancellationFee: additional_cancellation_fee, }), }, estimate: { request: ({ amountIn, blockedProtocols, slippage, tokenIn, tokenOut, }: Swap.EstimateRequest): EstimateRequest => ({ slippage, amount_in: amountIn, blacklisted_dexes: blockedProtocols ?.map(fromSwapProtocol) .filter(isDex), token_in: toTokenId(tokenIn), token_out: toTokenId(tokenOut), }), response: ( { splits, batcher_fee = 0, deposits = 0, dexhunter_fee = 0, net_price = 0, net_price_reverse = 0, partner_fee = 0, total_output = 0, total_output_without_slippage = 0, }: EstimateResponse, reversed?: boolean, ): Swap.EstimateResponse => ({ deposits, splits: splits?.map(toSwapSplit) ?? [], totalOutputWithoutSlippage: total_output_without_slippage, totalInput: splits?.reduce((acc, cur) => acc + (cur.amount_in ?? 0), 0) ?? undefined, batcherFee: batcher_fee, aggregatorFee: dexhunter_fee, frontendFee: partner_fee, netPrice: reversed ? net_price_reverse : net_price, priceImpact: toPriceImpact(splits ?? []), totalFee: Number( (batcher_fee + dexhunter_fee + partner_fee).toFixed( primaryTokenInfo.decimals, ), ), totalOutput: total_output, }), }, reverseEstimate: { request: ({ amountOut, blockedProtocols, slippage, tokenIn, tokenOut, }: Swap.EstimateRequest): ReverseEstimateRequest => ({ slippage, amount_out: amountOut, blacklisted_dexes: blockedProtocols ?.map(fromSwapProtocol) .filter(isDex), token_in: toTokenId(tokenIn), token_out: toTokenId(tokenOut), }), response: ( { batcher_fee = 0, deposits = 0, dexhunter_fee = 0, net_price = 0, net_price_reverse = 0, partner_fee = 0, splits, total_input = 0, total_output = 0, }: ReverseEstimateResponse, reversed?: boolean, ): Swap.EstimateResponse => ({ deposits, batcherFee: batcher_fee, aggregatorFee: dexhunter_fee, frontendFee: partner_fee, netPrice: reversed ? net_price_reverse : net_price, priceImpact: toPriceImpact(splits ?? []), totalFee: Number( (batcher_fee + dexhunter_fee + partner_fee).toFixed( primaryTokenInfo.decimals, ), ), totalOutput: total_output, totalOutputWithoutSlippage: total_output, splits: splits?.map(toSwapSplit) ?? [], totalInput: (total_input || splits?.reduce((acc, cur) => acc + (cur.amount_in ?? 0), 0)) ?? undefined, }), }, limitEstimate: { request: ({ protocol = Swap.Protocol.Unsupported, multiples = 1, amountIn, blockedProtocols, tokenIn, tokenOut, wantedPrice, }: Swap.EstimateRequest): LimitEstimateRequest => ({ multiples, amount_in: amountIn, wanted_price: isPrimaryToken(tokenIn) && wantedPrice !== undefined && wantedPrice !== 0 ? 1 / wantedPrice : wantedPrice, blacklisted_dexes: blockedProtocols ?.map(fromSwapProtocol) .filter(isDex), dex: fromSwapProtocol(protocol), token_in: toTokenId(tokenIn), token_out: toTokenId(tokenOut), }), response: ( { splits, batcher_fee = 0, deposits = 0, dexhunter_fee = 0, net_price = 0, partner_fee = 0, total_input = 0, total_output = 0, }: LimitEstimateResponse, reversed: boolean, ): Swap.EstimateResponse => ({ deposits, batcherFee: batcher_fee, aggregatorFee: dexhunter_fee, frontendFee: partner_fee, netPrice: reverse(reversed, net_price), priceImpact: toPriceImpact(splits ?? []), totalFee: Number( (batcher_fee + dexhunter_fee + partner_fee).toFixed( primaryTokenInfo.decimals, ), ), totalOutput: total_output, totalOutputWithoutSlippage: total_output, splits: splits?.map(toSwapSplit) ?? [], totalInput: (total_input || splits?.reduce((acc, cur) => acc + (cur.amount_in ?? 0), 0)) ?? undefined, }), }, limitBuild: { request: ({ amountIn, blockedProtocols, protocol, multiples, tokenIn, tokenOut, wantedPrice, }: Swap.CreateRequest): LimitBuildRequest => ({ multiples, buyer_address: address, amount_in: amountIn, wanted_price: isPrimaryToken(tokenIn) && wantedPrice !== undefined && wantedPrice !== 0 ? 1 / wantedPrice : wantedPrice, token_in: toTokenId(tokenIn), token_out: toTokenId(tokenOut), blacklisted_dexes: blockedProtocols ?.map(fromSwapProtocol) .filter(isDex), dex: protocol ? fromSwapProtocol(protocol) : undefined, }), response: ( { cbor = '', batcher_fee = 0, deposits = 0, dexhunter_fee = 0, partner_fee = 0, splits, total_input = 0, total_output = 0, }: LimitBuildResponse, reversed: boolean, ): Swap.CreateResponse => ({ cbor, deposits, aggregator: Swap.Aggregator.Dexhunter, batcherFee: batcher_fee, aggregatorFee: dexhunter_fee, frontendFee: partner_fee / 10 ** primaryTokenInfo.decimals, netPrice: reverse(reversed, splits?.[0]?.initial_price ?? 0), totalOutput: total_output, totalOutputWithoutSlippage: total_output, priceImpact: toPriceImpact(splits ?? []), totalFee: Number( ( batcher_fee + dexhunter_fee + partner_fee / 10 ** primaryTokenInfo.decimals ).toFixed(primaryTokenInfo.decimals), ), splits: splits?.map(toSwapSplit) ?? [], totalInput: (total_input || splits?.reduce((acc, cur) => acc + (cur.amount_in ?? 0), 0)) ?? 0, }), }, build: { request: ({ slippage = 0, amountIn, blockedProtocols, tokenIn, tokenOut, inputs, }: Swap.CreateRequest): BuildRequest => ({ slippage, amount_in: amountIn, buyer_address: address, blacklisted_dexes: blockedProtocols ?.map(fromSwapProtocol) .filter(isDex), token_in: toTokenId(tokenIn), token_out: toTokenId(tokenOut), inputs, }), response: ( { splits, cbor = '', batcher_fee = 0, deposits = 0, dexhunter_fee = 0, net_price = 0, net_price_reverse = 0, partner_fee = 0, total_input = 0, total_output = 0, total_output_without_slippage = 0, }: BuildResponse, reversed?: boolean, ): Swap.CreateResponse => ({ aggregator: Swap.Aggregator.Dexhunter, cbor, deposits, batcherFee: batcher_fee, aggregatorFee: dexhunter_fee, frontendFee: partner_fee, netPrice: (reversed ? net_price_reverse || reverse(true, splits?.[0]?.initial_price ?? 0) : net_price || splits?.[0]?.initial_price) ?? 0, // main net_price is coming as 0 :( priceImpact: toPriceImpact(splits ?? []), totalOutput: total_output, totalFee: Number( (batcher_fee + dexhunter_fee + partner_fee).toFixed( primaryTokenInfo.decimals, ), ), totalOutputWithoutSlippage: total_output_without_slippage, totalInput: (total_input || splits?.reduce((acc, cur) => acc + (cur.amount_in ?? 0), 0)) ?? 0, splits: splits?.map(toSwapSplit) ?? [], }), }, } as const } export const toSwapProtocol = (dex: Dex): Swap.Protocol => ({ [Dex.Cswap]: Swap.Protocol.Cswap, [Dex.Minswap_v1]: Swap.Protocol.Minswap_v1, [Dex.Minswap_v2]: Swap.Protocol.Minswap_v2, [Dex.Wingriders_v1]: Swap.Protocol.Wingriders_v1, [Dex.Wingriders_v2]: Swap.Protocol.Wingriders_v2, [Dex.Vyfi_v1]: Swap.Protocol.Vyfi_v1, [Dex.Sundaeswap_v1]: Swap.Protocol.Sundaeswap_v1, [Dex.Sundaeswap_v3]: Swap.Protocol.Sundaeswap_v3, [Dex.Splash_v1]: Swap.Protocol.Splash_v1, [Dex.Muesliswap_clp]: Swap.Protocol.Muesliswap_clp, [Dex.Muesliswap_v2]: Swap.Protocol.Muesliswap_v2, [Dex.Unsupported]: Swap.Protocol.Unsupported, })[dex] ?? Swap.Protocol.Unsupported export const fromSwapProtocol = (dex: Swap.Protocol): Dex => ({ [Swap.Protocol.Cswap]: Dex.Cswap, [Swap.Protocol.Minswap_v1]: Dex.Minswap_v1, [Swap.Protocol.Minswap_v2]: Dex.Minswap_v2, [Swap.Protocol.Minswap_stable]: Dex.Unsupported, [Swap.Protocol.Wingriders_v1]: Dex.Wingriders_v1, [Swap.Protocol.Wingriders_v2]: Dex.Wingriders_v2, [Swap.Protocol.Vyfi_v1]: Dex.Vyfi_v1, [Swap.Protocol.Sundaeswap_v1]: Dex.Sundaeswap_v1, [Swap.Protocol.Sundaeswap_v3]: Dex.Sundaeswap_v3, [Swap.Protocol.Splash_v1]: Dex.Splash_v1, [Swap.Protocol.Teddy_v1]: Dex.Unsupported, [Swap.Protocol.Muesliswap_v2]: Dex.Muesliswap_v2, [Swap.Protocol.Muesliswap_clp]: Dex.Muesliswap_clp, [Swap.Protocol.Spectrum_v1]: Dex.Unsupported, [Swap.Protocol.Unsupported]: Dex.Unsupported, })[dex] ?? Dex.Unsupported export const DexhunterProtocols = Object.values(Dex) .filter((p) => p !== Dex.Unsupported) .map(toSwapProtocol) export const reverse = (reversed: boolean, price: number) => !reversed || price === 0 || price === undefined ? price : 1 / price