@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,34 @@
+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

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

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

@@ -0,0 +1,92 @@
+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);
+    });
+});

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

@@ -0,0 +1,31 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { SwapperConfig, SwapSource, TradeQuote, TradeRate } from '../types.js';
+import { SwapperName } from '../types.js';
+import type { ThorTradeQuote, ThorTradeRate } from './types.js';
+import { TradeType } from './types.js';
+export * from './checkTradeStatus.js';
+export * from './getInboundAddressDataForChain.js';
+export * from './memo/index.js';
+export * from './routerCallData/routerCalldata.js';
+export * from './service.js';
+export * from './types.js';
+export * from './getL1RateOrQuote.js';
+export * from './getPoolDetails.js';
+export * as cosmossdk from './cosmossdk/index.js';
+export * as evm from './evm/index.js';
+export * as tron from './tron/index.js';
+export * as utxo from './utxo/index.js';
+export declare const getChainIdBySwapper: (swapperName: SwapperName) => import("@shapeshiftoss/caip").ChainId;
+export declare const isThorTradeRate: (quote: TradeRate | undefined) => quote is ThorTradeRate;
+export declare const isThorTradeQuote: (quote: TradeQuote | undefined) => quote is ThorTradeQuote;
+export declare const getDaemonUrl: (config: SwapperConfig, swapperName: SwapperName) => string;
+export declare const getMidgardUrl: (config: SwapperConfig, swapperName: SwapperName) => string;
+export declare const isNativeAsset: (assetId: AssetId, swapperName: SwapperName) => boolean;
+export declare const getNativePrecision: (assetId: AssetId, swapperName: SwapperName) => 10 | 8;
+export declare const getNativeFee: (swapperName: SwapperName) => "2000000" | "2000000000";
+export declare const getAffiliate: (swapperName: SwapperName) => "ss" | "ssmaya";
+export declare const getPoolAssetId: ({ assetId, swapperName, }: {
+    assetId: AssetId;
+    swapperName: SwapperName;
+}) => string | undefined;
+export declare const getSwapSource: (tradeType: TradeType, isStreaming: boolean, swapperName: SwapperName) => SwapSource;

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

@@ -0,0 +1,132 @@
+import { mayachainAssetId, mayachainChainId, thorchainChainId } from '@shapeshiftoss/caip';
+import * as adapters from '@shapeshiftoss/chain-adapters';
+import { assetIdToMayaPoolAssetId, CACAO_PRECISION, isCacao, MAYACHAIN_AFFILIATE_NAME, MAYACHAIN_PRECISION, MAYACHAIN_STREAM_SWAP_SOURCE, } from '../swappers/MayachainSwapper/index.js';
+import { assetIdToThorPoolAssetId, isRune, THORCHAIN_AFFILIATE_NAME, THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE, THORCHAIN_LONGTAIL_SWAP_SOURCE, THORCHAIN_PRECISION, THORCHAIN_STREAM_SWAP_SOURCE, } from '../swappers/ThorchainSwapper/index.js';
+import { SwapperName } from '../types.js';
+import { TradeType } from './types.js';
+export * from './checkTradeStatus.js';
+export * from './getInboundAddressDataForChain.js';
+export * from './memo/index.js';
+export * from './routerCallData/routerCalldata.js';
+export * from './service.js';
+export * from './types.js';
+export * from './getL1RateOrQuote.js';
+export * from './getPoolDetails.js';
+export * as cosmossdk from './cosmossdk/index.js';
+export * as evm from './evm/index.js';
+export * as tron from './tron/index.js';
+export * as utxo from './utxo/index.js';
+export const getChainIdBySwapper = (swapperName) => {
+    switch (swapperName) {
+        case SwapperName.Thorchain:
+            return thorchainChainId;
+        case SwapperName.Mayachain:
+            return mayachainChainId;
+        default:
+            throw new Error(`Invalid swapper: ${swapperName}`);
+    }
+};
+export const isThorTradeRate = (quote) => !!quote && 'tradeType' in quote && 'vault' in quote;
+export const isThorTradeQuote = (quote) => !!quote && 'tradeType' in quote && 'vault' in quote;
+export const getDaemonUrl = (config, swapperName) => {
+    switch (swapperName) {
+        case SwapperName.Thorchain:
+            return `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;
+        case SwapperName.Mayachain:
+            return `${config.VITE_MAYACHAIN_NODE_URL}/mayachain`;
+        default:
+            throw new Error(`Invalid swapper: ${swapperName}`);
+    }
+};
+export const getMidgardUrl = (config, swapperName) => {
+    switch (swapperName) {
+        case SwapperName.Thorchain:
+            return config.VITE_THORCHAIN_MIDGARD_URL;
+        case SwapperName.Mayachain:
+            return config.VITE_MAYACHAIN_MIDGARD_URL;
+        default:
+            throw new Error(`Invalid swapper: ${swapperName}`);
+    }
+};
+export const isNativeAsset = (assetId, swapperName) => {
+    switch (swapperName) {
+        case SwapperName.Thorchain:
+            return isRune(assetId);
+        case SwapperName.Mayachain:
+            return isCacao(assetId);
+        default:
+            throw new Error(`Invalid swapper: ${swapperName}`);
+    }
+};
+export const getNativePrecision = (assetId, swapperName) => {
+    switch (swapperName) {
+        case SwapperName.Thorchain:
+            return THORCHAIN_PRECISION;
+        case SwapperName.Mayachain:
+            return assetId === mayachainAssetId ? CACAO_PRECISION : MAYACHAIN_PRECISION;
+        default:
+            throw new Error(`Invalid swapper: ${swapperName}`);
+    }
+};
+export const getNativeFee = (swapperName) => {
+    switch (swapperName) {
+        case SwapperName.Thorchain:
+            return adapters.thorchain.NATIVE_FEE;
+        case SwapperName.Mayachain:
+            return adapters.mayachain.NATIVE_FEE;
+        default:
+            throw new Error(`Invalid swapper: ${swapperName}`);
+    }
+};
+export const getAffiliate = (swapperName) => {
+    switch (swapperName) {
+        case SwapperName.Thorchain:
+            return THORCHAIN_AFFILIATE_NAME;
+        case SwapperName.Mayachain:
+            return MAYACHAIN_AFFILIATE_NAME;
+        default:
+            throw new Error(`Invalid swapper: ${swapperName}`);
+    }
+};
+export const getPoolAssetId = ({ assetId, swapperName, }) => {
+    switch (swapperName) {
+        case SwapperName.Thorchain:
+            return assetIdToThorPoolAssetId({ assetId });
+        case SwapperName.Mayachain:
+            return assetIdToMayaPoolAssetId({ assetId });
+        default:
+            throw new Error(`Invalid swapper: ${swapperName}`);
+    }
+};
+export const getSwapSource = (tradeType, isStreaming, swapperName) => {
+    const swapSources = {
+        [SwapperName.Thorchain]: {
+            streaming: {
+                [TradeType.L1ToLongTail]: THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE,
+                [TradeType.LongTailToL1]: THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE,
+                [TradeType.LongTailToLongTail]: THORCHAIN_LONGTAIL_STREAMING_SWAP_SOURCE,
+                [TradeType.L1ToL1]: THORCHAIN_STREAM_SWAP_SOURCE,
+            },
+            standard: {
+                [TradeType.L1ToLongTail]: THORCHAIN_LONGTAIL_SWAP_SOURCE,
+                [TradeType.LongTailToL1]: THORCHAIN_LONGTAIL_SWAP_SOURCE,
+                [TradeType.LongTailToLongTail]: THORCHAIN_LONGTAIL_SWAP_SOURCE,
+                [TradeType.L1ToL1]: SwapperName.Thorchain,
+            },
+        },
+        [SwapperName.Mayachain]: {
+            streaming: {
+                [TradeType.L1ToL1]: MAYACHAIN_STREAM_SWAP_SOURCE,
+            },
+            standard: {
+                [TradeType.L1ToL1]: SwapperName.Mayachain,
+            },
+        },
+    };
+    const mode = isStreaming ? 'streaming' : 'standard';
+    const swapSource = swapSources[swapperName]?.[mode]?.[tradeType];
+    if (!swapSource) {
+        throw new Error(`No swap source defined: ${{ tradeType, isStreaming, swapperName }}`);
+    }
+    return swapSource;
+};

package/dist/esm/thorchain-utils/memo/addAggregatorAddressToMemo.d.ts

@@ -0,0 +1,12 @@
+type AddAggregatorAddressToMemoArgs = {
+    /**
+     * A THORChain memo, with or without aggregator address.
+     */
+    memo: string;
+    /**
+     * The aggregator address.
+     */
+    aggregatorAddress: string;
+};
+export declare const addAggregatorAddressToMemo: ({ memo, aggregatorAddress, }: AddAggregatorAddressToMemoArgs) => string;
+export {};

package/dist/esm/thorchain-utils/memo/addAggregatorAddressToMemo.js

@@ -0,0 +1,39 @@
+import { MEMO_PART_DELIMITER } from './constants.js';
+export const addAggregatorAddressToMemo = ({ memo, aggregatorAddress, }) => {
+    const memoParts = memo.split(MEMO_PART_DELIMITER);
+    const [action] = memoParts;
+    if (!action)
+        throw new Error(`action is required in memo: ${memo}`);
+    let updatedMemo = memo;
+    switch (action.toLowerCase()) {
+        case 'swap':
+        case '=':
+        case 's': {
+            // SWAP:ASSET:DESTADDR:LIM/INTERVAL/QUANTITY:AFFILIATE:FEE:AGGREGATOR
+            const [, asset, destAddr, limit, affiliate, fee, _aggregatorAddress] = memoParts;
+            if (!_aggregatorAddress) {
+                updatedMemo = `${action}:${asset}:${destAddr}:${limit}:${affiliate || ''}:${fee || ''}:${aggregatorAddress}`;
+            }
+            break;
+        }
+        // No Aggregator for loans
+        case '$+':
+        case 'loan+':
+            throw new Error(`cannot add aggregator to loan memo: ${memo}`);
+        // No Aggregator for loans
+        case '$-':
+        case 'loan-':
+            throw new Error(`cannot add aggregator to loan memo: ${memo}`);
+        // No Aggregator for Add Liquidity / Withdraw Liquidity as of now
+        case 'add':
+        case '+':
+        case 'a':
+        case 'withdraw':
+        case '-':
+        case 'wd':
+            throw new Error(`cannot add aggregator to liquidity memo: ${memo}`);
+        default:
+            throw new Error(`unsupported memo: ${memo}`);
+    }
+    return updatedMemo;
+};

package/dist/esm/thorchain-utils/memo/addFinalAssetAddressToMemo.d.ts

@@ -0,0 +1,15 @@
+type AddFinalAssetContractToMemoArgs = {
+    /**
+     * A THORChain memo, with or without a final asset contract.
+     */
+    memo: string;
+    /**
+     * The final asset address, can be shortened.
+     */
+    finalAssetAddress: string;
+};
+/**
+ * A simple util that adds the final asset contract address to a THORChain memo, if the memo doesn't already have one.
+ */
+export declare const addFinalAssetAddressToMemo: ({ memo, finalAssetAddress, }: AddFinalAssetContractToMemoArgs) => string;
+export {};

package/dist/esm/thorchain-utils/memo/addFinalAssetAddressToMemo.js

@@ -0,0 +1,44 @@
+import { MEMO_PART_DELIMITER } from './constants.js';
+/**
+ * A simple util that adds the final asset contract address to a THORChain memo, if the memo doesn't already have one.
+ */
+export const addFinalAssetAddressToMemo = ({ memo, finalAssetAddress, }) => {
+    const memoParts = memo.split(MEMO_PART_DELIMITER);
+    const [action] = memoParts;
+    if (!action)
+        throw new Error(`action is required in memo: ${memo}`);
+    let updatedMemo = memo;
+    switch (action.toLowerCase()) {
+        case 'swap':
+        case '=':
+        case 's': {
+            // SWAP:ASSET:DESTADDR:LIM/INTERVAL/QUANTITY:AFFILIATE:FEE:AGGREGATOR:FINALASSETCONTRACT
+            const [, asset, destAddr, limit, affiliate, fee, aggregator, _finalAssetAddress] = memoParts;
+            if (!aggregator)
+                throw new Error(`aggregator is required in memo: ${memo}`);
+            if (!_finalAssetAddress) {
+                updatedMemo = `${action}:${asset}:${destAddr}:${limit}:${affiliate || ''}:${fee || ''}:${aggregator}:${finalAssetAddress}`;
+            }
+            break;
+        }
+        // No final asset contract for loans
+        case '$+':
+        case 'loan+':
+            throw new Error(`cannot add final asset contract to loan memo: ${memo}`);
+        // No final asset contract for loans
+        case '$-':
+        case 'loan-':
+            throw new Error(`cannot add final asset contract to loan memo: ${memo}`);
+        // No final asset contract for Add Liquidity / Withdraw Liquidity as of now
+        case 'add':
+        case '+':
+        case 'a':
+        case 'withdraw':
+        case '-':
+        case 'wd':
+            throw new Error(`cannot add final asset contract to liquidity memo: ${memo}`);
+        default:
+            throw new Error(`unsupported memo: ${memo}`);
+    }
+    return updatedMemo;
+};

package/dist/esm/thorchain-utils/memo/addFinalAssetLimitToMemo.d.ts

@@ -0,0 +1,16 @@
+type AddFinalAssetLimitToMemoArgs = {
+    /**
+     * A THORChain memo, with or without a final asset MinOut.
+     */
+    memo: string;
+    /**
+     * The final asset amount out to be added to the memo. THOR Aggregator will use the last two numbers as exponents.
+     */
+    finalAssetLimit: string;
+    affiliate: string;
+};
+/**
+ * A simple util that adds a final asset limit to a THORChain memo, if the memo doesn't already have one.
+ */
+export declare const addFinalAssetLimitToMemo: ({ memo, finalAssetLimit, affiliate: _affiliate, }: AddFinalAssetLimitToMemoArgs) => string;
+export {};

package/dist/esm/thorchain-utils/memo/addFinalAssetLimitToMemo.js

@@ -0,0 +1,47 @@
+import { assertAndProcessMemo } from './assertAndProcessMemo.js';
+import { MEMO_PART_DELIMITER } from './constants.js';
+/**
+ * A simple util that adds a final asset limit to a THORChain memo, if the memo doesn't already have one.
+ */
+export const addFinalAssetLimitToMemo = ({ memo, finalAssetLimit, affiliate: _affiliate, }) => {
+    const memoParts = memo.split(MEMO_PART_DELIMITER);
+    const [action] = memoParts;
+    if (!action)
+        throw new Error(`action is required in memo: ${memo}`);
+    let updatedMemo = memo;
+    switch (action.toLowerCase()) {
+        case 'swap':
+        case '=':
+        case 's': {
+            // SWAP:ASSET:DESTADDR:LIM/INTERVAL/QUANTITY:AFFILIATE:FEE:AGGREGATOR:FINALASSETCONTRACT:FINALASSETLIMIT
+            const [, asset, destAddr, limit, affiliate, fee, aggregator, finalAssetContract, _finalAssetLimit,] = memoParts;
+            if (!aggregator)
+                throw new Error(`aggregator is required in memo: ${memo}`);
+            if (!finalAssetContract)
+                throw new Error(`final asset contract is required in memo: ${memo}`);
+            if (!_finalAssetLimit) {
+                updatedMemo = `${action}:${asset}:${destAddr}:${limit}:${affiliate || ''}:${fee || ''}:${aggregator}:${finalAssetContract}:${finalAssetLimit}`;
+            }
+            break;
+        }
+        // No final asset amount out for loans as of now
+        case '$+':
+        case 'loan+':
+            throw new Error(`cannot add final asset amount out to loan memo: ${memo}`);
+        // No final asset amount out for loans as of now
+        case '$-':
+        case 'loan-':
+            throw new Error(`cannot add final asset amount out to loan memo: ${memo}`);
+        // No final asset amount out for Add Liquidity / Withdraw Liquidity as of now
+        case 'add':
+        case '+':
+        case 'a':
+        case 'withdraw':
+        case '-':
+        case 'wd':
+            throw new Error(`cannot add final asset amount out to liquidity memo: ${memo}`);
+        default:
+            throw new Error(`unsupported memo: ${memo}`);
+    }
+    return assertAndProcessMemo(updatedMemo, _affiliate);
+};

package/dist/esm/thorchain-utils/memo/addLimitToMemo.d.ts

@@ -0,0 +1,18 @@
+type AddLimitToMemoArgs = {
+    /**
+     * A THORChain memo, with or without a limit/MinOut.
+     */
+    memo: string;
+    /**
+     * The limit/minout to be added to the memo. Must be in THOR base unit, or problems.
+     */
+    limit: string;
+    affilate: string;
+};
+/**
+ * A simple util that adds a limit to a THORChain memo, if the memo doesn't already have one.
+ * This is made to be composable, do one thing, and do it well.
+ * If you need to handle slippage concerns, this should be done beforehand, with addLimitToMemo/assertAndProcessMemo being the final steps.
+ */
+export declare const addLimitToMemo: ({ memo, limit, affilate: _affiliate }: AddLimitToMemoArgs) => string;
+export {};

package/dist/esm/thorchain-utils/memo/addLimitToMemo.js

@@ -0,0 +1,55 @@
+import { assertAndProcessMemo } from './assertAndProcessMemo.js';
+import { MEMO_PART_DELIMITER } from './constants.js';
+/**
+ * A simple util that adds a limit to a THORChain memo, if the memo doesn't already have one.
+ * This is made to be composable, do one thing, and do it well.
+ * If you need to handle slippage concerns, this should be done beforehand, with addLimitToMemo/assertAndProcessMemo being the final steps.
+ */
+export const addLimitToMemo = ({ memo, limit, affilate: _affiliate }) => {
+    const memoParts = memo.split(MEMO_PART_DELIMITER);
+    const [action] = memoParts;
+    if (!action)
+        throw new Error(`action is required in memo: ${memo}`);
+    let updatedMemo = memo;
+    switch (action.toLowerCase()) {
+        case 'swap':
+        case '=':
+        case 's': {
+            // SWAP:ASSET:DESTADDR:LIM/INTERVAL/QUANTITY:AFFILIATE:FEE
+            const [, asset, destAddr, _limit, affiliate, fee] = memoParts;
+            if (!_limit) {
+                updatedMemo = `${action}:${asset}:${destAddr}:${limit}:${affiliate || ''}:${fee || ''}`;
+            }
+            break;
+        }
+        case '$+':
+        case 'loan+': {
+            // LOAN+:ASSET:DESTADDR:MINOUT:AFFILIATE:FEE
+            const [, asset, destAddr, _minOut, affiliate, fee] = memoParts;
+            if (!_minOut) {
+                updatedMemo = `${action}:${asset}:${destAddr}:${limit}:${affiliate || ''}:${fee || ''}`;
+            }
+            break;
+        }
+        case '$-':
+        case 'loan-': {
+            // LOAN-:ASSET:DESTADDR:MINOUT
+            const [, asset, destAddr, _minOut] = memoParts;
+            if (!_minOut) {
+                updatedMemo = `${action}:${asset}:${destAddr}:${limit}`;
+            }
+            break;
+        }
+        // No MinOut for Add Liquidity / Withdraw Liquidity as of now
+        case 'add':
+        case '+':
+        case 'a':
+        case 'withdraw':
+        case '-':
+        case 'wd':
+            break;
+        default:
+            throw new Error(`unsupported memo: ${memo}`);
+    }
+    return assertAndProcessMemo(updatedMemo, _affiliate);
+};

package/dist/esm/thorchain-utils/memo/assertAndProcessMemo.d.ts

@@ -0,0 +1,4 @@
+/**
+ * asserts memo is valid and processes the memo to ensure our affiliate code is always present
+ */
+export declare const assertAndProcessMemo: (memo: string, affiliate: string) => string;