@shapeshiftoss/swapper 17.6.3 → 17.6.4

package/dist/cjs/utils.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSolanaSwapStatus = exports.getExecutableTradeStep = exports.isExecutableTradeStep = exports.isExecutableTradeQuote = exports.getInputOutputRate = exports.checkEvmSwapStatus = exports.checkSafeTransactionStatus = exports.createDefaultStatusResponse = exports.executeSolanaTransaction = exports.executeEvmTransaction = exports.getHopByIndex = exports.makeSwapperAxiosServiceMonadic = exports.AsyncResultOf = exports.createCache = exports.createTradeAmountTooSmallErr = exports.makeSwapErrorRight = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const axios_1 = __importDefault(require("axios"));
+const axios_cache_interceptor_1 = require("axios-cache-interceptor");
+const safe_utils_1 = require("./safe-utils");
+const types_1 = require("./types");
+const makeSwapErrorRight = ({ details, cause, code, message, }) => ({
+    name: 'SwapError',
+    message,
+    details,
+    cause,
+    code,
+});
+exports.makeSwapErrorRight = makeSwapErrorRight;
+const createTradeAmountTooSmallErr = (details) => (0, exports.makeSwapErrorRight)({
+    code: types_1.TradeQuoteError.SellAmountBelowMinimum,
+    message: 'Sell amount is too small',
+    details,
+});
+exports.createTradeAmountTooSmallErr = createTradeAmountTooSmallErr;
+const getRequestFilter = (cachedUrls) => (request) => !cachedUrls.some(url => request.url?.includes(url));
+const createCache = (maxAge, cachedUrls, axiosConfig) => {
+    const filter = getRequestFilter(cachedUrls);
+    const axiosInstance = axios_1.default.create(axiosConfig);
+    (0, axios_cache_interceptor_1.setupCache)(axiosInstance, {
+        ttl: maxAge,
+        cachePredicate: cacheResponse => filter(cacheResponse.config),
+        interpretHeader: false,
+        staleIfError: true,
+        cacheTakeover: false,
+    });
+    return axiosInstance;
+};
+exports.createCache = createCache;
+// https://github.com/sniptt-official/monads/issues/111
+const AsyncResultOf = async (promise) => {
+    try {
+        return (0, monads_1.Ok)(await promise);
+    }
+    catch (err) {
+        return (0, monads_1.Err)(err);
+    }
+};
+exports.AsyncResultOf = AsyncResultOf;
+const makeSwapperAxiosServiceMonadic = (service) => new Proxy(service, {
+    get: (trappedAxios, method) => {
+        const originalMethodPromise = trappedAxios[method];
+        return async (...args) => {
+            // getMixPanel()?.track(MixPanelEvent.SwapperApiRequest, {
+            //   swapper: swapperName,
+            //   url: args[0],
+            //   method,
+            // })
+            const result = await (0, exports.AsyncResultOf)(originalMethodPromise(...args));
+            return result
+                .mapErr(e => (0, exports.makeSwapErrorRight)({
+                message: 'makeSwapperAxiosServiceMonadic',
+                cause: e,
+                code: types_1.TradeQuoteError.QueryFailed,
+            }))
+                .andThen(result => {
+                if (!result.data)
+                    return (0, monads_1.Err)((0, exports.makeSwapErrorRight)({
+                        message: 'makeSwapperAxiosServiceMonadic: no data was returned',
+                        cause: result,
+                        code: types_1.TradeQuoteError.QueryFailed,
+                    }));
+                return (0, monads_1.Ok)(result);
+            });
+        };
+    },
+});
+exports.makeSwapperAxiosServiceMonadic = makeSwapperAxiosServiceMonadic;
+const getHopByIndex = (quote, index) => {
+    if (quote === undefined)
+        return undefined;
+    if (index > 1) {
+        throw new Error("Index out of bounds - Swapper doesn't currently support more than 2 hops.");
+    }
+    const hop = quote.steps[index];
+    return hop;
+};
+exports.getHopByIndex = getHopByIndex;
+const executeEvmTransaction = (txToSign, callbacks) => {
+    return callbacks.signAndBroadcastTransaction(txToSign);
+};
+exports.executeEvmTransaction = executeEvmTransaction;
+const executeSolanaTransaction = (txToSign, callbacks) => {
+    return callbacks.signAndBroadcastTransaction(txToSign);
+};
+exports.executeSolanaTransaction = executeSolanaTransaction;
+const createDefaultStatusResponse = (buyTxHash) => ({
+    status: unchained_client_1.TxStatus.Unknown,
+    buyTxHash,
+    message: undefined,
+});
+exports.createDefaultStatusResponse = createDefaultStatusResponse;
+const checkSafeTransactionStatus = async ({ address, txHash, chainId, assertGetEvmChainAdapter, fetchIsSmartContractAddressQuery, }) => {
+    const { isExecutedSafeTx, isQueuedSafeTx, transaction } = await (0, safe_utils_1.fetchSafeTransactionInfo)({
+        address,
+        chainId,
+        fetchIsSmartContractAddressQuery,
+        safeTxHash: txHash,
+    });
+    if (!transaction)
+        return;
+    // SAFE proposal queued, but not executed on-chain yet
+    if (isQueuedSafeTx) {
+        return {
+            status: unchained_client_1.TxStatus.Pending,
+            message: [
+                'common.safeProposalQueued',
+                {
+                    currentConfirmations: transaction.confirmations?.length,
+                    confirmationsRequired: transaction.confirmationsRequired,
+                },
+            ],
+            buyTxHash: undefined,
+        };
+    }
+    // Transaction executed on-chain
+    if (isExecutedSafeTx) {
+        const adapter = assertGetEvmChainAdapter(chainId);
+        const tx = await adapter.httpProvider.getTransaction({ txid: transaction.transactionHash });
+        const status = unchained_client_1.evm.getTxStatus(tx);
+        return {
+            status,
+            buyTxHash: transaction.transactionHash,
+            message: 'common.safeProposalExecuted',
+        };
+    }
+};
+exports.checkSafeTransactionStatus = checkSafeTransactionStatus;
+const checkEvmSwapStatus = async ({ txHash, chainId, address, assertGetEvmChainAdapter, fetchIsSmartContractAddressQuery, }) => {
+    try {
+        const maybeSafeTransactionStatus = await (0, exports.checkSafeTransactionStatus)({
+            address,
+            txHash,
+            fetchIsSmartContractAddressQuery,
+            chainId,
+            assertGetEvmChainAdapter,
+        });
+        if (maybeSafeTransactionStatus)
+            return maybeSafeTransactionStatus;
+        const adapter = assertGetEvmChainAdapter(chainId);
+        const tx = await adapter.httpProvider.getTransaction({ txid: txHash });
+        const status = unchained_client_1.evm.getTxStatus(tx);
+        return {
+            status,
+            buyTxHash: txHash,
+            message: undefined,
+        };
+    }
+    catch (e) {
+        console.error(e);
+        return (0, exports.createDefaultStatusResponse)(txHash);
+    }
+};
+exports.checkEvmSwapStatus = checkEvmSwapStatus;
+const getInputOutputRate = ({ sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit, sellAsset, buyAsset, }) => {
+    const sellAmountCryptoHuman = (0, utils_1.fromBaseUnit)(sellAmountCryptoBaseUnit, sellAsset.precision);
+    const buyAmountCryptoHuman = (0, utils_1.fromBaseUnit)(buyAmountCryptoBaseUnit, buyAsset.precision);
+    return (0, utils_1.bn)(buyAmountCryptoHuman).div(sellAmountCryptoHuman).toFixed();
+};
+exports.getInputOutputRate = getInputOutputRate;
+const isExecutableTradeQuote = (quote) => quote.quoteOrRate === 'quote';
+exports.isExecutableTradeQuote = isExecutableTradeQuote;
+const isExecutableTradeStep = (step) => step.accountNumber !== undefined;
+exports.isExecutableTradeStep = isExecutableTradeStep;
+const getExecutableTradeStep = (tradeQuote, stepIndex) => {
+    const step = (0, exports.getHopByIndex)(tradeQuote, stepIndex);
+    if (!step)
+        throw new Error(`No hop found for stepIndex ${stepIndex}`);
+    if (!(0, exports.isExecutableTradeStep)(step))
+        throw Error('Unable to execute a trade rate step');
+    return step;
+};
+exports.getExecutableTradeStep = getExecutableTradeStep;
+const checkSolanaSwapStatus = async ({ txHash, address, assertGetSolanaChainAdapter, }) => {
+    try {
+        if (!address)
+            throw new Error('Missing address');
+        const adapter = assertGetSolanaChainAdapter(caip_1.solanaChainId);
+        const tx = await adapter.httpProvider.getTransaction({ txid: txHash });
+        const status = await adapter.getTxStatus(tx, address);
+        return {
+            status,
+            buyTxHash: txHash,
+            message: undefined,
+        };
+    }
+    catch (e) {
+        console.error(e);
+        return (0, exports.createDefaultStatusResponse)(txHash);
+    }
+};
+exports.checkSolanaSwapStatus = checkSolanaSwapStatus;