@shapeshiftoss/swapper 17.8.0 → 19.0.0

package/dist/esm/swappers/NearIntentsSwapper/utils/getNearIntentsStepData.js

@@ -0,0 +1,231 @@
+import { CHAIN_NAMESPACE, fromAssetId, fromChainId } from '@shapeshiftoss/caip';
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { bn, contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { makeNetworkFeeEstimationFailedErr, makeSwapErrorRight } from '../../../utils/index.js';
+import { EVM_PLACEHOLDER_ADDRESS, getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
+import { ATA_RENT_LAMPORTS, getSolanaNetworkFeeCryptoBaseUnit, SOLANA_PLACEHOLDER_ADDRESS, withComputeUnitLimit, } from '../../../utils/solana/index.js';
+import { getUtxoNetworkFeeCryptoBaseUnit } from '../../../utils/utxo/index.js';
+// Deposits are plain (token) transfers with constant measured compute consumption (max 15394 CU
+// with ata creation), so the margin is safety only; the floor guarantees the limit covers full
+// ata recreation if the deposit ata is closed between simulation and landing (a no-op create
+// simulates ~3x cheaper than a real one)
+export const NEAR_INTENTS_SOLANA_COMPUTE_BUDGET = {
+    marginMultiplier: 1.1,
+    minComputeUnits: 20_000,
+};
+export async function getNearIntentsStepData(args) {
+    const { deps, type, input, sellAsset, sellAmountCryptoBaseUnit, from, depositAddress } = args;
+    const { chainNamespace } = fromAssetId(sellAsset.assetId);
+    const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
+    try {
+        switch (chainNamespace) {
+            case CHAIN_NAMESPACE.Evm: {
+                const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+                const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+                const transactionData = {
+                    type: 'evm',
+                    chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+                    to: contractAddress ?? depositAddress,
+                    data: evm.getErc20Data(depositAddress, sellAmountCryptoBaseUnit, contractAddress) || '0x',
+                    value: isNativeEvmAsset(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0',
+                };
+                const stateOverride = {
+                    sellAsset,
+                    sellAmountCryptoBaseUnit,
+                };
+                // The deposit is a plain (token) transfer with no approval involved - overridden
+                // estimation still prices an unfunded sender, so rates work walletless via the placeholder
+                if (type === 'rate') {
+                    const networkFeeCryptoBaseUnit = await (async () => {
+                        try {
+                            return await getEvmNetworkFeeCryptoBaseUnit({
+                                adapter,
+                                transactionData,
+                                from: from || EVM_PLACEHOLDER_ADDRESS,
+                                supportsEIP1559,
+                                stateOverride,
+                            });
+                        }
+                        catch {
+                            return undefined;
+                        }
+                    })();
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return Ok(stepData);
+                }
+                const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    transactionData,
+                    from: from || depositAddress,
+                    supportsEIP1559,
+                    stateOverride,
+                });
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            case CHAIN_NAMESPACE.Utxo: {
+                const adapter = deps.assertGetUtxoChainAdapter(sellAsset.chainId);
+                const { networkFeeCryptoBaseUnit } = await getUtxoNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    pubkey: 'xpub' in input ? input.xpub : undefined,
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                });
+                if (type === 'rate') {
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return Ok(stepData);
+                }
+                const stepData = {
+                    transactionData: { type: 'utxo', to: depositAddress, value: sellAmountCryptoBaseUnit },
+                    networkFeeCryptoBaseUnit,
+                };
+                return Ok(stepData);
+            }
+            case CHAIN_NAMESPACE.Solana: {
+                const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                const tokenId = contractAddressOrUndefined(sellAsset.assetId);
+                if (type === 'rate') {
+                    // Rates estimate with a transfer from the send address, or a self transfer from the
+                    // funded placeholder (1 lamport, native shape) when no wallet is connected; fresh
+                    // deposit addresses always need their token account created, so rent is included
+                    const address = from ?? SOLANA_PLACEHOLDER_ADDRESS;
+                    const instructions = await adapter.buildTransferInstructions({
+                        from: address,
+                        to: from ? depositAddress : address,
+                        tokenId: from ? tokenId : undefined,
+                        value: from ? sellAmountCryptoBaseUnit : '1',
+                    });
+                    const { networkFeeCryptoBaseUnit: transactionFeeCryptoBaseUnit } = await getSolanaNetworkFeeCryptoBaseUnit({
+                        adapter,
+                        from: address,
+                        instructions,
+                        tokenId,
+                    });
+                    // The walletless native shape can't include the deposit token account creation
+                    const ataCreationRent = !from && tokenId ? ATA_RENT_LAMPORTS : 0;
+                    const stepData = {
+                        networkFeeCryptoBaseUnit: bn(transactionFeeCryptoBaseUnit)
+                            .plus(ataCreationRent)
+                            .toString(),
+                    };
+                    return Ok(stepData);
+                }
+                const instructions = await adapter.buildTransferInstructions({
+                    from,
+                    to: depositAddress,
+                    tokenId,
+                    value: sellAmountCryptoBaseUnit,
+                });
+                const { networkFeeCryptoBaseUnit, feeData, includeComputeBudget } = await getSolanaNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    from,
+                    instructions,
+                    tokenId,
+                });
+                const transactionData = {
+                    type: 'solana_instructions',
+                    instructions: withComputeUnitLimit({
+                        instructions,
+                        computeUnits: feeData.chainSpecific.computeUnits,
+                        includeComputeBudget,
+                        computeBudget: NEAR_INTENTS_SOLANA_COMPUTE_BUDGET,
+                    }),
+                    addressLookupTableAddresses: [],
+                };
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            case CHAIN_NAMESPACE.Tron: {
+                const { fast } = await deps.assertGetTronChainAdapter(sellAsset.chainId).getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: {
+                        from,
+                        contractAddress: contractAddressOrUndefined(sellAsset.assetId),
+                    },
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return Ok(stepData);
+            }
+            case CHAIN_NAMESPACE.Sui: {
+                if (!from) {
+                    const stepData = { networkFeeCryptoBaseUnit: undefined };
+                    return Ok(stepData);
+                }
+                const { fast } = await deps.assertGetSuiChainAdapter(sellAsset.chainId).getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: {
+                        from,
+                        tokenId: contractAddressOrUndefined(sellAsset.assetId),
+                    },
+                    sendMax: false,
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return Ok(stepData);
+            }
+            case CHAIN_NAMESPACE.Starknet: {
+                if (!from) {
+                    const stepData = { networkFeeCryptoBaseUnit: undefined };
+                    return Ok(stepData);
+                }
+                const { fast } = await deps.assertGetStarknetChainAdapter(sellAsset.chainId).getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: {
+                        from,
+                        tokenContractAddress: contractAddressOrUndefined(sellAsset.assetId),
+                    },
+                    sendMax: false,
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return Ok(stepData);
+            }
+            case CHAIN_NAMESPACE.Near: {
+                if (!from) {
+                    const stepData = { networkFeeCryptoBaseUnit: undefined };
+                    return Ok(stepData);
+                }
+                const { fast } = await deps.assertGetNearChainAdapter(sellAsset.chainId).getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: { from },
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return Ok(stepData);
+            }
+            case CHAIN_NAMESPACE.Ton: {
+                if (!from) {
+                    const stepData = { networkFeeCryptoBaseUnit: undefined };
+                    return Ok(stepData);
+                }
+                const { fast } = await deps.assertGetTonChainAdapter(sellAsset.chainId).getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: {
+                        from,
+                        contractAddress: contractAddressOrUndefined(sellAsset.assetId),
+                    },
+                });
+                const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                return Ok(stepData);
+            }
+            default:
+                return Err(makeSwapErrorRight({
+                    message: `[getNearIntentsStepData] unsupported chain namespace: ${chainNamespace}`,
+                    code: TradeQuoteError.UnsupportedChain,
+                }));
+        }
+    }
+    catch (error) {
+        // Rates are best effort with no provider fee to degrade to; quotes must price to execute
+        if (type === 'rate') {
+            const stepData = { networkFeeCryptoBaseUnit: undefined };
+            return Ok(stepData);
+        }
+        return Err(makeNetworkFeeEstimationFailedErr('getNearIntentsStepData', error));
+    }
+}

package/dist/esm/swappers/NearIntentsSwapper/utils/getNearIntentsTradeContext.d.ts

@@ -0,0 +1,21 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { NearIntentsTradeQuoteInput, NearIntentsTradeRateInput, QuoteResponse } from '../types.js';
+type NearIntentsTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: {
+        deps: SwapperDeps;
+        sellAsset: Asset;
+        sellAmountCryptoBaseUnit: string;
+        depositAddress: string;
+    };
+};
+export declare const getNearIntentsTradeContext: ({ input, deps, quote, }: {
+    input: NearIntentsTradeQuoteInput | NearIntentsTradeRateInput;
+    deps: SwapperDeps;
+    quote: QuoteResponse['quote'];
+}) => Result<NearIntentsTradeContext, SwapErrorRight>;
+export {};

package/dist/esm/swappers/NearIntentsSwapper/utils/getNearIntentsTradeContext.js

@@ -0,0 +1,58 @@
+import { nearChainId } from '@shapeshiftoss/caip';
+import { chainIdToFeeAssetId } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName } from '../../../types.js';
+import { getInputOutputRate, makeTradeStepBuildFailedErr } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+export const getNearIntentsTradeContext = ({ input, deps, quote, }) => {
+    const { sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, slippageTolerancePercentageDecimal, } = input;
+    if (!quote.depositAddress)
+        return Err(makeTradeStepBuildFailedErr('getNearIntentsTradeContext'));
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: quote.amountIn,
+        buyAmountCryptoBaseUnit: quote.amountOut,
+        sellAsset,
+        buyAsset,
+    });
+    return Ok({
+        tradeCommon: {
+            id: uuid(),
+            rate,
+            swapperName: SwapperName.NearIntents,
+            affiliateBps,
+            slippageTolerancePercentageDecimal: slippageTolerancePercentageDecimal ??
+                getDefaultSlippageDecimalPercentageForSwapper(SwapperName.NearIntents),
+        },
+        stepCommon: {
+            allowanceContract: '',
+            buyAmountBeforeFeesCryptoBaseUnit: quote.amountOut,
+            buyAmountAfterFeesCryptoBaseUnit: quote.amountOut,
+            buyAsset,
+            rate,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit: quote.amountIn,
+            sellAsset,
+            source: SwapperName.NearIntents,
+            estimatedExecutionTimeMs: quote.timeEstimate ? quote.timeEstimate * 1000 : undefined,
+            affiliateFee: buildAffiliateFee({
+                strategy: 'fixed_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: quote.amountIn,
+                buyAmountCryptoBaseUnit: quote.amountOut,
+                fixedAssetId: chainIdToFeeAssetId(nearChainId),
+                fixedAsset: deps.assetsById[chainIdToFeeAssetId(nearChainId)],
+                isEstimate: true,
+            }),
+        },
+        protocolFees: {},
+        stepDataArgs: {
+            deps,
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            depositAddress: quote.depositAddress,
+        },
+    });
+};

package/dist/esm/swappers/NearIntentsSwapper/utils/helpers.d.ts

@@ -0,0 +1,40 @@
+import type { Asset } from '@shapeshiftoss/types';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+import type { GetExecutionStatusResponse, QuoteResponse } from '../types.js';
+import { QuoteRequest } from '../types.js';
+export declare const getNearIntentsAsset: ({ nearNetwork, contractAddress, }: {
+    nearNetwork: string;
+    contractAddress: string;
+}) => string;
+export declare const assetToNearIntentsAsset: (asset: Asset) => Promise<string | null>;
+export declare const resolveNearIntentsAssets: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Promise<Result<{
+    originAsset: string;
+    destinationAsset: string;
+}, SwapErrorRight>>;
+export declare const getNearIntentsQuoteDeadline: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => string;
+export declare const buildNearIntentsQuoteRequest: ({ originAsset, destinationAsset, sellAmountCryptoBaseUnit, slippageTolerancePercentageDecimal, affiliateBps, refundTo, recipient, refundType, recipientType, deadline, }: {
+    originAsset: string;
+    destinationAsset: string;
+    sellAmountCryptoBaseUnit: string;
+    slippageTolerancePercentageDecimal: string | undefined;
+    affiliateBps: string;
+    refundTo: string;
+    recipient: string;
+    refundType: QuoteRequest.refundType;
+    recipientType: QuoteRequest.recipientType;
+    deadline: string;
+}) => QuoteRequest;
+export declare const fetchNearIntentsQuote: ({ quoteRequest, sellAsset, }: {
+    quoteRequest: QuoteRequest;
+    sellAsset: Asset;
+}) => Promise<Result<QuoteResponse, SwapErrorRight>>;
+export declare const mapNearIntentsStatus: (status: GetExecutionStatusResponse['status']) => TxStatus;
+export declare const getNearIntentsStatusMessage: (status: GetExecutionStatusResponse['status']) => string | undefined;

package/dist/esm/swappers/NearIntentsSwapper/utils/{helpers/helpers.js → helpers.js}

@@ -1,10 +1,13 @@
-import { ASSOCIATED_PROGRAM_ID } from '@coral-xyz/anchor/dist/cjs/utils/token';
-import { fromAssetId, solanaChainId } from '@shapeshiftoss/caip';
+import { btcChainId, fromAssetId, solanaChainId } from '@shapeshiftoss/caip';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import { bnOrZero, isToken } from '@shapeshiftoss/utils';
+import { bnOrZero, DAO_TREASURY_NEAR, isToken } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
 import { zeroAddress } from 'viem';
-import { chainIdToNearIntentsChain } from '../../types.js';
-import { OneClickService } from '../oneClickService.js';
+import { TradeQuoteError } from '../../../types.js';
+import { createTradeAmountTooSmallErr, makeSwapErrorRight } from '../../../utils/index.js';
+import { BTC_QUOTE_DEADLINE_MS, DEFAULT_QUOTE_DEADLINE_MS, DEFAULT_SLIPPAGE_BPS, } from '../constants.js';
+import { chainIdToNearIntentsChain, QuoteRequest } from '../types.js';
+import { ApiError, OneClickService } from './oneClickService.js';
 const getTokensWithRetry = async () => {
     const maxRetries = 3;
     let lastError = null;
@@ -24,16 +27,6 @@ const getTokensWithRetry = async () => {
     }
     throw lastError ?? new Error('Failed to get tokens after retries');
 };
-const ATA_RENT_LAMPORTS = 2040000;
-export const calculateAccountCreationCosts = (instructions) => {
-    let totalCost = bnOrZero(0);
-    for (const ix of instructions) {
-        if (ix.programId.toString() === ASSOCIATED_PROGRAM_ID.toString()) {
-            totalCost = totalCost.plus(ATA_RENT_LAMPORTS);
-        }
-    }
-    return totalCost.toString();
-};
 export const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
     // Native EVM assets: "nep141:eth.omft.near"
     if (contractAddress === zeroAddress) {
@@ -101,6 +94,105 @@ export const assetToNearIntentsAsset = async (asset) => {
         : zeroAddress;
     return getNearIntentsAsset({ nearNetwork, contractAddress });
 };
+export const resolveNearIntentsAssets = async ({ sellAsset, buyAsset, }) => {
+    try {
+        const originAsset = await assetToNearIntentsAsset(sellAsset);
+        const destinationAsset = await assetToNearIntentsAsset(buyAsset);
+        if (!originAsset) {
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: `Asset ${sellAsset.symbol} on ${sellAsset.networkName || sellAsset.chainId} is not supported by NEAR Intents`,
+            }));
+        }
+        if (!destinationAsset) {
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: `Asset ${buyAsset.symbol} on ${buyAsset.networkName || buyAsset.chainId} is not supported by NEAR Intents`,
+            }));
+        }
+        return Ok({ originAsset, destinationAsset });
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Failed to resolve NEAR Intents assets',
+            code: TradeQuoteError.QueryFailed,
+            cause: error,
+        }));
+    }
+};
+// BTC deposits confirm slowly, so BTC pairs get a longer deadline
+export const getNearIntentsQuoteDeadline = ({ sellAsset, buyAsset, }) => {
+    const deadlineMs = sellAsset.chainId === btcChainId || buyAsset.chainId === btcChainId
+        ? BTC_QUOTE_DEADLINE_MS
+        : DEFAULT_QUOTE_DEADLINE_MS;
+    return new Date(Date.now() + deadlineMs).toISOString();
+};
+export const buildNearIntentsQuoteRequest = ({ originAsset, destinationAsset, sellAmountCryptoBaseUnit, slippageTolerancePercentageDecimal, affiliateBps, refundTo, recipient, refundType, recipientType, deadline, }) => ({
+    dry: false,
+    swapType: QuoteRequest.swapType.EXACT_INPUT,
+    slippageTolerance: slippageTolerancePercentageDecimal
+        ? bnOrZero(slippageTolerancePercentageDecimal).times(10000).toNumber()
+        : DEFAULT_SLIPPAGE_BPS,
+    originAsset,
+    destinationAsset,
+    amount: sellAmountCryptoBaseUnit,
+    depositType: QuoteRequest.depositType.ORIGIN_CHAIN,
+    refundTo,
+    refundType,
+    recipient,
+    recipientType,
+    deadline,
+    referral: 'shapeshift',
+    appFees: [
+        {
+            recipient: DAO_TREASURY_NEAR,
+            fee: Number(affiliateBps),
+        },
+    ],
+});
+// One retry loop for the SDK's flaky WebSocket transport; maps provider errors to swap errors
+export const fetchNearIntentsQuote = async ({ quoteRequest, sellAsset, }) => {
+    const maxRetries = 3;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return Ok(await OneClickService.getQuote(quoteRequest));
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            const isWebSocketError = lastError.message.includes('WebSocket is not ready');
+            if (isWebSocketError && attempt < maxRetries) {
+                await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+                continue;
+            }
+            break;
+        }
+    }
+    const error = lastError ?? new Error('Failed to get quote after retries');
+    if (error instanceof ApiError) {
+        if (error.body?.message === 'tokenIn is not valid' ||
+            error.body?.message === 'tokenOut is not valid') {
+            return Err(makeSwapErrorRight({
+                code: TradeQuoteError.UnsupportedTradePair,
+                message: 'Unsupported asset',
+            }));
+        }
+        if (error.body?.message?.includes('Amount is too low')) {
+            const match = error.body.message.match(/try at least (\d+)/);
+            if (match) {
+                return Err(createTradeAmountTooSmallErr({
+                    minAmountCryptoBaseUnit: match[1],
+                    assetId: sellAsset.assetId,
+                }));
+            }
+        }
+    }
+    return Err(makeSwapErrorRight({
+        message: error instanceof Error ? error.message : 'Unknown error getting NEAR Intents quote',
+        code: TradeQuoteError.QueryFailed,
+        cause: error,
+    }));
+};
 export const mapNearIntentsStatus = (status) => {
     switch (status) {
         case 'PENDING_DEPOSIT':

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

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

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

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

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

@@ -1,4 +1,6 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
+// Vitalik's address — a realistic connected-wallet stand-in for walletless rate pricing + simulation
+export const PORTALS_RATE_DEFAULT_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
 export const chainIdToPortalsNetwork = {
     [KnownChainIds.EthereumMainnet]: 'ethereum',
     [KnownChainIds.AvalancheMainnet]: 'avalanche',
@@ -8,4 +10,6 @@ export const chainIdToPortalsNetwork = {
     [KnownChainIds.ArbitrumMainnet]: 'arbitrum',
     [KnownChainIds.BaseMainnet]: 'base',
     [KnownChainIds.HyperEvmMainnet]: 'hyperevm',
+    [KnownChainIds.SonicMainnet]: 'sonic',
+    [KnownChainIds.PlasmaMainnet]: 'plasma',
 };

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

@@ -1,54 +1,15 @@
-import { evm } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import BigNumber from 'bignumber.js';
-import { checkEvmSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { checkEvmSwapStatus } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getPortalsTradeQuote } from './getPortalsTradeQuote/getPortalsTradeQuote.js';
 import { getPortalsTradeRate } from './getPortalsTradeRate/getPortalsTradeRate.js';
 import { fetchAxelarscanBridgeStatus, getAxelarscanTrackingLink, } from './utils/fetchAxelarscanStatus.js';
 import { fetchSquidBridgeStatus, getSquidTrackingLink } from './utils/fetchSquidStatus.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(),
-        });
-    },
+    getTradeQuote: (input, deps) => getPortalsTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getPortalsTradeRate(input, deps),
+    getEvmTransactionFees,
+    getUnsignedEvmTransaction,
     checkTradeStatus: async (input) => {
         const { txHash, chainId, swap, assertGetEvmChainAdapter, address, fetchIsSmartContractAddressQuery, } = input;
         const isCrossChain = Boolean(swap && swap.sellAsset.chainId !== swap.buyAsset?.chainId);
@@ -97,14 +58,14 @@ export const portalsApi = {
                 return {
                     status: squidTxStatus,
                     buyTxHash: squidStatus.destinationTxHash,
-                    relayerExplorerTxLink: getSquidTrackingLink(txHash, squidStatus, swap.sellAsset.explorerTxLink, swap.buyAsset.explorerTxLink),
+                    swapperTxLink: getSquidTrackingLink(txHash, squidStatus, swap.sellAsset.explorerTxLink, swap.buyAsset.explorerTxLink),
                     message: squidTxStatus === TxStatus.Pending ? 'Cross-chain swap in progress' : undefined,
                 };
             }
             return {
                 status: TxStatus.Pending,
                 buyTxHash: undefined,
-                relayerExplorerTxLink: getAxelarscanTrackingLink(txHash),
+                swapperTxLink: getAxelarscanTrackingLink(txHash),
                 message: 'Bridge status check failed - track manually',
             };
         }
@@ -130,7 +91,7 @@ export const portalsApi = {
         return {
             status: txStatus,
             buyTxHash: bridgeStatus.destinationTxHash,
-            relayerExplorerTxLink: getAxelarscanTrackingLink(txHash),
+            swapperTxLink: getAxelarscanTrackingLink(txHash),
             message: txStatus === TxStatus.Pending
                 ? 'Bridge in progress'
                 : txStatus === TxStatus.Failed

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

@@ -1,5 +1,4 @@
-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>>;
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { PortalsTradeQuoteInput } from '../types.js';
+export declare const getPortalsTradeQuote: (input: PortalsTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;