@shapeshiftoss/swapper 17.7.2 → 17.8.0

package/dist/esm/swappers/SunioSwapper/utils/buildSwapTransaction.js

@@ -1,53 +0,0 @@
-import { TronWeb } from 'tronweb';
-import { SUNIO_SMART_ROUTER_CONTRACT } from './constants.js';
-const convertAddressesToEvmFormat = (value) => {
-    if (Array.isArray(value)) {
-        return value.map(v => convertAddressesToEvmFormat(v));
-    }
-    if (typeof value === 'string' && value.startsWith('T') && TronWeb.isAddress(value)) {
-        const hex = TronWeb.address.toHex(value);
-        return hex.replace(/^41/, '0x');
-    }
-    return value;
-};
-export const buildSunioSwapTransaction = async (args) => {
-    const { route, from, to, sellAmountCryptoBaseUnit, minBuyAmountCryptoBaseUnit, rpcUrl, deadline, } = args;
-    const tronWeb = new TronWeb({
-        fullHost: rpcUrl,
-    });
-    const path = route.tokens;
-    const poolVersion = route.poolVersions;
-    const versionLen = Array(poolVersion.length).fill(2);
-    const fees = route.poolFees.map(fee => Number(fee));
-    const swapData = {
-        amountIn: sellAmountCryptoBaseUnit,
-        amountOutMin: minBuyAmountCryptoBaseUnit,
-        recipient: to,
-        deadline: deadline ?? Math.floor(Date.now() / 1000) + 60 * 20,
-    };
-    const parameters = [
-        { type: 'address[]', value: path },
-        { type: 'string[]', value: poolVersion },
-        { type: 'uint256[]', value: versionLen },
-        { type: 'uint24[]', value: fees },
-        {
-            type: 'tuple(uint256,uint256,address,uint256)',
-            value: convertAddressesToEvmFormat([
-                swapData.amountIn,
-                swapData.amountOutMin,
-                swapData.recipient,
-                swapData.deadline,
-            ]),
-        },
-    ];
-    const functionSelector = 'swapExactInput(address[],string[],uint256[],uint24[],(uint256,uint256,address,uint256))';
-    const options = {
-        feeLimit: 100_000_000,
-        callValue: 0,
-    };
-    const txData = await tronWeb.transactionBuilder.triggerSmartContract(SUNIO_SMART_ROUTER_CONTRACT, functionSelector, options, parameters, from);
-    if (!txData.result || !txData.result.result) {
-        throw new Error('[Sun.io] Failed to build swap transaction');
-    }
-    return txData.transaction;
-};

package/dist/esm/thorchain-utils/getThresholdedAffiliateBps/getThresholdedAffiliateBps.d.ts

@@ -1,11 +0,0 @@
-import type { Asset } from '@shapeshiftoss/types';
-import type { SwapperConfig, SwapperName } from '../../types.js';
-export declare const getOutboundFeeInSellAssetThorBaseUnit: (runePerAsset: string, swapperName: SwapperName) => BigNumber;
-export declare const getExpectedAffiliateFeeSellAssetThorUnit: (sellAmountCryptoBaseUnit: string, sellAsset: Asset, affiliateBps: string, swapperName: SwapperName) => BigNumber;
-export declare const getThresholdedAffiliateBps: ({ sellAsset, affiliateBps, sellAmountCryptoBaseUnit, config, swapperName, }: {
-    sellAsset: Asset;
-    affiliateBps: string;
-    sellAmountCryptoBaseUnit: string;
-    config: SwapperConfig;
-    swapperName: SwapperName;
-}) => Promise<string>;

package/dist/esm/thorchain-utils/getThresholdedAffiliateBps/getThresholdedAffiliateBps.js

@@ -1,34 +0,0 @@
-import { bn, convertBasisPointsToDecimalPercentage, convertPrecision } from '@shapeshiftoss/utils';
-import { getMidgardUrl, getNativeFee, getNativePrecision, getPoolAssetId, isNativeAsset, thorService, } from '../index.js';
-export const getOutboundFeeInSellAssetThorBaseUnit = (runePerAsset, swapperName) => {
-    return bn(getNativeFee(swapperName)).dividedBy(runePerAsset);
-};
-export const getExpectedAffiliateFeeSellAssetThorUnit = (sellAmountCryptoBaseUnit, sellAsset, affiliateBps, swapperName) => {
-    const sellAmountThorUnit = convertPrecision({
-        value: sellAmountCryptoBaseUnit,
-        inputExponent: sellAsset.precision,
-        outputExponent: getNativePrecision(sellAsset.assetId, swapperName),
-    });
-    const affiliatePercent = convertBasisPointsToDecimalPercentage(affiliateBps);
-    return sellAmountThorUnit.times(affiliatePercent);
-};
-// don't apply an affiliate fee if it's below the outbound fee for the inbound pool
-export const getThresholdedAffiliateBps = async ({ sellAsset, affiliateBps, sellAmountCryptoBaseUnit, config, swapperName, }) => {
-    const midgardUrl = getMidgardUrl(config, swapperName);
-    const outboundFeeSellAssetThorUnit = await (async () => {
-        if (isNativeAsset(sellAsset.assetId, swapperName))
-            return getNativeFee(swapperName);
-        const sellPoolId = getPoolAssetId({ assetId: sellAsset.assetId, swapperName });
-        // get pool data for the sell asset
-        const res = await thorService.get(`${midgardUrl}/pool/${sellPoolId}`);
-        if (res.isErr())
-            throw res.unwrapErr();
-        const pool = res.unwrap().data;
-        // calculate the rune outbound fee denominated in the sell asset, in native units
-        return getOutboundFeeInSellAssetThorBaseUnit(pool.assetPrice, swapperName);
-    })();
-    // calculate the expected affiliate fee, in native units
-    const expectedAffiliateFeeSellAssetThorUnit = getExpectedAffiliateFeeSellAssetThorUnit(sellAmountCryptoBaseUnit, sellAsset, affiliateBps, swapperName);
-    const isAffiliateFeeBelowOutboundFee = expectedAffiliateFeeSellAssetThorUnit.lte(outboundFeeSellAssetThorUnit);
-    return isAffiliateFeeBelowOutboundFee ? '0' : affiliateBps;
-};

package/dist/esm/thorchain-utils/getThresholdedAffiliateBps/getThresholdedAffiliateBps.test.d.ts

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

package/dist/esm/thorchain-utils/getThresholdedAffiliateBps/getThresholdedAffiliateBps.test.js

@@ -1,92 +0,0 @@
-import { thorchain } from '@shapeshiftoss/chain-adapters';
-import { bn } from '@shapeshiftoss/utils';
-import { Ok } from '@sniptt/monads';
-import { describe, expect, it, vi } from 'vitest';
-import { ETH } from '../../swappers/utils/test-data/index.js';
-import { SwapperName } from '../../types.js';
-import { thorService } from '../service.js';
-import { getExpectedAffiliateFeeSellAssetThorUnit, getOutboundFeeInSellAssetThorBaseUnit, getThresholdedAffiliateBps, } from './getThresholdedAffiliateBps.js';
-const mockedThorService = vi.mocked(thorService);
-const mocks = vi.hoisted(() => ({
-    get: vi.fn(),
-    post: vi.fn(),
-}));
-vi.mock('../service', () => {
-    const mockAxios = {
-        default: {
-            create: vi.fn(() => ({
-                get: mocks.get,
-                post: mocks.post,
-            })),
-        },
-    };
-    return {
-        thorService: mockAxios.default.create(),
-    };
-});
-describe('getOutboundFeeInSellAssetThorBaseUnit', () => {
-    it('should return 0.02 rune denominated in the target asset, in thor units', () => {
-        const assetPricePrecision = '4.00000'; // 1 token is 4x as valuable as 1 rune
-        expect(getOutboundFeeInSellAssetThorBaseUnit(assetPricePrecision, SwapperName.Thorchain).toNumber()).toEqual(Number(thorchain.NATIVE_FEE) / 4);
-    });
-});
-describe('getExpectedAffiliateFeeSellAssetThorUnit', () => {
-    it('should return the correct affiliate fee in thor base units', () => {
-        const sellAmountCryptoBaseUnit = '1000000000000000000'; // 1 eth
-        const affiliateBps = '35';
-        const sellAsset = ETH;
-        const result = getExpectedAffiliateFeeSellAssetThorUnit(sellAmountCryptoBaseUnit, sellAsset, affiliateBps, SwapperName.Thorchain);
-        const expectation = bn('100000000').times('0.0035').toFixed(0);
-        expect(result.toFixed(0)).toEqual(expectation);
-    });
-    it('returns 0 when affiliateBps is 0', () => {
-        const sellAmountCryptoBaseUnit = '1000000000000000000'; // 1 eth
-        const affiliateBps = '0';
-        const sellAsset = ETH;
-        const result = getExpectedAffiliateFeeSellAssetThorUnit(sellAmountCryptoBaseUnit, sellAsset, affiliateBps, SwapperName.Thorchain);
-        const expectation = '0';
-        expect(result.toFixed(0)).toEqual(expectation);
-    });
-});
-describe('getThresholdedAffiliateBps', () => {
-    mockedThorService.get.mockImplementation(() => {
-        return Promise.resolve(Ok({
-            data: {
-                assetPrice: '100', // 1 eth = 100 rune
-            },
-        }));
-    });
-    // outbound fee threshold is 0.02 rune.
-    // assuming eth price at 100 rune:
-    // 0.02 rune = 0.02 / 100 = 0.0002 eth
-    // give an affiliate bps of 50 (0.5%):
-    // min input amount = threshold eth / affiliate percentage = 0.0002 eth / 0.5% = 0.04 eth
-    it('should return 0 when the sell amount is less than or equal to the rune outbound fee', async () => {
-        const sellAmountCryptoBaseUnit = '40000000000000000'; // 0.04 eth
-        const affiliateBps = '50'; // 0.5%
-        const sellAsset = ETH;
-        const result = await getThresholdedAffiliateBps({
-            sellAsset,
-            affiliateBps,
-            sellAmountCryptoBaseUnit,
-            config: {},
-            swapperName: SwapperName.Thorchain,
-        });
-        const expectation = '0';
-        expect(result).toEqual(expectation);
-    });
-    it('should return input affiliate bps when the sell amount is greater than the rune outbound fee', async () => {
-        const sellAmountCryptoBaseUnit = '40000000000000001'; // > 0.04 eth
-        const affiliateBps = '50'; // 0.5%
-        const sellAsset = ETH;
-        const result = await getThresholdedAffiliateBps({
-            sellAsset,
-            affiliateBps,
-            sellAmountCryptoBaseUnit,
-            config: {},
-            swapperName: SwapperName.Thorchain,
-        });
-        const expectation = affiliateBps;
-        expect(result).toEqual(expectation);
-    });
-});