@shapeshiftoss/swapper 20.3.0 → 20.5.0

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

@@ -1,5 +1,6 @@
 import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
 import { createDefaultStatusResponse, getExecutableTradeStep, getSwapMetadata, isExecutableTradeQuote, } from '../../utils/index.js';
+import { getAptosTransactionFees, getUnsignedAptosTransaction } from '../../utils/aptos/index.js';
 import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getSolanaTransactionFees, getUnsignedSolanaTransaction } from '../../utils/solana/index.js';
 import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
@@ -84,7 +85,7 @@ export const nearIntentsApi = {
         }
         return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
     },
-    getUnsignedStarknetTransaction: async ({ stepIndex, tradeQuote, from, assertGetStarknetChainAdapter, }) => {
+    getUnsignedStarknetTransaction: async ({ stepIndex, tradeQuote, from, callsOnly, assertGetStarknetChainAdapter, }) => {
         if (!isExecutableTradeQuote(tradeQuote))
             throw new Error('Unable to execute a trade rate quote');
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
@@ -94,24 +95,20 @@ export const nearIntentsApi = {
         const to = depositAddress;
         const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
         const tokenContractAddress = contractAddressOrUndefined(sellAsset.assetId);
-        const { fast } = await adapter.getFeeData({
-            to,
-            value,
-            chainSpecific: {
-                from,
-                tokenContractAddress,
-            },
-            sendMax: false,
-        });
+        const maxFee = callsOnly
+            ? undefined
+            : (await adapter.getFeeData({
+                to,
+                value,
+                chainSpecific: { from, tokenContractAddress },
+                sendMax: false,
+            })).fast.chainSpecific.maxFee;
         return adapter.buildSendApiTransaction({
             from,
             to,
             value,
             accountNumber,
-            chainSpecific: {
-                tokenContractAddress,
-                maxFee: fast.chainSpecific.maxFee,
-            },
+            chainSpecific: { tokenContractAddress, maxFee, callsOnly },
         });
     },
     getStarknetTransactionFees: ({ tradeQuote, stepIndex }) => {
@@ -153,6 +150,8 @@ export const nearIntentsApi = {
         }
         return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit);
     },
+    getUnsignedAptosTransaction,
+    getAptosTransactionFees,
     checkTradeStatus: async ({ config, swap }) => {
         if (!swap)
             throw new Error('Missing swap');

package/dist/esm/swappers/NearIntentsSwapper/swapperApi/getTradeRate.js

@@ -54,7 +54,7 @@ const getRate = async (input, deps) => {
             {
                 ...stepCommon,
                 accountNumber,
-                feeData: { protocolFees, networkFeeCryptoBaseUnit: networkFeeCryptoBaseUnit ?? '0' },
+                feeData: { protocolFees, networkFeeCryptoBaseUnit },
             },
         ],
     };

package/dist/esm/swappers/NearIntentsSwapper/types.d.ts

@@ -1,7 +1,7 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
-import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetNearTradeQuoteInput, GetNearTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, GetStarknetTradeQuoteInput, GetStarknetTradeRateInput, GetSuiTradeQuoteInput, GetSuiTradeRateInput, GetTonTradeQuoteInput, GetTonTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput, GetUtxoTradeQuoteInput, GetUtxoTradeRateInput, WithExactBuyAmount } from '../../types.js';
-export type NearIntentsTradeQuoteInput = GetEvmTradeQuoteInput | GetUtxoTradeQuoteInput | GetSolanaTradeQuoteInput | GetTronTradeQuoteInput | GetSuiTradeQuoteInput | GetStarknetTradeQuoteInput | GetNearTradeQuoteInput | GetTonTradeQuoteInput;
-export type NearIntentsTradeRateInput = GetEvmTradeRateInput | GetUtxoTradeRateInput | GetSolanaTradeRateInput | GetTronTradeRateInput | GetSuiTradeRateInput | GetStarknetTradeRateInput | GetNearTradeRateInput | GetTonTradeRateInput;
+import type { GetAptosTradeQuoteInput, GetAptosTradeRateInput, GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetNearTradeQuoteInput, GetNearTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, GetStarknetTradeQuoteInput, GetStarknetTradeRateInput, GetSuiTradeQuoteInput, GetSuiTradeRateInput, GetTonTradeQuoteInput, GetTonTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput, GetUtxoTradeQuoteInput, GetUtxoTradeRateInput, WithExactBuyAmount } from '../../types.js';
+export type NearIntentsTradeQuoteInput = GetEvmTradeQuoteInput | GetUtxoTradeQuoteInput | GetSolanaTradeQuoteInput | GetTronTradeQuoteInput | GetSuiTradeQuoteInput | GetStarknetTradeQuoteInput | GetNearTradeQuoteInput | GetTonTradeQuoteInput | GetAptosTradeQuoteInput;
+export type NearIntentsTradeRateInput = GetEvmTradeRateInput | GetUtxoTradeRateInput | GetSolanaTradeRateInput | GetTronTradeRateInput | GetSuiTradeRateInput | GetStarknetTradeRateInput | GetNearTradeRateInput | GetTonTradeRateInput | GetAptosTradeRateInput;
 export type NearIntentsExactOutputTradeQuoteInput = WithExactBuyAmount<NearIntentsTradeQuoteInput>;
 export type NearIntentsExactOutputTradeRateInput = WithExactBuyAmount<NearIntentsTradeRateInput>;
 export type NearIntentsMetadata = {
@@ -11,6 +11,6 @@ export type NearIntentsMetadata = {
 };
 export { QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
 export type { GetExecutionStatusResponse, QuoteResponse, TokenResponse, } from '@defuse-protocol/one-click-sdk-typescript';
-export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.BitcoinCashMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.ZcashMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet, KnownChainIds.SuiMainnet, KnownChainIds.StarknetMainnet, KnownChainIds.MonadMainnet, KnownChainIds.NearMainnet, KnownChainIds.PlasmaMainnet, KnownChainIds.TonMainnet];
+export declare const nearIntentsSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.GnosisMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.BitcoinCashMainnet, KnownChainIds.DogecoinMainnet, KnownChainIds.ZcashMainnet, KnownChainIds.SolanaMainnet, KnownChainIds.TronMainnet, KnownChainIds.SuiMainnet, KnownChainIds.StarknetMainnet, KnownChainIds.MonadMainnet, KnownChainIds.NearMainnet, KnownChainIds.PlasmaMainnet, KnownChainIds.TonMainnet, KnownChainIds.AptosMainnet];
 export type NearIntentsSupportedChainId = (typeof nearIntentsSupportedChainIds)[number];
 export declare const chainIdToNearIntentsChain: Record<NearIntentsSupportedChainId, string>;

package/dist/esm/swappers/NearIntentsSwapper/types.js

@@ -21,6 +21,7 @@ export const nearIntentsSupportedChainIds = [
     KnownChainIds.NearMainnet,
     KnownChainIds.PlasmaMainnet,
     KnownChainIds.TonMainnet,
+    KnownChainIds.AptosMainnet,
 ];
 export const chainIdToNearIntentsChain = {
     [KnownChainIds.EthereumMainnet]: 'eth',
@@ -43,4 +44,5 @@ export const chainIdToNearIntentsChain = {
     [KnownChainIds.MonadMainnet]: 'monad',
     [KnownChainIds.NearMainnet]: 'near',
     [KnownChainIds.TonMainnet]: 'ton',
+    [KnownChainIds.AptosMainnet]: 'aptos',
 };

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

@@ -1,9 +1,10 @@
 import { CHAIN_NAMESPACE, fromAssetId, fromChainId } from '@shapeshiftoss/caip';
-import { evm } from '@shapeshiftoss/chain-adapters';
+import { aptos, 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 { APTOS_PLACEHOLDER_ADDRESS, APTOS_RATE_SIMULATION_VALUE } from '../../../utils/aptos/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';
@@ -218,6 +219,33 @@ export async function getNearIntentsStepData(args) {
                 const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
                 return Ok(stepData);
             }
+            case CHAIN_NAMESPACE.Aptos: {
+                const adapter = deps.assertGetAptosChainAdapter(sellAsset.chainId);
+                if (type === 'rate') {
+                    const { fast } = await adapter.getFeeData({
+                        to: depositAddress,
+                        value: APTOS_RATE_SIMULATION_VALUE,
+                        chainSpecific: { from: from ?? APTOS_PLACEHOLDER_ADDRESS, contractAddress },
+                    });
+                    const stepData = { networkFeeCryptoBaseUnit: fast.txFee };
+                    return Ok(stepData);
+                }
+                const { fast } = await adapter.getFeeData({
+                    to: depositAddress,
+                    value: sellAmountCryptoBaseUnit,
+                    chainSpecific: { from, contractAddress },
+                });
+                const stepData = {
+                    transactionData: {
+                        type: 'aptos',
+                        payload: aptos.getSerializedTransferPayload(depositAddress, sellAmountCryptoBaseUnit, contractAddress),
+                        gasUnitPrice: fast.chainSpecific.gasUnitPrice,
+                        maxGasAmount: fast.chainSpecific.maxGasAmount,
+                    },
+                    networkFeeCryptoBaseUnit: fast.txFee,
+                };
+                return Ok(stepData);
+            }
             default:
                 return Err(makeSwapErrorRight({
                     message: `[getNearIntentsStepData] unsupported chain namespace: ${chainNamespace}`,

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

@@ -36,7 +36,7 @@ export const getNearIntentsAsset = ({ nearNetwork, contractAddress, }) => {
     return `nep141:${nearNetwork}-${contractAddress.toLowerCase()}.omft.near`;
 };
 const NEP245_CHAINS = ['bsc', 'pol', 'avax', 'op', 'tron', 'monad', 'plasma'];
-const TOKEN_LOOKUP_CHAINS = ['sui', 'starknet', 'ton'];
+const TOKEN_LOOKUP_CHAINS = ['sui', 'starknet', 'ton', 'aptos'];
 const NEAR_CHAIN = 'near';
 const BTC_CHAIN = 'btc';
 const WNEAR_CONTRACT_ADDRESS = 'wrap.near';
@@ -68,7 +68,7 @@ export const assetToNearIntentsAsset = async (asset) => {
         });
         return match?.assetId ?? null;
     }
-    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism, TRON, Monad), Token lookup chains (Sui, Starknet), and Solana require token lookup
+    // NEP-245 chains (BSC, Polygon, Avalanche, Optimism, TRON, Monad), Token lookup chains (Sui, Starknet, TON, Aptos), and Solana require token lookup
     // Asset IDs use hashed format that can't be generated from contract addresses
     const requiresLookup = isNep245Chain(nearNetwork) || isTokenLookupChain(nearNetwork) || asset.chainId === solanaChainId;
     if (requiresLookup) {

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

@@ -59,7 +59,7 @@ export const portalsApi = {
                 const txStatus = relayTxStatus === TxStatus.Unknown ? TxStatus.Pending : relayTxStatus;
                 return {
                     status: txStatus,
-                    buyTxHash: relayRequest.data?.outTxs?.[0]?.hash,
+                    buyTxHash: relayRequest.data?.outTxs?.[0]?.txHash,
                     message: txStatus === TxStatus.Failed
                         ? getRelayRequestFailureMessage(relayRequest)
                         : txStatus === TxStatus.Confirmed
@@ -68,6 +68,9 @@ export const portalsApi = {
                 };
             }
         }
+        else {
+            console.error('Failed to fetch relay request:', relayResult.unwrapErr());
+        }
         const axelarscanResult = await fetchAxelarscanBridgeStatus(txHash);
         if (axelarscanResult.isOk()) {
             const bridgeStatus = axelarscanResult.unwrap();

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

@@ -2,7 +2,7 @@ import { BigNumber, bn } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { TradeQuoteError } from '../../../types.js';
 import { assertQuoteAddresses, makeSwapErrorRight, makeTradeStepBuildFailedErr, } from '../../../utils/index.js';
-import { FALLBACK_QUOTE_DEADLINE_MS, getTreasuryAddressFromChainId, normalizeEpochToMs, } from '../../../utils/helpers.js';
+import { getTreasuryAddressFromChainId, normalizeEpochToMs } from '../../../utils/helpers.js';
 import { fetchPortalsTradeOrder, PortalsError } from '../utils/fetchPortalsTradeOrder.js';
 import { getPortalsStepData } from '../utils/getPortalsStepData.js';
 import { getPortalsTradeContext } from '../utils/getPortalsTradeContext.js';
@@ -138,7 +138,7 @@ export const getPortalsTradeQuote = async (input, deps) => {
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: expiryMs ?? Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+        deadline: expiryMs,
         receiveAddress,
         steps: [
             {

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

@@ -1,53 +1,47 @@
 import { fromChainId } from '@shapeshiftoss/caip';
-import { bnOrZero } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
-import { estimateGasWithStateOverride, getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit, getEvmRateNetworkFeeCryptoBaseUnit, } from '../../../utils/evm/index.js';
 import { fetchPortalsTradeEstimate } from './fetchPortalsTradeOrder.js';
 export async function getPortalsStepData(args) {
     const { tx, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, input, deps } = args;
     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: tx.to,
+        data: tx.data,
+        value: tx.value,
+    };
+    const stateOverride = {
+        sellAsset,
+        sellAmountCryptoBaseUnit,
+        spenderAddress,
+    };
     if (args.type === 'rate') {
+        const getEstimateEndpointGasLimit = async () => {
+            const quoteEstimateResponse = await fetchPortalsTradeEstimate({
+                inputToken: args.inputToken,
+                outputToken: args.outputToken,
+                inputAmount: args.inputAmount,
+                slippageTolerancePercentage: args.slippageTolerancePercentage,
+                swapperConfig: deps.config,
+            });
+            return quoteEstimateResponse.context.gasLimit.toString();
+        };
         try {
-            // No placeholder estimation for provider built routes - overridden estimation (approval
-            // state need not exist yet) with the Portals order and estimate endpoint as fallbacks
-            const gasLimit = await (async () => {
-                try {
-                    const gasLimit = await estimateGasWithStateOverride({
-                        sellAsset,
-                        sellAmountCryptoBaseUnit,
-                        from: tx.from,
-                        spenderAddress,
-                        to: tx.to,
-                        data: tx.data,
-                        value: tx.value,
-                    });
-                    return gasLimit;
-                }
-                catch {
-                    // Portals only carry a tx gas limit on the bridge routes their estimate endpoint zeroes
-                    const { gasLimit: txGasLimit } = tx;
-                    if (txGasLimit && bnOrZero(txGasLimit).gt(0))
-                        return txGasLimit;
-                    const quoteEstimateResponse = await fetchPortalsTradeEstimate({
-                        inputToken: args.inputToken,
-                        outputToken: args.outputToken,
-                        inputAmount: args.inputAmount,
-                        slippageTolerancePercentage: args.slippageTolerancePercentage,
-                        swapperConfig: deps.config,
-                    });
-                    const estimatedGasLimit = quoteEstimateResponse.context.gasLimit.toString();
-                    if (bnOrZero(estimatedGasLimit).lte(0))
-                        throw new Error('no Portals gas limit');
-                    return estimatedGasLimit;
-                }
-            })();
-            const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+            // Portals only set a tx gas limit on bridge routes, where their estimate endpoint is zero
+            const networkFeeCryptoBaseUnit = await getEvmRateNetworkFeeCryptoBaseUnit({
                 adapter,
                 supportsEIP1559,
-                gasLimit,
-            });
+                providerGasLimit: tx.gasLimit,
+                simulation: { transactionData, from: tx.from, stateOverride },
+            }).catch(async () => getEvmRateNetworkFeeCryptoBaseUnit({
+                adapter,
+                supportsEIP1559,
+                providerGasLimit: await getEstimateEndpointGasLimit(),
+            }));
             const stepData = { networkFeeCryptoBaseUnit };
             return Ok(stepData);
         }
@@ -55,27 +49,14 @@ export async function getPortalsStepData(args) {
             return Err(makeNetworkFeeEstimationFailedErr('getPortalsStepData', error));
         }
     }
-    const transactionData = {
-        type: 'evm',
-        chainId: Number(fromChainId(sellAsset.chainId).chainReference),
-        to: tx.to,
-        data: tx.data,
-        value: tx.value,
-        // Portals simulate and pad their gas limit when the order was validated, so no additional
-        // buffer - an unvalidated order carries no gas limit and estimates below instead
-        gasLimit: tx.gasLimit,
-    };
     try {
         const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
             adapter,
             transactionData,
             from: args.from,
             supportsEIP1559,
-            stateOverride: {
-                sellAsset,
-                sellAmountCryptoBaseUnit,
-                spenderAddress,
-            },
+            stateOverride,
+            providerGasLimit: tx.gasLimit,
         });
         const stepData = { transactionData, networkFeeCryptoBaseUnit };
         return Ok(stepData);

package/dist/esm/swappers/PortalsSwapper/utils/getPortalsStepData.test.js

@@ -45,11 +45,11 @@ const estimateEndpointGasLimit = (gasLimit) => vi.mocked(fetchPortalsTradeEstima
 });
 describe('getPortalsStepData rate gas limit', () => {
     beforeEach(() => vi.clearAllMocks());
-    it('falls back to the order gas limit on bridge routes the estimate endpoint zeroes', async () => {
-        vi.mocked(estimateGasWithStateOverride).mockRejectedValue(new Error('execution reverted'));
+    it('prices the order gas limit on bridge routes without simulating', async () => {
         estimateEndpointGasLimit(0);
         const actual = await rate(tx('76384'));
         expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '76384000000000' });
+        expect(estimateGasWithStateOverride).not.toHaveBeenCalled();
         expect(fetchPortalsTradeEstimate).not.toHaveBeenCalled();
     });
     it('falls back to the estimate endpoint when the order carries no gas limit', async () => {

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

@@ -1,6 +1,5 @@
 import { Err, Ok } from '@sniptt/monads';
 import { assertQuoteAddresses } from '../../../utils/index.js';
-import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
 import { getRelayStepData } from '../utils/getRelayStepData.js';
 import { getRelayTradeContext } from '../utils/getRelayTradeContext.js';
 const getQuote = async (input, deps, relayChainMap) => {
@@ -12,7 +11,7 @@ const getQuote = async (input, deps, relayChainMap) => {
     const maybeContext = await getRelayTradeContext({ input, deps, relayChainMap });
     if (maybeContext.isErr())
         return Err(maybeContext.unwrapErr());
-    const { tradeCommon, stepCommon, protocolFees, relayStepInputs, stepDataArgs, relayId } = maybeContext.unwrap();
+    const { tradeCommon, stepCommon, protocolFees, relayStepInputs, stepDataArgs, relayId, deadline, } = maybeContext.unwrap();
     const stepResults = await Promise.all(relayStepInputs.map(async ({ data, allowanceContract }) => {
         const maybeStepData = await getRelayStepData({
             ...stepDataArgs,
@@ -42,7 +41,7 @@ const getQuote = async (input, deps, relayChainMap) => {
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+        deadline,
         receiveAddress,
         steps,
     };

package/dist/esm/swappers/RelaySwapper/utils/getRelayStepData.js

@@ -1,9 +1,9 @@
 import { fromChainId } from '@shapeshiftoss/caip';
 import { tron } from '@shapeshiftoss/chain-adapters';
-import { bnOrZero, contractAddressOrUndefined, isToken } from '@shapeshiftoss/utils';
+import { contractAddressOrUndefined, isToken } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr, makeTradeStepBuildFailedErr } from '../../../utils/index.js';
-import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit, getEvmRateNetworkFeeCryptoBaseUnit, } from '../../../utils/evm/index.js';
 import { getSolanaNetworkFeeCryptoBaseUnit, omitComputeBudgetInstructions, withComputeUnitLimit, } from '../../../utils/solana/index.js';
 import { getTronContractCallFallbackFeeCryptoBaseUnit, getTronContractCallNetworkFeeCryptoBaseUnit, } from '../../../utils/tron/index.js';
 import { getUtxoNetworkFeeCryptoBaseUnit } from '../../../utils/utxo/index.js';
@@ -34,7 +34,6 @@ export async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUn
             to,
             value,
             data: callData,
-            gasLimit: bnOrZero(relayGasLimit).gt(0) ? relayGasLimit : undefined,
         };
         const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
         const stateOverride = {
@@ -43,20 +42,12 @@ export async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUn
             spenderAddress,
         };
         if (type === 'rate') {
-            const networkFeeCryptoBaseUnit = await (async () => {
-                try {
-                    return await getEvmNetworkFeeCryptoBaseUnit({
-                        adapter,
-                        transactionData,
-                        from,
-                        supportsEIP1559,
-                        stateOverride,
-                    });
-                }
-                catch {
-                    return fallbackNetworkFeeCryptoBaseUnit;
-                }
-            })();
+            const networkFeeCryptoBaseUnit = await getEvmRateNetworkFeeCryptoBaseUnit({
+                adapter,
+                supportsEIP1559,
+                providerGasLimit: relayGasLimit,
+                simulation: { transactionData, from, stateOverride },
+            }).catch(() => fallbackNetworkFeeCryptoBaseUnit);
             const stepData = { networkFeeCryptoBaseUnit };
             return Ok(stepData);
         }
@@ -68,6 +59,7 @@ export async function getRelayStepData({ data, sellAsset, sellAmountCryptoBaseUn
                 from,
                 supportsEIP1559,
                 stateOverride,
+                providerGasLimit: relayGasLimit,
             });
             const stepData = { transactionData, networkFeeCryptoBaseUnit };
             return Ok(stepData);

package/dist/esm/swappers/RelaySwapper/utils/getRelayTradeContext.d.ts

@@ -13,6 +13,7 @@ type RelayTradeContext = {
     }[];
     stepDataArgs: Omit<GetRelayStepDataArgs, 'type' | 'input' | 'data' | 'spenderAddress'>;
     relayId: string;
+    deadline: number | undefined;
 };
 export declare const getRelayTradeContext: ({ input, deps, relayChainMap, }: {
     input: RelayTradeQuoteInput | RelayTradeRateInput | RelayExactOutputTradeQuoteInput | RelayExactOutputTradeRateInput;

package/dist/esm/swappers/RelaySwapper/utils/getRelayTradeContext.js

@@ -7,7 +7,7 @@ import { zeroAddress } from 'viem';
 import { MixPanelEvent, SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
 import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
-import { getTradeAmount, isNativeEvmAsset } from '../../../utils/helpers.js';
+import { getTradeAmount, isNativeEvmAsset, normalizeEpochToMs } from '../../../utils/helpers.js';
 import { MAXIMUM_SUPPORTED_RELAY_STEPS, relayErrorCodeToTradeQuoteError } from '../constant.js';
 import { getRelayAssetAddress } from '../utils/getRelayAssetAddress.js';
 import { relayTokenToAsset } from '../utils/relayTokenToAsset.js';
@@ -258,6 +258,9 @@ export const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
         .plus(appFeesBaseUnit)
         .toFixed();
     const relayId = quote.steps[0].requestId;
+    // Only cross-chain (protocol v2) orders carry an expiry; past it the solver submits a no-fill refund
+    const orderDeadline = quote.protocol?.v2?.orderData?.output?.deadline;
+    const deadline = orderDeadline === undefined ? undefined : normalizeEpochToMs(orderDeadline);
     const relayStepInputs = swapSteps.map(step => {
         const data = step.items?.[0]?.data;
         return { data, allowanceContract: getRelayAllowanceContract(data) };
@@ -301,6 +304,7 @@ export const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
             ...appFeesAsProtocolFee,
         },
         relayStepInputs,
+        deadline,
         stepDataArgs: {
             sellAsset,
             sellAmountCryptoBaseUnit,

package/dist/esm/swappers/RelaySwapper/utils/relayStatus.js

@@ -20,13 +20,13 @@ export const relayStatusToTxStatus = (status) => {
 };
 // Relay index requests by origin tx hash, resolving a swap we hold no relayId for
 export const fetchRelayRequestByTxHash = async (txHash, config) => {
-    const maybeResponse = await relayService.get(`${config.VITE_RELAY_API_URL}/requests/v2?hash=${txHash}`, getRelayRequestConfig(config));
+    const maybeResponse = await relayService.get(`${config.VITE_RELAY_API_URL}/requests/v3?depositTxHash=${txHash}`, getRelayRequestConfig(config));
     // Match the origin tx ourselves rather than trusting the listing to have filtered on it
-    return maybeResponse.map(({ data }) => data.requests?.find(({ data: request }) => request?.inTxs?.some(({ hash }) => hash?.toLowerCase() === txHash.toLowerCase())));
+    return maybeResponse.map(({ data }) => data.requests?.find(({ data: request }) => request?.inTxs?.some(({ txHash: hash }) => hash?.toLowerCase() === txHash.toLowerCase())));
 };
 export const getRelayRequestFailureMessage = (request) => {
     const { failReason, refundFailReason } = request.data ?? {};
-    // Relay report 'N/A' rather than omitting the reason when there isn't one
+    // Relay can report 'N/A' rather than null when there isn't one
     const reason = [failReason, refundFailReason].find(value => value && value !== 'N/A');
     return reason ?? 'Bridge failed';
 };

package/dist/esm/swappers/RelaySwapper/utils/types.d.ts

@@ -9,12 +9,12 @@ export type RelayMetadata = {
     data?: string;
 };
 export type RelayRequestTransaction = {
-    hash?: string;
+    txHash?: string;
     chainId?: number;
 };
 export type RelayRequestData = {
-    failReason?: string;
-    refundFailReason?: string;
+    failReason?: string | null;
+    refundFailReason?: string | null;
     inTxs?: RelayRequestTransaction[];
     outTxs?: RelayRequestTransaction[];
 };
@@ -121,9 +121,14 @@ export type RelayQuoteStep = {
     requestId: string;
     items?: RelayQuoteItem[];
 };
+export type RelayOrderData = {
+    output?: {
+        deadline?: number;
+    };
+};
 export type RelayProtocolV2 = {
     orderId: string | undefined;
-    orderData?: unknown;
+    orderData?: RelayOrderData;
     paymentDetails?: {
         chainId: string;
         depository: string;

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

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

package/dist/esm/swappers/SymbiosisSwapper/SymbiosisSwapper.js

@@ -0,0 +1,5 @@
+import { executeEvmTransaction, executeTronTransaction } from '../../utils/index.js';
+export const symbiosisSwapper = {
+    executeEvmTransaction,
+    executeTronTransaction,
+};

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

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

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

@@ -0,0 +1,63 @@
+import { tronChainId } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { checkEvmSwapStatus } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
+import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
+import { getTradeRate } from './getTradeRate/getTradeRate.js';
+import { chainIdToSymbiosisChainId, SYMBIOSIS_EXPLORER_URL } from './utils/constants.js';
+import { getSymbiosisTradeStatus, isTronSourceTxFailed } from './utils/helpers.js';
+import { symbiosisService } from './utils/symbiosisService.js';
+export const symbiosisApi = {
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getTradeRate(input, deps),
+    getEvmTransactionFees,
+    getUnsignedEvmTransaction,
+    getTronTransactionFees,
+    getUnsignedTronTransaction,
+    checkTradeStatus: async ({ txHash, chainId, address, config, swap, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, assertGetTronChainAdapter, }) => {
+        if (!swap)
+            throw new Error('Missing swap');
+        const evmSourceTxStatus = isEvmChainId(chainId)
+            ? await checkEvmSwapStatus({
+                txHash,
+                chainId,
+                address,
+                assertGetEvmChainAdapter,
+                fetchIsSmartContractAddressQuery,
+            })
+            : undefined;
+        if (evmSourceTxStatus && evmSourceTxStatus.status !== TxStatus.Confirmed) {
+            return evmSourceTxStatus;
+        }
+        const sourceTxHash = evmSourceTxStatus?.buyTxHash ?? txHash;
+        if (chainId === tronChainId) {
+            const sourceTx = await assertGetTronChainAdapter(chainId)
+                .httpProvider.getTransaction({ txid: sourceTxHash })
+                .catch(() => null);
+            if (!sourceTx?.confirmations) {
+                return { buyTxHash: undefined, status: TxStatus.Pending, message: undefined };
+            }
+            if (isTronSourceTxFailed(sourceTx)) {
+                return { buyTxHash: undefined, status: TxStatus.Failed, message: undefined };
+            }
+        }
+        const sellSymbiosisChainId = chainIdToSymbiosisChainId[chainId];
+        const buySymbiosisChainId = chainIdToSymbiosisChainId[swap.buyAsset.chainId];
+        const maybeStatusResponse = await symbiosisService.get(`${config.VITE_SYMBIOSIS_API_URL}/v2/tx/${sellSymbiosisChainId}/${sourceTxHash}`);
+        if (maybeStatusResponse.isErr()) {
+            return {
+                buyTxHash: undefined,
+                status: TxStatus.Unknown,
+                message: undefined,
+            };
+        }
+        const { data: response } = maybeStatusResponse.unwrap();
+        return {
+            ...getSymbiosisTradeStatus({ response, buySymbiosisChainId }),
+            swapperTxId: sourceTxHash,
+            swapperTxLink: `${SYMBIOSIS_EXPLORER_URL}/transactions/${sellSymbiosisChainId}/${sourceTxHash}`,
+        };
+    },
+};

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

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

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

@@ -0,0 +1,38 @@
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { getSymbiosisStepData } from '../utils/getSymbiosisStepData.js';
+import { getSymbiosisTradeContext } from '../utils/getSymbiosisTradeContext.js';
+export const getTradeQuote = async (input, deps) => {
+    const { accountNumber } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeContext = await getSymbiosisTradeContext({
+        input,
+        deps,
+        from: sendAddress,
+        to: receiveAddress,
+    });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getSymbiosisStepData({ ...stepDataArgs, type: 'quote', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                transactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeQuote]);
+};

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

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