@shapeshiftoss/swapper 17.6.6 → 17.6.8

package/dist/esm/utils.js

@@ -0,0 +1,262 @@
+import { solanaChainId, starknetChainId, suiChainId } from '@shapeshiftoss/caip';
+import { evm, TxStatus } from '@shapeshiftoss/unchained-client';
+import { bn, fromBaseUnit } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import Axios from 'axios';
+import { setupCache } from 'axios-cache-interceptor';
+import { fetchSafeTransactionInfo } from './safe-utils/index.js';
+import { TradeQuoteError } from './types.js';
+export const makeSwapErrorRight = ({ details, cause, code, message, }) => ({
+    name: 'SwapError',
+    message,
+    details,
+    cause,
+    code,
+});
+export const createTradeAmountTooSmallErr = (details) => makeSwapErrorRight({
+    code: TradeQuoteError.SellAmountBelowMinimum,
+    message: 'Sell amount is too small',
+    details,
+});
+const getRequestFilter = (cachedUrls) => (request) => !cachedUrls.some(url => request.url?.includes(url));
+export const createCache = (maxAge, cachedUrls, axiosConfig) => {
+    const filter = getRequestFilter(cachedUrls);
+    const axiosInstance = Axios.create(axiosConfig);
+    setupCache(axiosInstance, {
+        ttl: maxAge,
+        cachePredicate: cacheResponse => filter(cacheResponse.config),
+        interpretHeader: false,
+        staleIfError: true,
+        cacheTakeover: false,
+    });
+    return axiosInstance;
+};
+// https://github.com/sniptt-official/monads/issues/111
+export const AsyncResultOf = async (promise) => {
+    try {
+        return Ok(await promise);
+    }
+    catch (err) {
+        return Err(err);
+    }
+};
+export 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 AsyncResultOf(originalMethodPromise(...args));
+            return result
+                .mapErr(e => makeSwapErrorRight({
+                message: 'makeSwapperAxiosServiceMonadic',
+                cause: e,
+                code: TradeQuoteError.QueryFailed,
+            }))
+                .andThen(result => {
+                if (!result.data)
+                    return Err(makeSwapErrorRight({
+                        message: 'makeSwapperAxiosServiceMonadic: no data was returned',
+                        cause: result,
+                        code: TradeQuoteError.QueryFailed,
+                    }));
+                return Ok(result);
+            });
+        };
+    },
+});
+export 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;
+};
+export const executeEvmTransaction = (txToSign, callbacks) => {
+    return callbacks.signAndBroadcastTransaction(txToSign);
+};
+export const executeSolanaTransaction = (txToSign, callbacks) => {
+    return callbacks.signAndBroadcastTransaction(txToSign);
+};
+export const executeTronTransaction = (txToSign, callbacks) => {
+    return callbacks.signAndBroadcastTransaction(txToSign);
+};
+export const executeSuiTransaction = (txToSign, callbacks) => {
+    return callbacks.signAndBroadcastTransaction(txToSign);
+};
+export const executeNearTransaction = (txToSign, callbacks) => {
+    return callbacks.signAndBroadcastTransaction(txToSign);
+};
+export const executeStarknetTransaction = (txToSign, callbacks) => {
+    return callbacks.signAndBroadcastTransaction(txToSign);
+};
+export const createDefaultStatusResponse = (buyTxHash) => ({
+    status: TxStatus.Unknown,
+    buyTxHash,
+    message: undefined,
+});
+export const checkSafeTransactionStatus = async ({ address, txHash, chainId, assertGetEvmChainAdapter, fetchIsSmartContractAddressQuery, }) => {
+    const { isExecutedSafeTx, isQueuedSafeTx, transaction } = await fetchSafeTransactionInfo({
+        address,
+        chainId,
+        fetchIsSmartContractAddressQuery,
+        safeTxHash: txHash,
+    });
+    if (!transaction)
+        return;
+    // SAFE proposal queued, but not executed on-chain yet
+    if (isQueuedSafeTx) {
+        return {
+            status: 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 = evm.getTxStatus(tx);
+        return {
+            status,
+            buyTxHash: transaction.transactionHash,
+            message: 'common.safeProposalExecuted',
+        };
+    }
+};
+export const checkEvmSwapStatus = async ({ txHash, chainId, address, assertGetEvmChainAdapter, fetchIsSmartContractAddressQuery, }) => {
+    try {
+        const maybeSafeTransactionStatus = await checkSafeTransactionStatus({
+            address,
+            txHash,
+            fetchIsSmartContractAddressQuery,
+            chainId,
+            assertGetEvmChainAdapter,
+        });
+        if (maybeSafeTransactionStatus)
+            return maybeSafeTransactionStatus;
+        const adapter = assertGetEvmChainAdapter(chainId);
+        const tx = await adapter.httpProvider.getTransaction({ txid: txHash });
+        const status = evm.getTxStatus(tx);
+        return {
+            status,
+            buyTxHash: txHash,
+            message: undefined,
+        };
+    }
+    catch (e) {
+        console.error(e);
+        return createDefaultStatusResponse(txHash);
+    }
+};
+export const getInputOutputRate = ({ sellAmountCryptoBaseUnit, buyAmountCryptoBaseUnit, sellAsset, buyAsset, }) => {
+    const sellAmountCryptoHuman = fromBaseUnit(sellAmountCryptoBaseUnit, sellAsset.precision);
+    const buyAmountCryptoHuman = fromBaseUnit(buyAmountCryptoBaseUnit, buyAsset.precision);
+    return bn(buyAmountCryptoHuman).div(sellAmountCryptoHuman).toFixed();
+};
+export const isExecutableTradeQuote = (quote) => quote.quoteOrRate === 'quote';
+export const isExecutableTradeStep = (step) => step.accountNumber !== undefined;
+export const getExecutableTradeStep = (tradeQuote, stepIndex) => {
+    const step = getHopByIndex(tradeQuote, stepIndex);
+    if (!step)
+        throw new Error(`No hop found for stepIndex ${stepIndex}`);
+    if (!isExecutableTradeStep(step))
+        throw Error('Unable to execute a trade rate step');
+    return step;
+};
+export const checkSolanaSwapStatus = async ({ txHash, address, assertGetSolanaChainAdapter, }) => {
+    try {
+        if (!address)
+            throw new Error('Missing address');
+        const adapter = assertGetSolanaChainAdapter(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 createDefaultStatusResponse(txHash);
+    }
+};
+export const checkSuiSwapStatus = async ({ txHash, address, assertGetSuiChainAdapter, }) => {
+    try {
+        if (!address)
+            throw new Error('Missing address');
+        const adapter = assertGetSuiChainAdapter(suiChainId);
+        const client = adapter.getSuiClient();
+        const txResponse = await client.getTransactionBlock({
+            digest: txHash,
+            options: {
+                showEffects: true,
+                showBalanceChanges: true,
+            },
+        });
+        const status = txResponse.effects?.status?.status === 'success' ? TxStatus.Confirmed : TxStatus.Failed;
+        // Extract actual buy amount from balance changes
+        let actualBuyAmountCryptoBaseUnit;
+        if (txResponse.balanceChanges) {
+            // Balance changes show the net effect on the user's balances
+            // Positive amounts are received, negative are sent
+            const receivedChanges = txResponse.balanceChanges.filter(change => {
+                // The owner field is a discriminated union - check for AddressOwner variant
+                // Handle both object and string cases
+                const ownerAddress = change.owner && typeof change.owner === 'object' && 'AddressOwner' in change.owner
+                    ? change.owner.AddressOwner
+                    : change.owner && typeof change.owner === 'object' && 'ObjectOwner' in change.owner
+                        ? change.owner.ObjectOwner
+                        : null;
+                return ownerAddress === address && Number(change.amount) > 0;
+            });
+            if (receivedChanges.length > 0) {
+                // For swaps, we expect exactly one positive balance change (the buy asset)
+                actualBuyAmountCryptoBaseUnit = receivedChanges[0].amount;
+            }
+        }
+        return {
+            status,
+            buyTxHash: txHash,
+            message: undefined,
+            actualBuyAmountCryptoBaseUnit,
+        };
+    }
+    catch (e) {
+        console.error(e);
+        return createDefaultStatusResponse(txHash);
+    }
+};
+export const checkStarknetSwapStatus = async ({ txHash, assertGetStarknetChainAdapter, }) => {
+    try {
+        const adapter = assertGetStarknetChainAdapter(starknetChainId);
+        const provider = adapter.getStarknetProvider();
+        const receipt = await provider.getTransactionReceipt(txHash);
+        const status = receipt.execution_status === 'SUCCEEDED'
+            ? TxStatus.Confirmed
+            : receipt.execution_status === 'REVERTED'
+                ? TxStatus.Failed
+                : TxStatus.Pending;
+        return {
+            status,
+            buyTxHash: txHash,
+            message: undefined,
+        };
+    }
+    catch (e) {
+        console.error(e);
+        return createDefaultStatusResponse(txHash);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshiftoss/swapper",
-  "version": "17.6.6",
+  "version": "17.6.8",
   "packageManager": "yarn@3.5.0",
   "repository": "https://github.com/shapeshift/web",
   "license": "MIT",
@@ -31,24 +31,25 @@
   },
   "dependencies": {
     "@arbitrum/sdk": "^4.0.1",
+    "@avnu/avnu-sdk": "^4.0.1",
     "@coral-xyz/anchor": "0.29.0",
     "@cowprotocol/app-data": "^2.3.0",
     "@defuse-protocol/one-click-sdk-typescript": "^0.1.1-0.2",
     "@jup-ag/api": "^6.0.30",
     "@shapeshiftoss/bitcoinjs-lib": "7.0.0-shapeshift.0",
-    "@shapeshiftoss/caip": "^8.16.4",
-    "@shapeshiftoss/chain-adapters": "^11.3.5",
-    "@shapeshiftoss/contracts": "^1.0.3",
-    "@shapeshiftoss/hdwallet-core": "1.62.18",
-    "@shapeshiftoss/types": "^8.6.4",
-    "@shapeshiftoss/unchained-client": "^10.14.7",
-    "@shapeshiftoss/utils": "^1.0.3",
+    "@shapeshiftoss/caip": "^8.16.6",
+    "@shapeshiftoss/chain-adapters": "^11.3.7",
+    "@shapeshiftoss/contracts": "^1.0.4",
+    "@shapeshiftoss/hdwallet-core": "1.62.39",
+    "@shapeshiftoss/types": "^8.6.6",
+    "@shapeshiftoss/unchained-client": "^10.14.8",
+    "@shapeshiftoss/utils": "^1.0.5",
     "@sniptt/monads": "^0.5.10",
     "@solana/web3.js": "^1.98.0",
     "@uniswap/sdk-core": "^5.3.1",
     "@uniswap/v3-sdk": "^3.13.1",
     "axios": "^1.13.0",
-    "axios-cache-interceptor": "^1.5.3",
+    "axios-cache-interceptor": "^1.11.1",
     "bignumber.js": "^9.3.1",
     "eip-712": "^1.0.0",
     "ethers": "6.11.1",
@@ -57,7 +58,7 @@
     "mixpanel-browser": "^2.67.0",
     "node-polyglot": "^2.4.0",
     "pretty-ms": "7.0.1",
-    "qs": "^6.10.5",
+    "qs": "^6.14.1",
     "retry-axios": "^2.6.0",
     "uuid": "^9.0.0",
     "viem": "^2.40.3"