@shapeshiftoss/swapper 17.6.3 → 17.6.5

package/dist/esm/swappers/MayachainSwapper/constants.js

@@ -0,0 +1,10 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { SwapperName } from '../../types.js';
+import { assetIdToMayaPoolAssetIdMap } from './utils/poolAssetHelpers/poolAssetHelpers.js';
+export const CACAO_PRECISION = 10;
+export const MAYACHAIN_PRECISION = 8;
+export const MAYACHAIN_AFFILIATE_NAME = 'ssmaya';
+export const MAYACHAIN_SUPPORTED_CHAIN_IDS = [
+    ...new Set(Object.keys(assetIdToMayaPoolAssetIdMap).map(assetId => fromAssetId(assetId).chainId)),
+];
+export const MAYACHAIN_STREAM_SWAP_SOURCE = `${SwapperName.Mayachain} • Streaming`;

package/dist/esm/swappers/MayachainSwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const mayachainApi: SwapperApi;

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

@@ -0,0 +1,65 @@
+import { mayachainAssetId, thorchainAssetId } from '@shapeshiftoss/caip';
+import { checkTradeStatus, cosmossdk, evm, getInboundAddressDataForChain, utxo, } from '../../thorchain-utils/index.js';
+import { SwapperName } from '../../types.js';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getTradeQuote } from './getTradeQuote.js';
+import { getTradeRate } from './getTradeRate.js';
+const swapperName = SwapperName.Mayachain;
+export const mayachainApi = {
+    getTradeRate,
+    getTradeQuote,
+    getUnsignedEvmTransaction: input => evm.getUnsignedEvmTransaction(input, swapperName),
+    getEvmTransactionFees: input => evm.getEvmTransactionFees(input, swapperName),
+    getUnsignedUtxoTransaction: input => utxo.getUnsignedUtxoTransaction(input, swapperName),
+    getUtxoTransactionFees: input => utxo.getUtxoTransactionFees(input, swapperName),
+    getUnsignedCosmosSdkTransaction: async ({ tradeQuote, stepIndex, from, config, assertGetCosmosSdkChainAdapter, }) => {
+        if (!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 = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAsset, feeData } = step;
+        const gas = feeData.chainSpecific.estimatedGasCryptoBaseUnit;
+        const fee = feeData.networkFeeCryptoBaseUnit ?? '0';
+        switch (sellAsset.assetId) {
+            case mayachainAssetId: {
+                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+                const { txToSign } = await adapter.buildDepositTransaction({
+                    accountNumber,
+                    from,
+                    value: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    memo,
+                    chainSpecific: { gas, fee },
+                });
+                return txToSign;
+            }
+            case thorchainAssetId: {
+                const adapter = assertGetCosmosSdkChainAdapter(sellAsset.chainId);
+                const url = `${config.VITE_MAYACHAIN_NODE_URL}/mayachain`;
+                const data = await getInboundAddressDataForChain(url, 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 => cosmossdk.getCosmosSdkTransactionFees(input),
+    checkTradeStatus: input => {
+        const { config } = input;
+        const nodeUrl = `${config.VITE_MAYACHAIN_NODE_URL}/mayachain`;
+        const apiUrl = `${config.VITE_UNCHAINED_MAYACHAIN_HTTP_URL}/api/v1`;
+        return checkTradeStatus({ ...input, nodeUrl, apiUrl, nativeChain: 'MAYA' });
+    },
+};

package/dist/esm/swappers/MayachainSwapper/generated/generatedTradableAssetMap.json

@@ -0,0 +1,25 @@
+{
+    "ARB.ARB-0X912CE59144191C1204E64559FE8253A0E49E6548": "eip155:42161/erc20:0x912ce59144191c1204e64559fe8253a0e49e6548",
+    "ARB.DAI-0XDA10009CBD5D07DD0CECC66161FC93D7C9000DA1": "eip155:42161/erc20:0xda10009cbd5d07dd0cecc66161fc93d7c9000da1",
+    "ARB.ETH": "eip155:42161/slip44:60",
+    "ARB.GLD-0XAFD091F140C21770F4E5D53D26B2859AE97555AA": "eip155:42161/erc20:0xafd091f140c21770f4e5d53d26b2859ae97555aa",
+    "ARB.LEO-0X93864D81175095DD93360FFA2A529B8642F76A6E": "eip155:42161/erc20:0x93864d81175095dd93360ffa2a529b8642f76a6e",
+    "ARB.LINK-0XF97F4DF75117A78C1A5A0DBB814AF92458539FB4": "eip155:42161/erc20:0xf97f4df75117a78c1a5a0dbb814af92458539fb4",
+    "ARB.PEPE-0X25D887CE7A35172C62FEBFD67A1856F20FAEBB00": "eip155:42161/erc20:0x25d887ce7a35172c62febfd67a1856f20faebb00",
+    "ARB.TGT-0X429FED88F10285E61B12BDF00848315FBDFCC341": "eip155:42161/erc20:0x429fed88f10285e61b12bdf00848315fbdfcc341",
+    "ARB.USDC-0XAF88D065E77C8CC2239327C5EDB3A432268E5831": "eip155:42161/erc20:0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+    "ARB.USDT-0XFD086BC7CD5C481DCC9C85EBE478A1C0B69FCBB9": "eip155:42161/erc20:0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
+    "ARB.WBTC-0X2F2A2543B76A4166549F7AAB2E75BEF0AEFC5B0F": "eip155:42161/erc20:0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f",
+    "ARB.WSTETH-0X5979D7B546E38E414F7E9822514BE443A4800529": "eip155:42161/erc20:0x5979d7b546e38e414f7e9822514be443a4800529",
+    "ARB.YUM-0X9F41B34F42058A7B74672055A5FAE22C4B113FD1": "eip155:42161/erc20:0x9f41b34f42058a7b74672055a5fae22c4b113fd1",
+    "BTC.BTC": "bip122:000000000019d6689c085ae165831e93/slip44:0",
+    "ETH.ETH": "eip155:1/slip44:60",
+    "ETH.LLD-0X054C9D4C6F4EA4E14391ADDD1812106C97D05690": "eip155:1/erc20:0x054c9d4c6f4ea4e14391addd1812106c97d05690",
+    "ETH.MOCA-0X53312F85BBA24C8CB99CFFC13BF82420157230D3": "eip155:1/erc20:0x53312f85bba24c8cb99cffc13bf82420157230d3",
+    "ETH.PEPE-0X6982508145454CE325DDBE47A25D4EC3D2311933": "eip155:1/erc20:0x6982508145454ce325ddbe47a25d4ec3d2311933",
+    "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48": "eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    "ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7": "eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7",
+    "ETH.WSTETH-0X7F39C581F595B53C5CB19BD0B3F8DA6C935E2CA0": "eip155:1/erc20:0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0",
+    "THOR.RUNE": "cosmos:thorchain-1/slip44:931",
+    "MAYA.CACAO": "cosmos:mayachain-mainnet-v1/slip44:931"
+}

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

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

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

@@ -0,0 +1,20 @@
+import { Err } from '@sniptt/monads';
+import { getL1RateOrQuote, getPoolDetails, TradeType } from '../../thorchain-utils/index.js';
+import { SwapperName } from '../../types.js';
+import { assertValidTrade } from './utils/index.js';
+export const getTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset } = input;
+    const assertion = assertValidTrade({ buyAsset, sellAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const poolDetails = await getPoolDetails({
+        buyAsset,
+        sellAsset,
+        url: `${deps.config.VITE_MAYACHAIN_NODE_URL}/mayachain/pools`,
+        swapperName: SwapperName.Mayachain,
+    });
+    if (poolDetails.isErr())
+        return Err(poolDetails.unwrapErr());
+    const { streamingInterval } = poolDetails.unwrap();
+    return getL1RateOrQuote(input, deps, streamingInterval, TradeType.L1ToL1, SwapperName.Mayachain);
+};

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

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

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

@@ -0,0 +1,20 @@
+import { Err } from '@sniptt/monads';
+import { getL1RateOrQuote, getPoolDetails, TradeType } from '../../thorchain-utils/index.js';
+import { SwapperName } from '../../types.js';
+import { assertValidTrade } from './utils/index.js';
+export const getTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset } = input;
+    const assertion = assertValidTrade({ buyAsset, sellAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const poolDetails = await getPoolDetails({
+        buyAsset,
+        sellAsset,
+        url: `${deps.config.VITE_MAYACHAIN_NODE_URL}/mayachain/pools`,
+        swapperName: SwapperName.Mayachain,
+    });
+    if (poolDetails.isErr())
+        return Err(poolDetails.unwrapErr());
+    const { streamingInterval } = poolDetails.unwrap();
+    return getL1RateOrQuote(input, deps, streamingInterval, TradeType.L1ToL1, SwapperName.Mayachain);
+};

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

@@ -0,0 +1,4 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+export * from './constants.js';
+export * from './utils/poolAssetHelpers/poolAssetHelpers.js';
+export declare const isCacao: (assetId: AssetId) => boolean;

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

@@ -0,0 +1,4 @@
+import { mayachainAssetId } from '@shapeshiftoss/caip';
+export * from './constants.js';
+export * from './utils/poolAssetHelpers/poolAssetHelpers.js';
+export const isCacao = (assetId) => assetId === mayachainAssetId;

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

@@ -0,0 +1,7 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
+    buyAsset: Asset;
+    sellAsset: Asset;
+}) => Result<boolean, SwapErrorRight>;

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

@@ -0,0 +1,36 @@
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { MAYACHAIN_SUPPORTED_CHAIN_IDS } from '../constants.js';
+import { assetIdToMayaPoolAssetId } from './poolAssetHelpers/poolAssetHelpers.js';
+export const assertValidTrade = ({ buyAsset, sellAsset, }) => {
+    if (!MAYACHAIN_SUPPORTED_CHAIN_IDS.includes(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `[MayachainSwapper: assertValidTrade] - unsupported sell chain`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!MAYACHAIN_SUPPORTED_CHAIN_IDS.includes(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `[MayachainSwapper: assertValidTrade] - unsupported buy chain`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    if (!assetIdToMayaPoolAssetId({ assetId: buyAsset.assetId })) {
+        return Err(makeSwapErrorRight({
+            message: `[MayachainSwapper: assertValidTrade] - unsupported buy asset`,
+            code: TradeQuoteError.UnsupportedTradePair,
+            details: { assetId: buyAsset.assetId },
+        }));
+    }
+    if (!assetIdToMayaPoolAssetId({ assetId: sellAsset.assetId })) {
+        return Err(makeSwapErrorRight({
+            message: `[MayachainSwapper: assertValidTrade] - unsupported sell asset`,
+            code: TradeQuoteError.UnsupportedTradePair,
+            details: { assetId: sellAsset.assetId },
+        }));
+    }
+    return Ok(true);
+};

package/dist/esm/swappers/MayachainSwapper/utils/poolAssetHelpers/poolAssetHelpers.d.ts

@@ -0,0 +1,6 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+export declare const assetIdToMayaPoolAssetIdMap: import("lodash").Dictionary<string>;
+export declare const mayaPoolAssetIdToAssetId: (id: string) => AssetId | undefined;
+export declare const assetIdToMayaPoolAssetId: ({ assetId }: {
+    assetId: AssetId;
+}) => string | undefined;

package/dist/esm/swappers/MayachainSwapper/utils/poolAssetHelpers/poolAssetHelpers.js

@@ -0,0 +1,6 @@
+import invert from 'lodash/invert';
+import generatedTradableAssetMap from '../../generated/generatedTradableAssetMap.json';
+const mayaPoolIdAssetIdSymbolMap = generatedTradableAssetMap;
+export const assetIdToMayaPoolAssetIdMap = invert(mayaPoolIdAssetIdSymbolMap);
+export const mayaPoolAssetIdToAssetId = (id) => mayaPoolIdAssetIdSymbolMap[id.toUpperCase()];
+export const assetIdToMayaPoolAssetId = ({ assetId }) => assetIdToMayaPoolAssetIdMap[assetId.toLowerCase()];

package/dist/esm/swappers/MayachainSwapper/utils/poolAssetHelpers/poolAssetHelpers.test.d.ts

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

package/dist/esm/swappers/MayachainSwapper/utils/poolAssetHelpers/poolAssetHelpers.test.js

@@ -0,0 +1,54 @@
+import { btcAssetId, ethAssetId } from '@shapeshiftoss/caip';
+import { describe, expect, it } from 'vitest';
+import { assetIdToMayaPoolAssetId, mayaPoolAssetIdToAssetId } from './poolAssetHelpers.js';
+describe('poolAssetHelpers', () => {
+    const usdcAssetId = 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
+    describe('mayaPoolAssetIdToAssetId', () => {
+        it('returns Ethereum assetId when poolAssetId is ETH.ETH', () => {
+            const result = mayaPoolAssetIdToAssetId('ETH.ETH');
+            expect(result).toEqual(ethAssetId);
+        });
+        it('returns Bitcoin assetId when poolAssetId is BTC.BTC', () => {
+            const result = mayaPoolAssetIdToAssetId('BTC.BTC');
+            expect(result).toEqual(btcAssetId);
+        });
+        it('returns ERC20 assetId when poolAssetId is in ERC20 format', () => {
+            const result = mayaPoolAssetIdToAssetId('ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48');
+            expect(result).toEqual(usdcAssetId);
+        });
+        it('returns undefined for an asset we dont support', () => {
+            const result = mayaPoolAssetIdToAssetId('BNB.AVA-645');
+            expect(result).toEqual(undefined);
+        });
+        it('returns undefined for an asset that uses asset abbreviations', () => {
+            const result = mayaPoolAssetIdToAssetId('ETH.USDT-ec7');
+            expect(result).toEqual(undefined);
+        });
+    });
+    describe('assetIdToMayaPoolAssetId', () => {
+        it('returns Ethereum pool when assetId is ethAssetId', () => {
+            const assetId = ethAssetId;
+            const result = assetIdToMayaPoolAssetId({ assetId });
+            const poolAssetId = 'ETH.ETH';
+            expect(result).toEqual(poolAssetId);
+        });
+        it('returns bitcoin pool when assetId is btcAssetId', () => {
+            const assetId = btcAssetId;
+            const result = assetIdToMayaPoolAssetId({ assetId });
+            const poolAssetId = 'BTC.BTC';
+            expect(result).toEqual(poolAssetId);
+        });
+        it('returns USDC pool when assetId is usdc', () => {
+            const assetId = usdcAssetId;
+            const result = assetIdToMayaPoolAssetId({ assetId });
+            const poolAssetId = 'ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48';
+            expect(result).toEqual(poolAssetId);
+        });
+        it('returns undefined for an unsupported asset', () => {
+            const assetId = 'foobar';
+            const result = assetIdToMayaPoolAssetId({ assetId });
+            const poolAssetId = undefined;
+            expect(result).toEqual(poolAssetId);
+        });
+    });
+});

package/dist/esm/swappers/PortalsSwapper/PortalsSwapper.d.ts

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types.js';
+export declare const portalsSwapper: Swapper;

package/dist/esm/swappers/PortalsSwapper/PortalsSwapper.js

@@ -0,0 +1,4 @@
+import { executeEvmTransaction } from '../../utils.js';
+export const portalsSwapper = {
+    executeEvmTransaction,
+};

package/dist/esm/swappers/PortalsSwapper/constants.d.ts

@@ -0,0 +1,2 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const chainIdToPortalsNetwork: Partial<Record<KnownChainIds, string>>;

package/dist/esm/swappers/PortalsSwapper/constants.js

@@ -0,0 +1,11 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export const chainIdToPortalsNetwork = {
+    [KnownChainIds.EthereumMainnet]: 'ethereum',
+    [KnownChainIds.AvalancheMainnet]: 'avalanche',
+    [KnownChainIds.OptimismMainnet]: 'optimism',
+    [KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+    [KnownChainIds.PolygonMainnet]: 'polygon',
+    [KnownChainIds.GnosisMainnet]: 'gnosis',
+    [KnownChainIds.ArbitrumMainnet]: 'arbitrum',
+    [KnownChainIds.BaseMainnet]: 'base',
+};

package/dist/esm/swappers/PortalsSwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const portalsApi: SwapperApi;

package/dist/esm/swappers/PortalsSwapper/endpoints.js

@@ -0,0 +1,50 @@
+import { evm } from '@shapeshiftoss/chain-adapters';
+import BigNumber from 'bignumber.js';
+import { checkEvmSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getPortalsTradeQuote } from './getPortalsTradeQuote/getPortalsTradeQuote.js';
+import { getPortalsTradeRate } from './getPortalsTradeRate/getPortalsTradeRate.js';
+export const portalsApi = {
+    getTradeQuote: async (input, { config, assertGetEvmChainAdapter }) => {
+        const tradeQuoteResult = await getPortalsTradeQuote(input, assertGetEvmChainAdapter, config);
+        return tradeQuoteResult.map(tradeQuote => [tradeQuote]);
+    },
+    getTradeRate: async (input, { config, assertGetEvmChainAdapter }) => {
+        const tradeRateResult = await getPortalsTradeRate(input, assertGetEvmChainAdapter, config);
+        return tradeRateResult.map(tradeRate => [tradeRate]);
+    },
+    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { portalsTransactionMetadata, sellAsset } = step;
+        if (!portalsTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        const { value, to, data } = portalsTransactionMetadata;
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return feeData.networkFeeCryptoBaseUnit;
+    },
+    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, portalsTransactionMetadata, sellAsset } = step;
+        if (!portalsTransactionMetadata)
+            throw new Error('Transaction metadata is required');
+        // Portals has a 15% buffer on gas estimations, which may or may not turn out to be more reliable than our "pure" simulations
+        const { value, to, data, gasLimit: estimatedGas } = portalsTransactionMetadata;
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
+        return adapter.buildCustomApiTx({
+            accountNumber,
+            data,
+            from,
+            to,
+            value,
+            ...feeData,
+            // Use the higher amount of the node or the API, as the node doesn't always provide enough gas padding for total gas used.
+            gasLimit: BigNumber.max(feeData.gasLimit, estimatedGas).toFixed(),
+        });
+    },
+    checkTradeStatus: checkEvmSwapStatus,
+};

package/dist/esm/swappers/PortalsSwapper/getPortalsTradeQuote/getPortalsTradeQuote.d.ts

@@ -0,0 +1,5 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { Result } from '@sniptt/monads';
+import type { GetEvmTradeQuoteInputBase, SwapErrorRight, SwapperConfig, TradeQuote } from '../../../types.js';
+export declare function getPortalsTradeQuote(input: GetEvmTradeQuoteInputBase, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, swapperConfig: SwapperConfig): Promise<Result<TradeQuote, SwapErrorRight>>;

package/dist/esm/swappers/PortalsSwapper/getPortalsTradeQuote/getPortalsTradeQuote.js

@@ -0,0 +1,204 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { BigNumber, bn, bnOrZero, convertBasisPointsToDecimalPercentage, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { zeroAddress } from 'viem';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../index.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { getTreasuryAddressFromChainId, isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { chainIdToPortalsNetwork } from '../constants.js';
+import { fetchPortalsTradeOrder, PortalsError } from '../utils/fetchPortalsTradeOrder.js';
+import { isSupportedChainId } from '../utils/helpers.js';
+export async function getPortalsTradeQuote(input, assertGetEvmChainAdapter, swapperConfig) {
+    const { sellAsset, buyAsset, sendAddress, accountNumber, affiliateBps, chainId, supportsEIP1559, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+    const sellAssetChainId = sellAsset.chainId;
+    const buyAssetChainId = buyAsset.chainId;
+    if (!isSupportedChainId(sellAssetChainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!isSupportedChainId(buyAssetChainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (sellAssetChainId !== buyAssetChainId) {
+        return Err(makeSwapErrorRight({
+            message: `cross-chain not supported - both assets must be on chainId ${sellAsset.chainId}`,
+            code: TradeQuoteError.CrossChainNotSupported,
+            details: { buyAsset, sellAsset },
+        }));
+    }
+    // Not a decimal percentage, just a good ol' percentage e.g 1 for 1%
+    const affiliateBpsPercentage = convertBasisPointsToDecimalPercentage(affiliateBps)
+        .times(100)
+        .toNumber();
+    const userSlippageTolerancePercentageDecimalOrDefault = input.slippageTolerancePercentageDecimal
+        ? bnOrZero(input.slippageTolerancePercentageDecimal).times(100).toNumber()
+        : bnOrZero(getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Portals))
+            .times(100)
+            .toNumber();
+    if (!sendAddress)
+        return Err(makeSwapErrorRight({ message: 'missing sendAddress' }));
+    const portalsNetwork = chainIdToPortalsNetwork[chainId];
+    if (!portalsNetwork) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported ChainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: input.chainId },
+        }));
+    }
+    const sellAssetAddress = isNativeEvmAsset(sellAsset.assetId)
+        ? zeroAddress
+        : fromAssetId(sellAsset.assetId).assetReference;
+    const buyAssetAddress = isNativeEvmAsset(buyAsset.assetId)
+        ? zeroAddress
+        : fromAssetId(buyAsset.assetId).assetReference;
+    const inputToken = `${portalsNetwork}:${sellAssetAddress}`;
+    const outputToken = `${portalsNetwork}:${buyAssetAddress}`;
+    try {
+        const maybePortalsTradeOrderResponse = await fetchPortalsTradeOrder({
+            sender: sendAddress,
+            inputToken,
+            outputToken,
+            inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            slippageTolerancePercentage: userSlippageTolerancePercentageDecimalOrDefault,
+            partner: getTreasuryAddressFromChainId(sellAsset.chainId),
+            feePercentage: affiliateBpsPercentage,
+            validate: true,
+            swapperConfig,
+        })
+            .then(res => Ok(res))
+            .catch(async (err) => {
+            if (err instanceof PortalsError) {
+                // We assume a PortalsError was thrown because the slippage tolerance was too high during simulation
+                // So we attempt another (failing) call with autoslippage which will give us the actual expected slippage
+                const portalsExpectedSlippage = await fetchPortalsTradeOrder({
+                    sender: sendAddress,
+                    inputToken,
+                    outputToken,
+                    inputAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    autoSlippage: true,
+                    partner: getTreasuryAddressFromChainId(sellAsset.chainId),
+                    feePercentage: affiliateBpsPercentage,
+                    validate: true,
+                    swapperConfig,
+                })
+                    // This should never happen but could in very rare cases if original call failed on slippage slightly over 2.5% but this one succeeds on slightly under 2.5%
+                    .then(res => res.context.slippageTolerancePercentage)
+                    .catch(err => err.message.match(/Expected slippage is (.*?)%/)?.[1]);
+                // This should never happen as we don't have auto-slippage on for `/portal` as of now (2024-12-06, see https://github.com/shapeshift/web/pull/8293)
+                // But as soon as Portals implement auto-slippage for the estimate endpoint, we will most likely re-enable it, assuming it actually works
+                if (err.message.includes('Auto slippage exceeds'))
+                    return Err(makeSwapErrorRight({
+                        message: err.message,
+                        details: {
+                            expectedSlippage: portalsExpectedSlippage
+                                ? bn(portalsExpectedSlippage).toFixed(2, BigNumber.ROUND_HALF_UP)
+                                : undefined,
+                        },
+                        cause: err,
+                        code: TradeQuoteError.FinalQuoteMaxSlippageExceeded,
+                    }));
+                if (err.message.includes('execution reverted'))
+                    return Err(makeSwapErrorRight({
+                        message: err.message,
+                        details: {
+                            expectedSlippage: portalsExpectedSlippage
+                                ? bn(portalsExpectedSlippage).toFixed(2, BigNumber.ROUND_HALF_UP)
+                                : undefined,
+                        },
+                        cause: err,
+                        code: TradeQuoteError.FinalQuoteExecutionReverted,
+                    }));
+            }
+            return Err(makeSwapErrorRight({
+                message: 'failed to get Portals quote',
+                cause: err,
+                code: TradeQuoteError.NetworkFeeEstimationFailed,
+            }));
+        });
+        if (maybePortalsTradeOrderResponse.isErr())
+            return Err(maybePortalsTradeOrderResponse.unwrapErr());
+        const portalsTradeOrderResponse = maybePortalsTradeOrderResponse.unwrap();
+        const { context: { orderId, outputAmount: buyAmountAfterFeesCryptoBaseUnit, minOutputAmount, target: allowanceContract, feeAmount, gasLimit, feeToken, }, tx, } = portalsTradeOrderResponse;
+        const protocolFeeAsset = feeToken === inputToken ? sellAsset : buyAsset;
+        if (!tx)
+            throw new Error('Portals Tx simulation failed upstream');
+        const inputOutputRate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const adapter = assertGetEvmChainAdapter(chainId);
+        const { average } = await adapter.getGasFeeData();
+        const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
+            ...average,
+            supportsEIP1559: Boolean(supportsEIP1559),
+            // times 1 isn't a mistake, it's just so we can write this comment above to mention that Portals already add a
+            // buffer of ~15% to the gas limit
+            gasLimit: bnOrZero(gasLimit).times(1).toFixed(),
+        });
+        // Don't use Portals' slippageTolerancePercentage field (it's what we requested, not what they applied)
+        // Instead, calculate the actual buffer Portals applied from the amounts
+        const actualBufferDecimal = bnOrZero(buyAmountAfterFeesCryptoBaseUnit)
+            .minus(minOutputAmount)
+            .div(buyAmountAfterFeesCryptoBaseUnit)
+            .toString();
+        // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
+        const buyAmountBeforeSlippageCryptoBaseUnit = bnOrZero(minOutputAmount)
+            .div(bn(1).minus(actualBufferDecimal))
+            .toFixed(0);
+        const slippageTolerancePercentageDecimal = actualBufferDecimal;
+        const tradeQuote = {
+            id: orderId,
+            quoteOrRate: 'quote',
+            receiveAddress: input.receiveAddress,
+            affiliateBps,
+            rate: inputOutputRate,
+            slippageTolerancePercentageDecimal,
+            swapperName: SwapperName.Portals,
+            steps: [
+                {
+                    accountNumber,
+                    allowanceContract,
+                    rate: inputOutputRate,
+                    buyAsset,
+                    sellAsset,
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountBeforeSlippageCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    feeData: {
+                        networkFeeCryptoBaseUnit,
+                        protocolFees: {
+                            [protocolFeeAsset.assetId]: {
+                                amountCryptoBaseUnit: feeAmount,
+                                asset: protocolFeeAsset,
+                                requiresBalance: false,
+                            },
+                        },
+                    },
+                    source: SwapperName.Portals,
+                    // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
+                    estimatedExecutionTimeMs: 0,
+                    portalsTransactionMetadata: tx,
+                },
+            ],
+        };
+        return Ok(tradeQuote);
+    }
+    catch (err) {
+        return Err(makeSwapErrorRight({
+            message: 'failed to get Portals quote',
+            cause: err,
+            code: TradeQuoteError.NetworkFeeEstimationFailed,
+        }));
+    }
+}

package/dist/esm/swappers/PortalsSwapper/getPortalsTradeRate/getPortalsTradeRate.d.ts

@@ -0,0 +1,5 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { Result } from '@sniptt/monads';
+import type { GetEvmTradeRateInput, SwapErrorRight, SwapperConfig, TradeRate } from '../../../types.js';
+export declare function getPortalsTradeRate(input: GetEvmTradeRateInput, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, swapperConfig: SwapperConfig): Promise<Result<TradeRate, SwapErrorRight>>;