@shapeshiftoss/swapper 17.6.6 → 17.6.8

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLimitToMemo = void 0;
+const assertAndProcessMemo_1 = require("./assertAndProcessMemo");
+const constants_1 = require("./constants");
+/**
+ * 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.
+ */
+const addLimitToMemo = ({ memo, limit, affilate: _affiliate }) => {
+    const memoParts = memo.split(constants_1.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 (0, assertAndProcessMemo_1.assertAndProcessMemo)(updatedMemo, _affiliate);
+};
+exports.addLimitToMemo = addLimitToMemo;

package/dist/cjs/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;

package/dist/cjs/thorchain-utils/memo/assertAndProcessMemo.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertAndProcessMemo = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+function assertMemoHasPool(pool, memo) {
+    if (!pool)
+        throw new Error(`pool is required in memo: ${memo}`);
+}
+function assertMemoHasAsset(asset, memo) {
+    if (!asset)
+        throw new Error(`asset is required in memo: ${memo}`);
+}
+function assertMemoHasDestAddr(destAddr, memo) {
+    if (!destAddr)
+        throw new Error(`destination address is required in memo: ${memo}`);
+}
+function assertMemoHasAggregatorAddress(aggregatorAddr, memo) {
+    if (!aggregatorAddr)
+        throw new Error(`aggregator address is required in memo: ${memo}`);
+}
+function assertMemoHasFinalAssetContractAddress(finalAssetContractAddress, memo) {
+    if (!finalAssetContractAddress)
+        throw new Error(`final asset contract address is required in memo: ${memo}`);
+}
+function assertMemoHasPairedAddr(pairedAddr, memo) {
+    if (!pairedAddr)
+        throw new Error(`paired address is required in memo: ${memo}`);
+}
+function assertMemoHasLimit(limit, memo) {
+    if (!limit)
+        throw new Error(`limit is required in memo: ${memo}`);
+}
+function assertMemoHasFinalAssetLimit(finalAssetLimit, memo) {
+    if (!finalAssetLimit)
+        throw new Error(`final asset limit is required in memo: ${memo}`);
+}
+function assertMemoHasBasisPoints(basisPoints, memo) {
+    if (!basisPoints)
+        throw new Error(`basis points is required in memo: ${memo}`);
+}
+function assertMemoHasAction(action, memo) {
+    if (!action)
+        throw new Error(`action is required in memo: ${memo}`);
+}
+const assertIsValidLimit = (limit, memo) => {
+    assertMemoHasLimit(limit, memo);
+    const parts = limit.split('/');
+    const [lim, interval, quantity] = parts;
+    if (parts.length > 1) {
+        if (!(lim && interval && quantity && parts.length === 3))
+            throw new Error(`invalid streaming parameters in memo: ${memo}`);
+        if (!(0, utils_1.bn)(lim).gte(0))
+            throw new Error(`limit must be >= 0 in memo: ${memo}`);
+        if (!(0, utils_1.bn)(interval).gte(0))
+            throw new Error(`interval must be >= 0 in memo: ${memo}`);
+        if (!(0, utils_1.bn)(quantity).gte(0))
+            throw new Error(`quantity must be >= 0 in memo: ${memo}`);
+    }
+    else {
+        if (!(0, utils_1.bn)(limit).gt(0))
+            throw new Error(`positive limit is required in memo: ${memo}`);
+    }
+};
+const assertIsValidFinalAssetLimit = (finalAssetLimit, memo) => {
+    assertMemoHasFinalAssetLimit(finalAssetLimit, memo);
+    if (!(0, utils_1.bn)(finalAssetLimit).gt(0))
+        throw new Error(`positive final asset limit is required in memo: ${memo}`);
+    if (finalAssetLimit.length < 3)
+        throw new Error(`positive final asset limit length should be at least 3 in memo: ${memo}`);
+    if (finalAssetLimit.length > 19)
+        throw new Error(`positive final asset limit length should be maximum 19 in memo: ${memo}`);
+};
+function assertIsValidBasisPoints(basisPoints, memo) {
+    assertMemoHasBasisPoints(basisPoints, memo);
+    if (!(0, utils_1.bn)(basisPoints).isInteger())
+        throw new Error(`basis points must be an integer in memo: ${memo}`);
+    if ((0, utils_1.bn)(basisPoints).lt(0) || (0, utils_1.bn)(basisPoints).gt(10000))
+        throw new Error(`basis points must be between 0-10000 in memo: ${memo}`);
+}
+/**
+ * asserts memo is valid and processes the memo to ensure our affiliate code is always present
+ */
+const assertAndProcessMemo = (memo, affiliate) => {
+    const [action] = memo.split(':');
+    assertMemoHasAction(action, memo);
+    switch (action.toLowerCase()) {
+        case 'swap':
+        case '=':
+        case 's': {
+            // SWAP:ASSET:DESTADDR:LIM/INTERVAL/QUANTITY:AFFILIATE:FEE
+            const [_action, asset, destAddr, limit, , fee, aggregatorAddress, finalAssetAddress, finalAssetAmountOut,] = memo.split(':');
+            assertMemoHasAsset(asset, memo);
+            assertMemoHasDestAddr(destAddr, memo);
+            assertIsValidLimit(limit, memo);
+            // SWAP:ASSET:DESTADDR:LIM:AFFILIATE:FEE:DEXAggregatorAddr:FinalTokenAddr:MinAmountOut|
+            const maybeSwapOutParts = (() => {
+                if (aggregatorAddress || finalAssetAddress || finalAssetAmountOut) {
+                    assertMemoHasAggregatorAddress(aggregatorAddress, memo);
+                    assertMemoHasFinalAssetContractAddress(finalAssetAddress, memo);
+                    assertIsValidFinalAssetLimit(finalAssetAmountOut, memo);
+                    return `:${aggregatorAddress}:${finalAssetAddress}:${finalAssetAmountOut}`;
+                }
+                return '';
+            })();
+            return `${_action}:${asset}:${destAddr}:${limit}:${affiliate}:${fee || 0}${maybeSwapOutParts}`;
+        }
+        case 'add':
+        case '+':
+        case 'a': {
+            const [_action, pool, maybePairedAddr, , fee] = memo.split(':');
+            assertMemoHasPool(pool, memo);
+            // Add Liquidity - ADD:POOL:PAIREDADDR:AFFILIATE:FEE
+            if (pool.includes('.')) {
+                if (maybePairedAddr)
+                    assertMemoHasPairedAddr(maybePairedAddr, memo);
+                return `${_action}:${pool}:${maybePairedAddr ?? ''}:${affiliate}:${fee || 0}`;
+            }
+            // Deposit Savers - ADD:POOL::AFFILIATE:FEE
+            if (pool.includes('/')) {
+                if (maybePairedAddr)
+                    throw new Error('paired address is not supported for saver deposit');
+                return `${_action}:${pool}::${affiliate}:${fee || 0}`;
+            }
+            throw new Error(`invalid pool in memo: ${memo}`);
+        }
+        case 'withdraw':
+        case '-':
+        case 'wd': {
+            const [_action, pool, basisPoints, maybeAsset] = memo.split(':');
+            assertMemoHasPool(pool, memo);
+            assertMemoHasBasisPoints(basisPoints, memo);
+            // Withdraw Liquidity - WITHDRAW:POOL:BASISPOINTS:ASSET
+            if (pool.includes('.')) {
+                if (maybeAsset)
+                    assertMemoHasAsset(maybeAsset, memo);
+                assertIsValidBasisPoints(basisPoints, memo);
+                return `${_action}:${pool}:${basisPoints}:${maybeAsset ?? ''}:${affiliate}:0`;
+            }
+            // Withdraw Savers - WITHDRAW:POOL:BASISPOINTS
+            if (pool.includes('/')) {
+                if (maybeAsset)
+                    throw new Error('asset is not supported for savers withdraw');
+                assertIsValidBasisPoints(basisPoints, memo);
+                return `${_action}:${pool}:${basisPoints}::${affiliate}:0`;
+            }
+            throw new Error(`invalid pool in memo: ${memo}`);
+        }
+        // LOAN+:ASSET:DESTADDR:MINOUT:AFFILIATE:FEE
+        case '$+':
+        case 'loan+': {
+            const [_action, asset, destAddr, minOut, , fee] = memo.split(':');
+            assertMemoHasAsset(asset, memo);
+            assertMemoHasDestAddr(destAddr, memo);
+            return `${_action}:${asset}:${destAddr}:${minOut ?? ''}:${affiliate}:${fee || 0}`;
+        }
+        // LOAN-:ASSET:DESTADDR:MINOUT
+        case '$-':
+        case 'loan-': {
+            const [_action, asset, destAddr, minOut] = memo.split(':');
+            assertMemoHasAsset(asset, memo);
+            assertMemoHasDestAddr(destAddr, memo);
+            return `${_action}:${asset}:${destAddr}:${minOut ?? ''}:${affiliate}:0`;
+        }
+        case 'pool+': {
+            return memo;
+        }
+        case 'pool-': {
+            // RUNEPOOL:BASISPOINTS
+            const [_action, basisPoints] = memo.split(':');
+            assertIsValidBasisPoints(basisPoints, memo);
+            return `${_action}:${basisPoints}:${affiliate}:0`;
+        }
+        case 'tcy': {
+            // TCY:CLAIMADDR
+            const [_action, destAddr] = memo.split(':');
+            assertMemoHasDestAddr(destAddr, memo);
+            // Ensures we strip any additional bits which may not be supported for claim Txs
+            return `${_action}:${destAddr}`;
+        }
+        case 'tcy+': {
+            // TCY+:STAKEADDR
+            const [_action] = memo.split(':');
+            // Ensures we strip any additional bits - a tcy+ Tx only contains tcy+, nothing else
+            return _action;
+        }
+        case 'tcy-': {
+            // TCY-:UNSTAKEADDR
+            const [_action, basisPoints] = memo.split(':');
+            assertIsValidBasisPoints(basisPoints, memo);
+            // Ensures we strip any additional bits which may not be supported for unstake Txs
+            return `${_action}:${basisPoints}`;
+        }
+        default:
+            throw new Error(`unsupported memo: ${memo}`);
+    }
+};
+exports.assertAndProcessMemo = assertAndProcessMemo;

package/dist/cjs/thorchain-utils/memo/constants.d.ts

@@ -0,0 +1 @@
+export declare const MEMO_PART_DELIMITER = ":";

package/dist/cjs/thorchain-utils/memo/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMO_PART_DELIMITER = void 0;
+exports.MEMO_PART_DELIMITER = ':';

package/dist/cjs/thorchain-utils/memo/index.d.ts

@@ -0,0 +1,6 @@
+export * from './addAggregatorAddressToMemo';
+export * from './addFinalAssetAddressToMemo';
+export * from './addFinalAssetLimitToMemo';
+export * from './addLimitToMemo';
+export * from './assertAndProcessMemo';
+export * from './constants';

package/dist/cjs/thorchain-utils/memo/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./addAggregatorAddressToMemo"), exports);
+__exportStar(require("./addFinalAssetAddressToMemo"), exports);
+__exportStar(require("./addFinalAssetLimitToMemo"), exports);
+__exportStar(require("./addLimitToMemo"), exports);
+__exportStar(require("./assertAndProcessMemo"), exports);
+__exportStar(require("./constants"), exports);

package/dist/cjs/thorchain-utils/memo/index.test.d.ts

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