@shapeshiftoss/swapper 17.6.3 → 17.6.4

package/dist/esm/constants.d.ts

@@ -0,0 +1,8 @@
+import type { Swapper, SwapperApi } from './types.js';
+import { SwapperName } from './types.js';
+export declare const QUOTE_TIMEOUT_MS = 60000;
+export declare const TRADE_STATUS_POLL_INTERVAL_MILLISECONDS = 5000;
+export declare const QUOTE_TIMEOUT_ERROR: import("./types.js").SwapErrorRight;
+export declare const swappers: Record<SwapperName, (SwapperApi & Swapper) | undefined>;
+export declare const getDefaultSlippageDecimalPercentageForSwapper: (swapperName: SwapperName | undefined) => string;
+export declare const isAutoSlippageSupportedBySwapper: (swapperName: SwapperName) => boolean;

package/dist/esm/constants.js

@@ -0,0 +1,128 @@
+import { assertUnreachable } from '@shapeshiftoss/utils';
+import { arbitrumBridgeSwapper } from './swappers/ArbitrumBridgeSwapper/ArbitrumBridgeSwapper.js';
+import { arbitrumBridgeApi } from './swappers/ArbitrumBridgeSwapper/endpoints.js';
+import { bebopSwapper } from './swappers/BebopSwapper/BebopSwapper.js';
+import { bebopApi } from './swappers/BebopSwapper/endpoints.js';
+import { butterSwap } from './swappers/ButterSwap/ButterSwap.js';
+import { butterSwapApi } from './swappers/ButterSwap/endpoints.js';
+import { chainflipSwapper } from './swappers/ChainflipSwapper/ChainflipSwapper.js';
+import { chainflipApi } from './swappers/ChainflipSwapper/endpoints.js';
+import { cowSwapper } from './swappers/CowSwapper/CowSwapper.js';
+import { cowApi } from './swappers/CowSwapper/endpoints.js';
+import { jupiterApi } from './swappers/JupiterSwapper/endpoints.js';
+import { jupiterSwapper } from './swappers/JupiterSwapper/JupiterSwapper.js';
+import { mayachainApi } from './swappers/MayachainSwapper/endpoints.js';
+import { mayachainSwapper } from './swappers/MayachainSwapper/MayachainSwapper.js';
+import { portalsApi } from './swappers/PortalsSwapper/endpoints.js';
+import { portalsSwapper } from './swappers/PortalsSwapper/PortalsSwapper.js';
+import { relaySwapper } from './swappers/RelaySwapper/index.js';
+import { relayApi } from './swappers/RelaySwapper/endpoints.js';
+import { thorchainApi } from './swappers/ThorchainSwapper/endpoints.js';
+import { thorchainSwapper } from './swappers/ThorchainSwapper/ThorchainSwapper.js';
+import { zrxApi } from './swappers/ZrxSwapper/endpoints.js';
+import { zrxSwapper } from './swappers/ZrxSwapper/ZrxSwapper.js';
+import { SwapperName, TradeQuoteError } from './types.js';
+import { makeSwapErrorRight } from './utils.js';
+export const QUOTE_TIMEOUT_MS = 60_000;
+export const TRADE_STATUS_POLL_INTERVAL_MILLISECONDS = 5_000;
+export const QUOTE_TIMEOUT_ERROR = makeSwapErrorRight({
+    code: TradeQuoteError.Timeout,
+    message: `quote timed out after ${QUOTE_TIMEOUT_MS / 1000}s`,
+});
+// PartialRecord not used to ensure exhaustiveness
+export const swappers = {
+    [SwapperName.Thorchain]: {
+        ...thorchainSwapper,
+        ...thorchainApi,
+    },
+    [SwapperName.Mayachain]: {
+        ...mayachainSwapper,
+        ...mayachainApi,
+    },
+    [SwapperName.Zrx]: {
+        ...zrxSwapper,
+        ...zrxApi,
+    },
+    [SwapperName.CowSwap]: {
+        ...cowSwapper,
+        ...cowApi,
+    },
+    [SwapperName.ArbitrumBridge]: {
+        ...arbitrumBridgeSwapper,
+        ...arbitrumBridgeApi,
+    },
+    [SwapperName.Portals]: {
+        ...portalsSwapper,
+        ...portalsApi,
+    },
+    [SwapperName.Chainflip]: {
+        ...chainflipSwapper,
+        ...chainflipApi,
+    },
+    [SwapperName.Jupiter]: {
+        ...jupiterSwapper,
+        ...jupiterApi,
+    },
+    [SwapperName.Relay]: {
+        ...relaySwapper,
+        ...relayApi,
+    },
+    [SwapperName.ButterSwap]: {
+        ...butterSwap,
+        ...butterSwapApi,
+    },
+    [SwapperName.Bebop]: {
+        ...bebopSwapper,
+        ...bebopApi,
+    },
+    [SwapperName.Test]: undefined,
+};
+// Slippage defaults. Don't export these to ensure the getDefaultSlippageDecimalPercentageForSwapper helper function is used.
+const DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE = '0.002'; // .2%
+const DEFAULT_COWSWAP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
+const DEFAULT_PORTALS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.025'; // 2.5%
+const DEFAULT_THOR_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01'; // 1%
+const DEFAULT_MAYA_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01'; // 1%
+const DEFAULT_ARBITRUM_BRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE = '0'; // no slippage for Arbitrum Bridge, so no slippage tolerance
+const DEFAULT_CHAINFLIP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.02'; // 2%
+const DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.015'; // 1.5%
+export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
+    if (swapperName === undefined)
+        return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
+    switch (swapperName) {
+        case SwapperName.Zrx:
+        case SwapperName.Bebop:
+        case SwapperName.Test:
+            return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.CowSwap:
+            return DEFAULT_COWSWAP_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.Portals:
+            return DEFAULT_PORTALS_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.Thorchain:
+            return DEFAULT_THOR_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.Mayachain:
+            return DEFAULT_MAYA_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.ArbitrumBridge:
+            return DEFAULT_ARBITRUM_BRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.Chainflip:
+            return DEFAULT_CHAINFLIP_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.Jupiter:
+            throw new Error('Default slippage not supported by Jupiter');
+        case SwapperName.Relay:
+            throw new Error('Default slippage not supported by Relay');
+        case SwapperName.ButterSwap:
+            return DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE;
+        default:
+            return assertUnreachable(swapperName);
+    }
+};
+export const isAutoSlippageSupportedBySwapper = (swapperName) => {
+    switch (swapperName) {
+        case SwapperName.Jupiter:
+            return true;
+        case SwapperName.Relay:
+            return true;
+        default:
+            return false;
+    }
+};

package/dist/esm/cowswap-utils/constants.d.ts

@@ -0,0 +1,14 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const ORDER_TYPE_FIELDS: {
+    name: string;
+    type: string;
+}[];
+export declare const CANCELLATIONS_TYPE_FIELDS: {
+    name: string;
+    type: string;
+}[];
+export declare const DEFAULT_ADDRESS: "0x0000000000000000000000000000000000000000";
+export declare const SUPPORTED_CHAIN_IDS: ChainId[];
+export declare const COW_SWAP_VAULT_RELAYER_ADDRESS = "0xc92e8bdf79f0507f65a392b0ab4667716bfe0110";
+export declare const COW_SWAP_SETTLEMENT_ADDRESS = "0x9008D19f58AAbD9eD0D60971565AA8510560ab41";
+export declare const COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";

package/dist/esm/cowswap-utils/constants.js

@@ -0,0 +1,31 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { zeroAddress } from 'viem';
+export const ORDER_TYPE_FIELDS = [
+    { name: 'sellToken', type: 'address' },
+    { name: 'buyToken', type: 'address' },
+    { name: 'receiver', type: 'address' },
+    { name: 'sellAmount', type: 'uint256' },
+    { name: 'buyAmount', type: 'uint256' },
+    { name: 'validTo', type: 'uint32' },
+    { name: 'appData', type: 'bytes32' },
+    { name: 'feeAmount', type: 'uint256' },
+    { name: 'kind', type: 'string' },
+    { name: 'partiallyFillable', type: 'bool' },
+    { name: 'sellTokenBalance', type: 'string' },
+    { name: 'buyTokenBalance', type: 'string' },
+];
+export const CANCELLATIONS_TYPE_FIELDS = [{ name: 'orderUids', type: 'bytes[]' }];
+export const DEFAULT_ADDRESS = zeroAddress;
+export const SUPPORTED_CHAIN_IDS = [
+    KnownChainIds.EthereumMainnet,
+    KnownChainIds.GnosisMainnet,
+    KnownChainIds.ArbitrumMainnet,
+    KnownChainIds.BaseMainnet,
+    KnownChainIds.AvalancheMainnet,
+    KnownChainIds.PolygonMainnet,
+];
+export const COW_SWAP_VAULT_RELAYER_ADDRESS = '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110';
+export const COW_SWAP_SETTLEMENT_ADDRESS = '0x9008D19f58AAbD9eD0D60971565AA8510560ab41';
+// Address used by CowSwap to buy ETH
+// See https://github.com/gnosis/gp-v2-contracts/commit/821b5a8da213297b0f7f1d8b17c893c5627020af#diff-12bbbe13cd5cf42d639e34a39d8795021ba40d3ee1e1a8282df652eb161a11d6R13
+export const COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';

package/dist/esm/cowswap-utils/index.d.ts

@@ -0,0 +1,24 @@
+import type { OrderClass1 } from '@cowprotocol/app-data/dist/generatedTypes/v1.3.0';
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { HDWallet } from '@shapeshiftoss/hdwallet-core';
+import type { AccountMetadata, UnsignedOrderCreation } from '@shapeshiftoss/types';
+import { CowNetwork } from '@shapeshiftoss/types';
+import type { TypedData } from 'eip-712';
+import type { Address } from 'viem';
+import type { AffiliateAppDataFragment } from '../swappers/CowSwapper/index.js';
+export * from './constants.js';
+export declare const getCowNetwork: (chainId: ChainId) => CowNetwork | undefined;
+export declare const assertGetCowNetwork: (chainId: ChainId) => CowNetwork;
+export declare const signCowMessage: (typedData: TypedData, chainAdapter: EvmChainAdapter, accountMetadata: AccountMetadata, wallet: HDWallet) => Promise<string>;
+export declare const signCowOrder: (unsignedOrderCreation: UnsignedOrderCreation, chainId: ChainId, signMessage: (typedData: TypedData) => Promise<string>) => Promise<string>;
+export declare const signCowOrderCancellation: (orderUid: string, chainId: ChainId, signMessage: (typedData: TypedData) => Promise<string>) => Promise<string>;
+export declare const cowSwapTokenToAssetId: (chainId: ChainId, cowSwapToken: Address) => import("@shapeshiftoss/caip").AssetId;
+export declare const getAffiliateAppDataFragmentByChainId: ({ affiliateBps, chainId, }: {
+    affiliateBps: string;
+    chainId: ChainId;
+}) => AffiliateAppDataFragment;
+export declare const getFullAppData: (slippageTolerancePercentage: string, affiliateAppDataFragment: AffiliateAppDataFragment, orderClass1: OrderClass1) => Promise<{
+    appDataHash: string;
+    appData: string;
+}>;

package/dist/esm/cowswap-utils/index.js

@@ -0,0 +1,152 @@
+import { MetadataApi, stringifyDeterministic } from '@cowprotocol/app-data';
+import { ASSET_NAMESPACE, fromChainId, toAssetId } from '@shapeshiftoss/caip';
+import { toAddressNList } from '@shapeshiftoss/chain-adapters';
+import { CowNetwork, KnownChainIds, TypedDataPrimaryType } from '@shapeshiftoss/types';
+import { bnOrZero, convertDecimalPercentageToBasisPoints, getNativeFeeAssetReference, } from '@shapeshiftoss/utils';
+import { ethers } from 'ethers';
+import { keccak256, stringToBytes } from 'viem';
+import { getTreasuryAddressFromChainId } from '../swappers/utils/helpers/helpers.js';
+import { CANCELLATIONS_TYPE_FIELDS, COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS, COW_SWAP_SETTLEMENT_ADDRESS, ORDER_TYPE_FIELDS, } from './constants.js';
+export * from './constants.js';
+export const getCowNetwork = (chainId) => {
+    switch (chainId) {
+        case KnownChainIds.EthereumMainnet:
+            return CowNetwork.Mainnet;
+        case KnownChainIds.GnosisMainnet:
+            return CowNetwork.Xdai;
+        case KnownChainIds.ArbitrumMainnet:
+            return CowNetwork.ArbitrumOne;
+        case KnownChainIds.BaseMainnet:
+            return CowNetwork.Base;
+        case KnownChainIds.AvalancheMainnet:
+            return CowNetwork.Avalanche;
+        case KnownChainIds.PolygonMainnet:
+            return CowNetwork.Polygon;
+        default:
+            return;
+    }
+};
+const cowDomain = (chainId, verifyingContract) => {
+    return {
+        name: 'Gnosis Protocol',
+        version: 'v2',
+        chainId,
+        verifyingContract,
+    };
+};
+export const assertGetCowNetwork = (chainId) => {
+    const maybeNetwork = getCowNetwork(chainId);
+    if (!maybeNetwork)
+        throw Error('Unsupported chain');
+    return maybeNetwork;
+};
+export const signCowMessage = async (typedData, chainAdapter, accountMetadata, wallet) => {
+    const { bip44Params } = accountMetadata;
+    const typedDataToSign = {
+        addressNList: toAddressNList(chainAdapter.getBip44Params(bip44Params)),
+        typedData,
+    };
+    const signTypedDataInput = {
+        typedDataToSign,
+        wallet,
+    };
+    const signedTypeData = await chainAdapter.signTypedData(signTypedDataInput);
+    // Passing the signature through split/join to normalize the `v` byte.
+    // Some wallets do not pad it with `27`, which causes a signature failure
+    // `splitSignature` pads it if needed, and `joinSignature` simply puts it back together
+    const signature = ethers.Signature.from(ethers.Signature.from(signedTypeData)).serialized;
+    return signature;
+};
+const getSignTypeDataPayload = (chainId, primaryType, types, message) => {
+    const { chainReference } = fromChainId(chainId);
+    const signingDomain = Number(chainReference);
+    const typedDataDomain = cowDomain(signingDomain, COW_SWAP_SETTLEMENT_ADDRESS);
+    return {
+        // Mismatch of types between ethers5' TypedDataDomain and TypedData :shrugs:
+        domain: typedDataDomain,
+        primaryType,
+        types: {
+            ...types,
+            EIP712Domain: [
+                { name: 'name', type: 'string' },
+                { name: 'version', type: 'string' },
+                { name: 'chainId', type: 'uint256' },
+                { name: 'verifyingContract', type: 'address' },
+            ],
+        },
+        message,
+    };
+};
+export const signCowOrder = async (unsignedOrderCreation, chainId, signMessage) => {
+    // Removes the types that aren't part of GpV2Order types or structured signing will fail
+    const { signingScheme, quoteId, appDataHash, appData, receiver, ...rest } = unsignedOrderCreation;
+    if (!appDataHash)
+        throw Error('missing appDataHash');
+    if (!receiver)
+        throw Error('missing receiver');
+    const message = {
+        ...rest,
+        receiver,
+        // The order we're signing requires the appData to be a hash, not the stringified doc
+        // However, the request we're making to *send* the order to the API requires both appData and appDataHash in their original form
+        // see https://github.com/cowprotocol/cowswap/blob/a11703f4e93df0247c09d96afa93e13669a3c244/apps/cowswap-frontend/src/legacy/utils/trade.ts#L236
+        appData: appDataHash,
+    };
+    const typedData = getSignTypeDataPayload(chainId, TypedDataPrimaryType.Order, { Order: ORDER_TYPE_FIELDS }, message);
+    const signature = await signMessage(typedData);
+    return signature;
+};
+export const signCowOrderCancellation = async (orderUid, chainId, signMessage) => {
+    const typedData = getSignTypeDataPayload(chainId, TypedDataPrimaryType.OrderCancellations, { OrderCancellations: CANCELLATIONS_TYPE_FIELDS }, { orderUids: [orderUid] });
+    const signature = await signMessage(typedData);
+    return signature;
+};
+export const cowSwapTokenToAssetId = (chainId, cowSwapToken) => {
+    const { chainNamespace, chainReference } = fromChainId(chainId);
+    return cowSwapToken.toLowerCase() === COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS.toLowerCase()
+        ? toAssetId({
+            chainId,
+            assetNamespace: 'slip44',
+            assetReference: getNativeFeeAssetReference(chainNamespace, chainReference),
+        })
+        : toAssetId({
+            chainId,
+            assetNamespace: ASSET_NAMESPACE.erc20,
+            assetReference: cowSwapToken,
+        });
+};
+export const getAffiliateAppDataFragmentByChainId = ({ affiliateBps, chainId, }) => {
+    const hasAffiliateFee = bnOrZero(affiliateBps).gt(0);
+    if (!hasAffiliateFee)
+        return {};
+    return {
+        partnerFee: {
+            bps: bnOrZero(affiliateBps).toNumber(),
+            recipient: getTreasuryAddressFromChainId(chainId),
+        },
+    };
+};
+const generateAppDataFromDoc = async (doc) => {
+    const appData = await stringifyDeterministic(doc);
+    const appDataKeccak256 = keccak256(stringToBytes(appData));
+    return { fullAppData: appData, appDataKeccak256 };
+};
+const metadataApi = new MetadataApi();
+// See https://api.cow.fi/docs/#/default/post_api_v1_quote / https://github.com/cowprotocol/app-data
+export const getFullAppData = async (slippageTolerancePercentage, affiliateAppDataFragment, orderClass1) => {
+    const APP_CODE = 'shapeshift';
+    const orderClass = { orderClass: orderClass1 };
+    const quote = {
+        slippageBips: convertDecimalPercentageToBasisPoints(slippageTolerancePercentage).toNumber(),
+    };
+    const appDataDoc = await metadataApi.generateAppDataDoc({
+        appCode: APP_CODE,
+        metadata: {
+            quote,
+            orderClass,
+            ...affiliateAppDataFragment,
+        },
+    });
+    const { fullAppData, appDataKeccak256 } = await generateAppDataFromDoc(appDataDoc);
+    return { appDataHash: appDataKeccak256, appData: fullAppData };
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,18 @@
+export * from './constants.js';
+export * from './cowswap-utils/index.js';
+export * from './safe-utils/index.js';
+export * from './swapper.js';
+export * from './swappers/ArbitrumBridgeSwapper/index.js';
+export * from './swappers/BebopSwapper/index.js';
+export * from './swappers/ChainflipSwapper/index.js';
+export * from './swappers/CowSwapper/index.js';
+export * from './swappers/JupiterSwapper/index.js';
+export * from './swappers/PortalsSwapper/index.js';
+export * from './swappers/ThorchainSwapper/index.js';
+export * from './swappers/MayachainSwapper/index.js';
+export * from './swappers/ButterSwap/index.js';
+export * from './swappers/utils/helpers/helpers.js';
+export * from './thorchain-utils/index.js';
+export * from './types.js';
+export * from './utils.js';
+export * as testData from './swappers/utils/test-data/index.js';

package/dist/esm/index.js

@@ -0,0 +1,18 @@
+export * from './constants.js';
+export * from './cowswap-utils/index.js';
+export * from './safe-utils/index.js';
+export * from './swapper.js';
+export * from './swappers/ArbitrumBridgeSwapper/index.js';
+export * from './swappers/BebopSwapper/index.js';
+export * from './swappers/ChainflipSwapper/index.js';
+export * from './swappers/CowSwapper/index.js';
+export * from './swappers/JupiterSwapper/index.js';
+export * from './swappers/PortalsSwapper/index.js';
+export * from './swappers/ThorchainSwapper/index.js';
+export * from './swappers/MayachainSwapper/index.js';
+export * from './swappers/ButterSwap/index.js';
+export * from './swappers/utils/helpers/helpers.js';
+export * from './thorchain-utils/index.js';
+export * from './types.js';
+export * from './utils.js';
+export * as testData from './swappers/utils/test-data/index.js';

package/dist/esm/safe-utils/constants.d.ts

@@ -0,0 +1,2 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const ChainIdToSafeBaseUrl: Partial<Record<ChainId, string>>;

package/dist/esm/safe-utils/constants.js

@@ -0,0 +1,11 @@
+import { arbitrumChainId, avalancheChainId, baseChainId, bscChainId, ethChainId, gnosisChainId, optimismChainId, polygonChainId, } from '@shapeshiftoss/caip';
+export const ChainIdToSafeBaseUrl = {
+    [ethChainId]: 'https://safe-transaction-mainnet.safe.global',
+    [avalancheChainId]: 'https://safe-transaction-avalanche.safe.global',
+    [optimismChainId]: 'https://safe-transaction-optimism.safe.global',
+    [bscChainId]: 'https://safe-transaction-bsc.safe.global',
+    [polygonChainId]: 'https://safe-transaction-polygon.safe.global',
+    [gnosisChainId]: 'https://safe-transaction-gnosis-chain.safe.global',
+    [arbitrumChainId]: 'https://safe-transaction-arbitrum.safe.global',
+    [baseChainId]: 'https://safe-transaction-base.safe.global',
+};

package/dist/esm/safe-utils/index.d.ts

@@ -0,0 +1,3 @@
+import type { FetchSafeTransactionArgs, SafeTxInfo } from './types.js';
+export declare const fetchSafeTransactionInfo: ({ safeTxHash, address, chainId, fetchIsSmartContractAddressQuery, }: FetchSafeTransactionArgs) => Promise<SafeTxInfo>;
+export * from './types.js';

package/dist/esm/safe-utils/index.js

@@ -0,0 +1,45 @@
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import axios from 'axios';
+import { ChainIdToSafeBaseUrl } from './constants.js';
+const nilSafeTransctionInfo = {
+    transaction: null,
+    isSafeTxHash: false,
+    isQueuedSafeTx: false,
+    isExecutedSafeTx: false,
+};
+export const fetchSafeTransactionInfo = async ({ safeTxHash, address, chainId, fetchIsSmartContractAddressQuery, }) => {
+    if (!address || !chainId || !isEvmChainId(chainId))
+        return nilSafeTransctionInfo;
+    const isSmartContractAddress = await fetchIsSmartContractAddressQuery(address, chainId);
+    if (!isSmartContractAddress) {
+        // Assume any smart contract address is a SAFE, and by extension, any non-smart contract address is not
+        // This is super naive, but this is exactly the same way SAFE does it
+        // https://github.com/safe-global/safe-core-sdk/blob/ea0d5018a93f294dfd891e6c8963edcb96431876/packages/protocol-kit/src/Safe.ts#L303
+        return nilSafeTransctionInfo;
+    }
+    const baseUrl = ChainIdToSafeBaseUrl[chainId];
+    if (!baseUrl) {
+        throw new Error(`Unsupported chain ID: ${chainId}`);
+    }
+    try {
+        const response = await axios.get(`${baseUrl}/api/v1/multisig-transactions/${safeTxHash}/`);
+        if ('detail' in response.data) {
+            return nilSafeTransctionInfo;
+        }
+        const isQueuedSafeTx = Boolean(!response.data?.transactionHash &&
+            response.data?.confirmations &&
+            response.data.confirmations.length <= response.data.confirmationsRequired);
+        const isExecutedSafeTx = Boolean(response.data?.transactionHash);
+        return {
+            transaction: response.data,
+            isSafeTxHash: true,
+            isQueuedSafeTx,
+            isExecutedSafeTx,
+        };
+    }
+    catch (error) {
+        // If the request fails, it's likely not a Safe transaction hash
+        return nilSafeTransctionInfo;
+    }
+};
+export * from './types.js';

package/dist/esm/safe-utils/types.d.ts

@@ -0,0 +1,57 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export type SafeTxInfo = {
+    transaction: SafeMultisigTransactionSuccess | null;
+    isSafeTxHash: boolean;
+    isQueuedSafeTx: boolean;
+    isExecutedSafeTx: boolean;
+};
+type SafeMultisigConfirmationResponse = {
+    owner: string;
+    submissionDate: string;
+    transactionHash?: string;
+    confirmationType?: string;
+    signature: string;
+    signatureType?: string;
+};
+export type SafeMultisigTransactionSuccess = {
+    safe: string;
+    to: string;
+    value: string;
+    data?: string;
+    operation: number;
+    gasToken: string;
+    safeTxGas: number;
+    baseGas: number;
+    gasPrice: string;
+    refundReceiver?: string;
+    nonce: number;
+    executionDate: string;
+    submissionDate: string;
+    modified: string;
+    blockNumber?: number;
+    transactionHash: string;
+    safeTxHash: string;
+    executor?: string;
+    proposer: string;
+    isExecuted: boolean;
+    isSuccessful?: boolean;
+    ethGasPrice?: string;
+    gasUsed?: number;
+    fee?: string;
+    origin: string;
+    dataDecoded?: string;
+    confirmationsRequired: number;
+    confirmations?: SafeMultisigConfirmationResponse[];
+    trusted: boolean;
+    signatures?: string;
+};
+export type SafeTransactionError = {
+    detail: string;
+};
+export type FetchSafeTransactionArgs = {
+    safeTxHash: string;
+    address: string | undefined;
+    chainId: ChainId;
+    fetchIsSmartContractAddressQuery: (userAddress: string, chainId: ChainId) => Promise<boolean>;
+};
+export {};

package/dist/esm/safe-utils/types.js

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

package/dist/esm/solana-utils/getSolanaTransactionFees.d.ts

@@ -0,0 +1,2 @@
+import type { GetUnsignedSolanaTransactionArgs } from '../types.js';
+export declare const getSolanaTransactionFees: ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }: GetUnsignedSolanaTransactionArgs) => Promise<string>;

package/dist/esm/solana-utils/getSolanaTransactionFees.js

@@ -0,0 +1,18 @@
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../utils.js';
+export const getSolanaTransactionFees = async ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { solanaTransactionMetadata, sellAsset } = step;
+    const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
+    const { fast } = await adapter.getFeeData({
+        to: '',
+        value: '0',
+        chainSpecific: {
+            from,
+            addressLookupTableAccounts: solanaTransactionMetadata?.addressLookupTableAddresses,
+            instructions: solanaTransactionMetadata?.instructions,
+        },
+    });
+    return fast.txFee;
+};

package/dist/esm/solana-utils/getUnsignedSolanaTransaction.d.ts

@@ -0,0 +1,3 @@
+import type { SolanaSignTx } from '@shapeshiftoss/hdwallet-core';
+import type { GetUnsignedSolanaTransactionArgs } from '../types.js';
+export declare const getUnsignedSolanaTransaction: ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }: GetUnsignedSolanaTransactionArgs) => Promise<SolanaSignTx>;

package/dist/esm/solana-utils/getUnsignedSolanaTransaction.js

@@ -0,0 +1,35 @@
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { COMPUTE_UNIT_MARGIN_MULTIPLIER } from '../swappers/JupiterSwapper/index.js';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../utils.js';
+export const getUnsignedSolanaTransaction = async ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }) => {
+    if (!isExecutableTradeQuote(tradeQuote))
+        throw new Error('Unable to execute a trade rate quote');
+    const step = getExecutableTradeStep(tradeQuote, stepIndex);
+    const { accountNumber, solanaTransactionMetadata, sellAsset } = step;
+    const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
+    const { fast } = await adapter.getFeeData({
+        to: '',
+        value: '0',
+        chainSpecific: {
+            from,
+            addressLookupTableAccounts: solanaTransactionMetadata?.addressLookupTableAddresses,
+            instructions: solanaTransactionMetadata?.instructions,
+        },
+    });
+    const solanaInstructions = solanaTransactionMetadata?.instructions?.map(instruction => adapter.convertInstruction(instruction));
+    return adapter.buildSendApiTransaction({
+        from,
+        to: '',
+        value: '0',
+        accountNumber,
+        chainSpecific: {
+            addressLookupTableAccounts: solanaTransactionMetadata?.addressLookupTableAddresses,
+            instructions: solanaInstructions,
+            // As always, as relay uses jupiter under the hood, we need to add the compute unit safety margin
+            computeUnitLimit: bnOrZero(fast.chainSpecific.computeUnits)
+                .times(COMPUTE_UNIT_MARGIN_MULTIPLIER)
+                .toFixed(0),
+            computeUnitPrice: fast.chainSpecific.priorityFee,
+        },
+    });
+};

package/dist/esm/swapper.d.ts

@@ -0,0 +1,3 @@
+import type { GetTradeQuoteInputWithWallet, GetTradeRateInput, QuoteResult, RateResult, SwapperDeps, SwapperName } from './types.js';
+export declare const getTradeQuotes: (getTradeQuoteInput: GetTradeQuoteInputWithWallet, swapperName: SwapperName, deps: SwapperDeps) => Promise<QuoteResult | undefined>;
+export declare const getTradeRates: (getTradeRateInput: GetTradeRateInput, swapperName: SwapperName, deps: SwapperDeps, quoteTimeoutMs?: number) => Promise<RateResult | undefined>;

package/dist/esm/swapper.js

@@ -0,0 +1,51 @@
+import { bnOrZero, timeoutMonadic, timeoutMonadicWithOriginal } from '@shapeshiftoss/utils';
+import { QUOTE_TIMEOUT_ERROR, QUOTE_TIMEOUT_MS, swappers } from './constants.js';
+import { TradeQuoteError } from './types.js';
+import { makeSwapErrorRight } from './utils.js';
+export const getTradeQuotes = async (getTradeQuoteInput, swapperName, deps) => {
+    if (bnOrZero(getTradeQuoteInput.affiliateBps).lt(0))
+        return;
+    if (getTradeQuoteInput.sellAmountIncludingProtocolFeesCryptoBaseUnit === '0')
+        return;
+    const swapper = swappers[swapperName];
+    if (swapper === undefined)
+        return;
+    try {
+        const quote = await timeoutMonadic(swapper.getTradeQuote(getTradeQuoteInput, deps), QUOTE_TIMEOUT_MS, QUOTE_TIMEOUT_ERROR);
+        return {
+            ...quote,
+            swapperName,
+        };
+    }
+    catch (e) {
+        // This should never happen but it may - we should be using monadic error handling all the way through swapper call stack
+        // in case this logs an error from a rejected promise, it means we throw somewhere and forgot to handle errors the monadic way
+        console.error('Unhandled error. Use monadic error handling: ', e);
+    }
+};
+export const getTradeRates = async (getTradeRateInput, swapperName, deps, quoteTimeoutMs = QUOTE_TIMEOUT_MS) => {
+    if (bnOrZero(getTradeRateInput.affiliateBps).lt(0))
+        return;
+    if (getTradeRateInput.sellAmountIncludingProtocolFeesCryptoBaseUnit === '0')
+        return;
+    const swapper = swappers[swapperName];
+    if (swapper === undefined)
+        return;
+    try {
+        const { timed, original } = timeoutMonadicWithOriginal(swapper.getTradeRate(getTradeRateInput, deps), quoteTimeoutMs, makeSwapErrorRight({
+            code: TradeQuoteError.Timeout,
+            message: `quote timed out after ${quoteTimeoutMs / 1000}s`,
+        }));
+        const quote = await timed;
+        return {
+            ...quote,
+            fallback: original,
+            swapperName,
+        };
+    }
+    catch (e) {
+        // This should never happen but it may - we should be using monadic error handling all the way through swapper call stack
+        // in case this logs an error from a rejected promise, it means we throw somewhere and forgot to handle errors the monadic way
+        console.error('Unhandled error. Use monadic error handling: ', e);
+    }
+};

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

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