@shapeshiftoss/swapper 17.7.3 → 18.1.0

package/dist/cjs/swappers/DebridgeSwapper/utils/getDebridgeStepData.d.ts

@@ -0,0 +1,26 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types';
+import type { DebridgeTx } from './types';
+type BaseArgs = {
+    tx: DebridgeTx;
+    gasLimit: string | undefined;
+    spenderAddress: string;
+    fallbackNetworkFeeCryptoBaseUnit: string | undefined;
+};
+export type GetDebridgeStepDataArgs = StepDataArgs<BaseArgs, {
+    from: string;
+}>;
+type DebridgeRateStepData = {
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+type DebridgeQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getDebridgeStepData(args: Extract<GetDebridgeStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<DebridgeRateStepData, SwapErrorRight>>;
+export declare function getDebridgeStepData(args: Extract<GetDebridgeStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<DebridgeQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/cjs/swappers/DebridgeSwapper/utils/getDebridgeStepData.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDebridgeStepData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+async function getDebridgeStepData(args) {
+    const { tx, gasLimit, spenderAddress, fallbackNetworkFeeCryptoBaseUnit, sellAsset, from, type, input, deps, } = args;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    const transactionData = {
+        type: 'evm',
+        chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+        to: tx.to,
+        data: tx.data,
+        value: tx.value,
+        gasLimit,
+    };
+    const stateOverride = {
+        sellAsset,
+        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        spenderAddress,
+    };
+    if (type === 'rate') {
+        const networkFeeCryptoBaseUnit = await (async () => {
+            try {
+                return await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559,
+                    stateOverride,
+                });
+            }
+            catch {
+                return fallbackNetworkFeeCryptoBaseUnit;
+            }
+        })();
+        const stepData = { networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    try {
+        const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+            adapter,
+            transactionData,
+            from,
+            supportsEIP1559,
+            stateOverride,
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_1.makeNetworkFeeEstimationFailedErr)('getDebridgeStepData', error));
+    }
+}
+exports.getDebridgeStepData = getDebridgeStepData;

package/dist/cjs/swappers/DebridgeSwapper/utils/getDebridgeTradeContext.d.ts

@@ -0,0 +1,17 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { GetDebridgeStepDataArgs } from './getDebridgeStepData';
+import type { DebridgeTradeQuoteInput, DebridgeTradeRateInput } from './types';
+type DebridgeTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetDebridgeStepDataArgs, 'type' | 'input'>;
+};
+export declare const getDebridgeTradeContext: ({ input, deps, senderAddress, recipientAddress, }: {
+    input: DebridgeTradeQuoteInput | DebridgeTradeRateInput;
+    deps: SwapperDeps;
+    senderAddress: string;
+    recipientAddress: string;
+}) => Promise<Result<DebridgeTradeContext, SwapErrorRight>>;
+export {};

package/dist/cjs/swappers/DebridgeSwapper/utils/getDebridgeTradeContext.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDebridgeTradeContext = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const helpers_1 = require("../../../utils/helpers");
+const constant_1 = require("../constant");
+const fetchDebridgeSingleChainTrade_1 = require("./fetchDebridgeSingleChainTrade");
+const fetchDebridgeTrade_1 = require("./fetchDebridgeTrade");
+const helpers_2 = require("./helpers");
+const getDebridgeTradeContext = async ({ input, deps, senderAddress, recipientAddress, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const assertion = (0, helpers_2.assertValidTrade)({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const { sellDebridgeChainId, buyDebridgeChainId } = assertion.unwrap();
+    const affiliateFeePercent = (() => {
+        if (!(0, utils_1.isTreasuryChainId)(sellAsset.chainId))
+            return;
+        const bps = (0, utils_1.bnOrZero)(affiliateBps);
+        if (!bps.isFinite() || bps.lte(0))
+            return;
+        return bps.div(100).toFixed();
+    })();
+    const affiliateFeeRecipient = (() => {
+        if (affiliateFeePercent === undefined)
+            return;
+        try {
+            return (0, helpers_1.getTreasuryAddressFromChainId)(sellAsset.chainId).toLowerCase();
+        }
+        catch (e) {
+            console.error(`[getDebridgeTradeContext] Failed to get treasury address for chainId ${sellAsset.chainId}, affiliate fee will not be applied`, e);
+        }
+    })();
+    const fetchArgs = {
+        input,
+        deps,
+        sellDebridgeChainId,
+        senderAddress,
+        recipientAddress,
+        affiliateFeePercent,
+        affiliateFeeRecipient,
+    };
+    const maybeQuote = sellAsset.chainId === buyAsset.chainId
+        ? await fetchSameChainQuote(fetchArgs)
+        : await fetchCrossChainQuote({ ...fetchArgs, buyDebridgeChainId });
+    if (maybeQuote.isErr())
+        return (0, monads_1.Err)(maybeQuote.unwrapErr());
+    const quote = maybeQuote.unwrap();
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: quote.buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const allowanceContract = (0, chain_adapters_1.isEvmChainId)(sellAsset.chainId) ? quote.tx.to : '';
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: quote.id,
+            rate,
+            swapperName: types_1.SwapperName.Debridge,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: quote.slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            allowanceContract,
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit: quote.buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit: quote.buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            source: types_1.SwapperName.Debridge,
+            estimatedExecutionTimeMs: quote.estimatedExecutionTimeMs,
+            swapperMetadata: {
+                name: 'debridge',
+                isSameChainSwap: quote.isSameChainSwap,
+            },
+        },
+        protocolFees: quote.protocolFees,
+        stepDataArgs: {
+            tx: quote.tx,
+            gasLimit: quote.gasLimit,
+            fallbackNetworkFeeCryptoBaseUnit: quote.fallbackNetworkFeeCryptoBaseUnit,
+            sellAsset,
+            spenderAddress: allowanceContract,
+            from: senderAddress,
+            deps,
+        },
+    });
+};
+exports.getDebridgeTradeContext = getDebridgeTradeContext;
+const fetchCrossChainQuote = async ({ input, deps, sellDebridgeChainId, buyDebridgeChainId, senderAddress, recipientAddress, affiliateFeePercent, affiliateFeeRecipient, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    const maybeQuote = await (0, fetchDebridgeTrade_1.fetchDebridgeTrade)({
+        srcChainId: sellDebridgeChainId,
+        srcChainTokenIn: (0, helpers_2.getDebridgeAssetAddress)(sellAsset.assetId),
+        srcChainTokenInAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        dstChainId: buyDebridgeChainId,
+        dstChainTokenOut: (0, helpers_2.getDebridgeAssetAddress)(buyAsset.assetId),
+        dstChainTokenOutAmount: 'auto',
+        dstChainTokenOutRecipient: recipientAddress,
+        srcChainOrderAuthorityAddress: senderAddress,
+        dstChainOrderAuthorityAddress: recipientAddress,
+        senderAddress,
+        prependOperatingExpenses: 'false',
+        affiliateFeePercent,
+        affiliateFeeRecipient,
+    }, deps.config);
+    if (maybeQuote.isErr())
+        return (0, helpers_2.handleDebridgeError)(maybeQuote.unwrapErr());
+    const { data: quote } = maybeQuote.unwrap();
+    const buyAmountAfterFeesCryptoBaseUnit = quote.estimation.dstChainTokenOut.recommendedAmount;
+    const fixFee = (0, utils_1.bnOrZero)(quote.fixFee).toFixed();
+    const protocolFeeAssetCaipChainId = constant_1.debridgeChainIdToChainId[sellDebridgeChainId.toString()];
+    const protocolFeeAssetIdForFees = protocolFeeAssetCaipChainId
+        ? (0, utils_1.chainIdToFeeAssetId)(protocolFeeAssetCaipChainId)
+        : undefined;
+    const protocolFees = protocolFeeAssetIdForFees && (0, utils_1.bnOrZero)(fixFee).gt(0)
+        ? {
+            [protocolFeeAssetIdForFees]: {
+                amountCryptoBaseUnit: fixFee,
+                asset: (0, utils_1.getBaseAsset)(sellAsset.chainId),
+                requiresBalance: true,
+            },
+        }
+        : {};
+    return (0, monads_1.Ok)({
+        id: quote.orderId,
+        buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        protocolFees,
+        estimatedExecutionTimeMs: quote.order.approximateFulfillmentDelay * 1000,
+        isSameChainSwap: false,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+        tx: quote.tx,
+        gasLimit: quote.estimatedTransactionFee?.details.gasLimit,
+        fallbackNetworkFeeCryptoBaseUnit: quote.estimatedTransactionFee?.total,
+    });
+};
+const fetchSameChainQuote = async ({ input, deps, sellDebridgeChainId, senderAddress, recipientAddress, affiliateFeePercent, affiliateFeeRecipient, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    const slippage = input.slippageTolerancePercentageDecimal
+        ? (0, utils_1.bnOrZero)(input.slippageTolerancePercentageDecimal).times(100).toFixed()
+        : '5';
+    const maybeQuote = await (0, fetchDebridgeSingleChainTrade_1.fetchDebridgeSingleChainTrade)({
+        chainId: sellDebridgeChainId,
+        tokenIn: (0, helpers_2.getDebridgeAssetAddress)(sellAsset.assetId),
+        tokenInAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        tokenOut: (0, helpers_2.getDebridgeAssetAddress)(buyAsset.assetId),
+        tokenOutRecipient: recipientAddress,
+        senderAddress,
+        slippage,
+        affiliateFeePercent,
+        affiliateFeeRecipient,
+    }, deps.config);
+    if (maybeQuote.isErr())
+        return (0, helpers_2.handleDebridgeError)(maybeQuote.unwrapErr());
+    const { data: quote } = maybeQuote.unwrap();
+    const buyAmountAfterFeesCryptoBaseUnit = quote.tokenOut.amount;
+    const protocolFeeAmount = quote.protocolFee ?? '0';
+    const buyAmountBeforeFeesCryptoBaseUnit = protocolFeeAmount === '0'
+        ? buyAmountAfterFeesCryptoBaseUnit
+        : utils_1.BigAmount.fromBaseUnit({
+            value: buyAmountAfterFeesCryptoBaseUnit,
+            precision: buyAsset.precision,
+        })
+            .plus(utils_1.BigAmount.fromBaseUnit({ value: protocolFeeAmount, precision: buyAsset.precision }))
+            .toBaseUnit();
+    const protocolFees = protocolFeeAmount !== '0'
+        ? {
+            [buyAsset.assetId]: {
+                amountCryptoBaseUnit: protocolFeeAmount,
+                asset: {
+                    symbol: quote.tokenOut.symbol,
+                    chainId: buyAsset.chainId,
+                    precision: buyAsset.precision,
+                },
+                requiresBalance: false,
+            },
+        }
+        : {};
+    return (0, monads_1.Ok)({
+        id: (0, uuid_1.v4)(),
+        buyAmountBeforeFeesCryptoBaseUnit,
+        buyAmountAfterFeesCryptoBaseUnit,
+        protocolFees,
+        estimatedExecutionTimeMs: 15_000,
+        isSameChainSwap: true,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
+            (quote.slippage ? (0, utils_1.bnOrZero)(quote.slippage).div(100).toString() : undefined),
+        tx: quote.tx,
+        gasLimit: quote.estimatedTransactionFee?.details.gasLimit,
+        fallbackNetworkFeeCryptoBaseUnit: quote.estimatedTransactionFee?.total,
+    });
+};

package/dist/cjs/swappers/DebridgeSwapper/utils/helpers.d.ts

@@ -0,0 +1,12 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types';
+export declare const getDebridgeAssetAddress: (assetId: string) => string;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    sellDebridgeChainId: number;
+    buyDebridgeChainId: number;
+}, SwapErrorRight>;
+export declare const handleDebridgeError: (error: SwapErrorRight) => Result<never, SwapErrorRight>;

package/dist/cjs/swappers/DebridgeSwapper/utils/helpers.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDebridgeError = exports.assertValidTrade = exports.getDebridgeAssetAddress = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const axios_1 = __importDefault(require("axios"));
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const helpers_1 = require("../../../utils/helpers");
+const constant_1 = require("../constant");
+const types_2 = require("./types");
+const getDebridgeAssetAddress = (assetId) => {
+    if ((0, helpers_1.isNativeEvmAsset)(assetId))
+        return constant_1.DEFAULT_DEBRIDGE_TOKEN_ADDRESS;
+    const { assetReference } = (0, caip_1.fromAssetId)(assetId);
+    return (0, caip_1.isAssetReference)(assetReference) ? viem_1.zeroAddress : assetReference;
+};
+exports.getDebridgeAssetAddress = getDebridgeAssetAddress;
+const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    const sellDebridgeChainId = constant_1.chainIdToDebridgeChainId[sellAsset.chainId];
+    if (sellDebridgeChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `Sell asset chain '${sellAsset.chainId}' not supported by deBridge`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    const buyDebridgeChainId = constant_1.chainIdToDebridgeChainId[buyAsset.chainId];
+    if (buyDebridgeChainId === undefined) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `Buy asset chain '${buyAsset.chainId}' not supported by deBridge`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return (0, monads_1.Ok)({ sellDebridgeChainId, buyDebridgeChainId });
+};
+exports.assertValidTrade = assertValidTrade;
+const handleDebridgeError = (error) => {
+    if (!axios_1.default.isAxiosError(error.cause)) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({ message: 'Unknown error', code: types_1.TradeQuoteError.UnknownError }));
+    }
+    const debridgeError = error.cause?.response?.data;
+    if (!(0, types_2.isDebridgeError)(debridgeError)) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({ message: 'Unknown error', code: types_1.TradeQuoteError.UnknownError }));
+    }
+    const errorMessage = debridgeError.errorMessage ?? debridgeError.message ?? 'Unknown error';
+    return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({ message: errorMessage, code: types_1.TradeQuoteError.UnknownError }));
+};
+exports.handleDebridgeError = handleDebridgeError;

package/dist/cjs/swappers/DebridgeSwapper/utils/types.d.ts

@@ -1,24 +1,9 @@
-import type { Asset } from '@shapeshiftoss/types';
-export type DebridgeTradeBaseParams = {
-    buyAsset: Asset;
-    sellAsset: Asset;
-    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
-    affiliateBps: string;
-};
-export type DebridgeTradeInputParams<T extends 'rate' | 'quote'> = DebridgeTradeBaseParams & {
-    quoteOrRate: T;
-    receiveAddress: T extends 'rate' ? string | undefined : string;
-    sendAddress: T extends 'rate' ? undefined : string;
-    accountNumber: T extends 'rate' ? undefined : number;
-    slippageTolerancePercentageDecimal?: string;
-};
-export type DebridgeTransactionMetadata = {
-    to: string;
-    data: string;
-    value: string;
-    gasLimit?: string;
-    orderId?: string;
-    isSameChainSwap?: boolean;
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../../types';
+export type DebridgeTradeQuoteInput = GetEvmTradeQuoteInput;
+export type DebridgeTradeRateInput = GetEvmTradeRateInput;
+export type DebridgeMetadata = {
+    name: 'debridge';
+    isSameChainSwap: boolean;
 };
 export type DebridgeTokenInfo = {
     address: string;
@@ -139,11 +124,7 @@ export type DebridgeSingleChainTransactionResponse = {
     protocolFee?: string;
     costsDetails: DebridgeSingleChainCostDetail[];
     estimatedTransactionFee?: DebridgeSingleChainEstimatedTransactionFee;
-    tx: {
-        to: string;
-        data: string;
-        value: string;
-    };
+    tx: DebridgeTx;
 };
 export type DebridgeError = {
     errorCode?: number;

package/dist/cjs/swappers/MayachainSwapper/endpoints.js

@@ -1,68 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mayachainApi = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
-const thorchain_utils_1 = require("../../thorchain-utils");
-const types_1 = require("../../types");
-const utils_1 = require("../../utils");
+const cosmossdk_1 = require("../../utils/cosmossdk");
+const evm_1 = require("../../utils/evm");
+const thorchain_1 = require("../../utils/thorchain");
+const utxo_1 = require("../../utils/utxo");
 const getTradeQuote_1 = require("./getTradeQuote");
 const getTradeRate_1 = require("./getTradeRate");
-const swapperName = types_1.SwapperName.Mayachain;
 exports.mayachainApi = {
-    getTradeRate: getTradeRate_1.getTradeRate,
-    getTradeQuote: getTradeQuote_1.getTradeQuote,
-    getUnsignedEvmTransaction: input => thorchain_utils_1.evm.getUnsignedEvmTransaction(input, swapperName),
-    getEvmTransactionFees: input => thorchain_utils_1.evm.getEvmTransactionFees(input, swapperName),
-    getUnsignedUtxoTransaction: input => thorchain_utils_1.utxo.getUnsignedUtxoTransaction(input, swapperName),
-    getUtxoTransactionFees: input => thorchain_utils_1.utxo.getUtxoTransactionFees(input, swapperName),
-    getUnsignedCosmosSdkTransaction: async ({ tradeQuote, stepIndex, from, config, assertGetCosmosSdkChainAdapter, }) => {
-        if (!(0, utils_1.isExecutableTradeQuote)(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const { memo } = tradeQuote;
-        if (!memo)
-            throw new Error('Memo is required');
-        const step = (0, utils_1.getExecutableTradeStep)(tradeQuote, stepIndex);
-        const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, feeData } = step;
-        const gas = feeData.chainSpecific.estimatedGasCryptoBaseUnit;
-        const fee = feeData.networkFeeCryptoBaseUnit ?? '0';
-        switch (sellAsset.assetId) {
-            case caip_1.mayachainAssetId: {
-                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
-                const { txToSign } = await adapter.buildDepositTransaction({
-                    accountNumber,
-                    from,
-                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    memo,
-                    chainSpecific: { gas, fee },
-                });
-                return txToSign;
-            }
-            case caip_1.thorchainAssetId: {
-                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
-                const url = `${config.VITE_MAYACHAIN_NODE_URL}/mayachain`;
-                const data = await (0, thorchain_utils_1.getInboundAddressDataForChain)(url, caip_1.thorchainAssetId, true, swapperName);
-                if (data.isErr())
-                    throw data.unwrapErr();
-                const { address: vault } = data.unwrap();
-                const { txToSign } = await adapter.buildSendApiTransaction({
-                    accountNumber,
-                    from,
-                    to: vault,
-                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    memo,
-                    chainSpecific: { gas, fee },
-                });
-                return txToSign;
-            }
-            default:
-                throw Error(`Unsupported sellAsset: ${sellAsset.assetId}`);
-        }
-    },
-    getCosmosSdkTransactionFees: input => thorchain_utils_1.cosmossdk.getCosmosSdkTransactionFees(input),
+    getTradeRate: (input, deps) => (0, getTradeRate_1.getTradeRate)(input, deps),
+    getTradeQuote: (input, deps) => (0, getTradeQuote_1.getTradeQuote)(input, deps),
+    getUnsignedEvmTransaction: evm_1.getUnsignedEvmTransaction,
+    getEvmTransactionFees: evm_1.getEvmTransactionFees,
+    getUnsignedUtxoTransaction: utxo_1.getUnsignedUtxoTransaction,
+    getUtxoTransactionFees: utxo_1.getUtxoTransactionFees,
+    getUnsignedCosmosSdkTransaction: cosmossdk_1.getUnsignedCosmosSdkTransaction,
+    getCosmosSdkTransactionFees: cosmossdk_1.getCosmosSdkTransactionFees,
     checkTradeStatus: input => {
         const { config } = input;
         const nodeUrl = `${config.VITE_MAYACHAIN_NODE_URL}/mayachain`;
         const apiUrl = `${config.VITE_UNCHAINED_MAYACHAIN_HTTP_URL}/api/v1`;
-        return (0, thorchain_utils_1.checkTradeStatus)({ ...input, nodeUrl, apiUrl, nativeChain: 'MAYA' });
+        return (0, thorchain_1.checkTradeStatus)({ ...input, nodeUrl, apiUrl, nativeChain: 'MAYA' });
     },
 };

package/dist/cjs/swappers/MayachainSwapper/getTradeQuote.d.ts

@@ -1,4 +1,4 @@
 import type { Result } from '@sniptt/monads';
-import type { ThorTradeQuote } from '../../thorchain-utils';
-import type { CommonTradeQuoteInput, SwapErrorRight, SwapperDeps } from '../../types';
-export declare const getTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<ThorTradeQuote[], SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps } from '../../types';
+import type { ThorTradeQuote, ThorTradeQuoteInput } from '../../utils/thorchain';
+export declare const getTradeQuote: (input: ThorTradeQuoteInput, deps: SwapperDeps) => Promise<Result<ThorTradeQuote[], SwapErrorRight>>;

package/dist/cjs/swappers/MayachainSwapper/getTradeQuote.js

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTradeQuote = void 0;
 const monads_1 = require("@sniptt/monads");
-const thorchain_utils_1 = require("../../thorchain-utils");
 const types_1 = require("../../types");
+const thorchain_1 = require("../../utils/thorchain");
 const utils_1 = require("./utils");
 const getTradeQuote = async (input, deps) => {
     const { sellAsset, buyAsset } = input;
     const assertion = (0, utils_1.assertValidTrade)({ buyAsset, sellAsset });
     if (assertion.isErr())
         return (0, monads_1.Err)(assertion.unwrapErr());
-    const poolDetails = await (0, thorchain_utils_1.getPoolDetails)({
+    const poolDetails = await (0, thorchain_1.getPoolDetails)({
         buyAsset,
         sellAsset,
         url: `${deps.config.VITE_MAYACHAIN_NODE_URL}/mayachain/pools`,
@@ -19,6 +19,6 @@ const getTradeQuote = async (input, deps) => {
     if (poolDetails.isErr())
         return (0, monads_1.Err)(poolDetails.unwrapErr());
     const { streamingInterval } = poolDetails.unwrap();
-    return (0, thorchain_utils_1.getL1RateOrQuote)(input, deps, streamingInterval, thorchain_utils_1.TradeType.L1ToL1, types_1.SwapperName.Mayachain);
+    return (0, thorchain_1.getThorL1TradeQuote)(input, deps, streamingInterval, thorchain_1.TradeType.L1ToL1, types_1.SwapperName.Mayachain);
 };
 exports.getTradeQuote = getTradeQuote;

package/dist/cjs/swappers/MayachainSwapper/getTradeRate.d.ts

@@ -1,4 +1,4 @@
 import type { Result } from '@sniptt/monads';
-import type { ThorTradeRate } from '../../thorchain-utils';
-import type { GetTradeRateInput, SwapErrorRight, SwapperDeps } from '../../types';
-export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<ThorTradeRate[], SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps } from '../../types';
+import type { ThorTradeRate, ThorTradeRateInput } from '../../utils/thorchain';
+export declare const getTradeRate: (input: ThorTradeRateInput, deps: SwapperDeps) => Promise<Result<ThorTradeRate[], SwapErrorRight>>;

package/dist/cjs/swappers/MayachainSwapper/getTradeRate.js

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTradeRate = void 0;
 const monads_1 = require("@sniptt/monads");
-const thorchain_utils_1 = require("../../thorchain-utils");
 const types_1 = require("../../types");
+const thorchain_1 = require("../../utils/thorchain");
 const utils_1 = require("./utils");
 const getTradeRate = async (input, deps) => {
     const { sellAsset, buyAsset } = input;
     const assertion = (0, utils_1.assertValidTrade)({ buyAsset, sellAsset });
     if (assertion.isErr())
         return (0, monads_1.Err)(assertion.unwrapErr());
-    const poolDetails = await (0, thorchain_utils_1.getPoolDetails)({
+    const poolDetails = await (0, thorchain_1.getPoolDetails)({
         buyAsset,
         sellAsset,
         url: `${deps.config.VITE_MAYACHAIN_NODE_URL}/mayachain/pools`,
@@ -19,6 +19,6 @@ const getTradeRate = async (input, deps) => {
     if (poolDetails.isErr())
         return (0, monads_1.Err)(poolDetails.unwrapErr());
     const { streamingInterval } = poolDetails.unwrap();
-    return (0, thorchain_utils_1.getL1RateOrQuote)(input, deps, streamingInterval, thorchain_utils_1.TradeType.L1ToL1, types_1.SwapperName.Mayachain);
+    return (0, thorchain_1.getThorL1TradeRate)(input, deps, streamingInterval, thorchain_1.TradeType.L1ToL1, types_1.SwapperName.Mayachain);
 };
 exports.getTradeRate = getTradeRate;

package/dist/cjs/swappers/MayachainSwapper/index.d.ts

@@ -2,3 +2,5 @@ import type { AssetId } from '@shapeshiftoss/caip';
 export * from './constants';
 export * from './utils/poolAssetHelpers/poolAssetHelpers';
 export declare const isCacao: (assetId: AssetId) => boolean;
+export { mayachainApi } from './endpoints';
+export { mayachainSwapper } from './MayachainSwapper';

package/dist/cjs/swappers/MayachainSwapper/index.js

@@ -14,9 +14,13 @@ 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 });
-exports.isCacao = void 0;
+exports.mayachainSwapper = exports.mayachainApi = exports.isCacao = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 __exportStar(require("./constants"), exports);
 __exportStar(require("./utils/poolAssetHelpers/poolAssetHelpers"), exports);
 const isCacao = (assetId) => assetId === caip_1.mayachainAssetId;
 exports.isCacao = isCacao;
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "mayachainApi", { enumerable: true, get: function () { return endpoints_1.mayachainApi; } });
+var MayachainSwapper_1 = require("./MayachainSwapper");
+Object.defineProperty(exports, "mayachainSwapper", { enumerable: true, get: function () { return MayachainSwapper_1.mayachainSwapper; } });

package/dist/cjs/swappers/MayachainSwapper/utils/index.d.ts

@@ -4,4 +4,4 @@ import type { SwapErrorRight } from '../../../types';
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;
     sellAsset: Asset;
-}) => Result<boolean, SwapErrorRight>;
+}) => Result<void, SwapErrorRight>;

package/dist/cjs/swappers/MayachainSwapper/utils/index.js

@@ -35,6 +35,6 @@ const assertValidTrade = ({ buyAsset, sellAsset, }) => {
             details: { assetId: sellAsset.assetId },
         }));
     }
-    return (0, monads_1.Ok)(true);
+    return (0, monads_1.Ok)(undefined);
 };
 exports.assertValidTrade = assertValidTrade;