@shapeshiftoss/swapper 17.6.6 → 17.6.7

package/dist/cjs/constants.d.ts

@@ -0,0 +1,8 @@
+import type { Swapper, SwapperApi } from './types';
+import { SwapperName } from './types';
+export declare const QUOTE_TIMEOUT_MS = 60000;
+export declare const TRADE_STATUS_POLL_INTERVAL_MILLISECONDS = 5000;
+export declare const QUOTE_TIMEOUT_ERROR: import("./types").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/cjs/constants.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAutoSlippageSupportedBySwapper = exports.getDefaultSlippageDecimalPercentageForSwapper = exports.swappers = exports.QUOTE_TIMEOUT_ERROR = exports.TRADE_STATUS_POLL_INTERVAL_MILLISECONDS = exports.QUOTE_TIMEOUT_MS = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
+const ArbitrumBridgeSwapper_1 = require("./swappers/ArbitrumBridgeSwapper/ArbitrumBridgeSwapper");
+const endpoints_1 = require("./swappers/ArbitrumBridgeSwapper/endpoints");
+const BebopSwapper_1 = require("./swappers/BebopSwapper/BebopSwapper");
+const endpoints_2 = require("./swappers/BebopSwapper/endpoints");
+const ButterSwap_1 = require("./swappers/ButterSwap/ButterSwap");
+const endpoints_3 = require("./swappers/ButterSwap/endpoints");
+const CetusSwapper_1 = require("./swappers/CetusSwapper/CetusSwapper");
+const endpoints_4 = require("./swappers/CetusSwapper/endpoints");
+const ChainflipSwapper_1 = require("./swappers/ChainflipSwapper/ChainflipSwapper");
+const endpoints_5 = require("./swappers/ChainflipSwapper/endpoints");
+const CowSwapper_1 = require("./swappers/CowSwapper/CowSwapper");
+const endpoints_6 = require("./swappers/CowSwapper/endpoints");
+const endpoints_7 = require("./swappers/JupiterSwapper/endpoints");
+const JupiterSwapper_1 = require("./swappers/JupiterSwapper/JupiterSwapper");
+const endpoints_8 = require("./swappers/MayachainSwapper/endpoints");
+const MayachainSwapper_1 = require("./swappers/MayachainSwapper/MayachainSwapper");
+const endpoints_9 = require("./swappers/NearIntentsSwapper/endpoints");
+const NearIntentsSwapper_1 = require("./swappers/NearIntentsSwapper/NearIntentsSwapper");
+const endpoints_10 = require("./swappers/PortalsSwapper/endpoints");
+const PortalsSwapper_1 = require("./swappers/PortalsSwapper/PortalsSwapper");
+const RelaySwapper_1 = require("./swappers/RelaySwapper");
+const endpoints_11 = require("./swappers/RelaySwapper/endpoints");
+const endpoints_12 = require("./swappers/ThorchainSwapper/endpoints");
+const ThorchainSwapper_1 = require("./swappers/ThorchainSwapper/ThorchainSwapper");
+const endpoints_13 = require("./swappers/ZrxSwapper/endpoints");
+const ZrxSwapper_1 = require("./swappers/ZrxSwapper/ZrxSwapper");
+const types_1 = require("./types");
+const utils_2 = require("./utils");
+exports.QUOTE_TIMEOUT_MS = 60_000;
+exports.TRADE_STATUS_POLL_INTERVAL_MILLISECONDS = 5_000;
+exports.QUOTE_TIMEOUT_ERROR = (0, utils_2.makeSwapErrorRight)({
+    code: types_1.TradeQuoteError.Timeout,
+    message: `quote timed out after ${exports.QUOTE_TIMEOUT_MS / 1000}s`,
+});
+// PartialRecord not used to ensure exhaustiveness
+exports.swappers = {
+    [types_1.SwapperName.Thorchain]: {
+        ...ThorchainSwapper_1.thorchainSwapper,
+        ...endpoints_12.thorchainApi,
+    },
+    [types_1.SwapperName.Mayachain]: {
+        ...MayachainSwapper_1.mayachainSwapper,
+        ...endpoints_8.mayachainApi,
+    },
+    [types_1.SwapperName.Zrx]: {
+        ...ZrxSwapper_1.zrxSwapper,
+        ...endpoints_13.zrxApi,
+    },
+    [types_1.SwapperName.CowSwap]: {
+        ...CowSwapper_1.cowSwapper,
+        ...endpoints_6.cowApi,
+    },
+    [types_1.SwapperName.ArbitrumBridge]: {
+        ...ArbitrumBridgeSwapper_1.arbitrumBridgeSwapper,
+        ...endpoints_1.arbitrumBridgeApi,
+    },
+    [types_1.SwapperName.Portals]: {
+        ...PortalsSwapper_1.portalsSwapper,
+        ...endpoints_10.portalsApi,
+    },
+    [types_1.SwapperName.Chainflip]: {
+        ...ChainflipSwapper_1.chainflipSwapper,
+        ...endpoints_5.chainflipApi,
+    },
+    [types_1.SwapperName.Jupiter]: {
+        ...JupiterSwapper_1.jupiterSwapper,
+        ...endpoints_7.jupiterApi,
+    },
+    [types_1.SwapperName.Relay]: {
+        ...RelaySwapper_1.relaySwapper,
+        ...endpoints_11.relayApi,
+    },
+    [types_1.SwapperName.ButterSwap]: {
+        ...ButterSwap_1.butterSwap,
+        ...endpoints_3.butterSwapApi,
+    },
+    [types_1.SwapperName.Bebop]: {
+        ...BebopSwapper_1.bebopSwapper,
+        ...endpoints_2.bebopApi,
+    },
+    [types_1.SwapperName.NearIntents]: {
+        ...NearIntentsSwapper_1.nearIntentsSwapper,
+        ...endpoints_9.nearIntentsApi,
+    },
+    [types_1.SwapperName.Cetus]: {
+        ...CetusSwapper_1.cetusSwapper,
+        ...endpoints_4.cetusApi,
+    },
+    [types_1.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_NEAR_INTENTS_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%
+const DEFAULT_CETUS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
+const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
+    if (swapperName === undefined)
+        return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
+    switch (swapperName) {
+        case types_1.SwapperName.Zrx:
+        case types_1.SwapperName.Bebop:
+        case types_1.SwapperName.Test:
+            return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case types_1.SwapperName.CowSwap:
+            return DEFAULT_COWSWAP_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case types_1.SwapperName.Portals:
+            return DEFAULT_PORTALS_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case types_1.SwapperName.Thorchain:
+            return DEFAULT_THOR_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case types_1.SwapperName.Mayachain:
+            return DEFAULT_MAYA_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case types_1.SwapperName.ArbitrumBridge:
+            return DEFAULT_ARBITRUM_BRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case types_1.SwapperName.Chainflip:
+            return DEFAULT_CHAINFLIP_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case types_1.SwapperName.Jupiter:
+            throw new Error('Default slippage not supported by Jupiter');
+        case types_1.SwapperName.Relay:
+            throw new Error('Default slippage not supported by Relay');
+        case types_1.SwapperName.ButterSwap:
+            return DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case types_1.SwapperName.NearIntents:
+            return DEFAULT_NEAR_INTENTS_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case types_1.SwapperName.Cetus:
+            return DEFAULT_CETUS_SLIPPAGE_DECIMAL_PERCENTAGE;
+        default:
+            return (0, utils_1.assertUnreachable)(swapperName);
+    }
+};
+exports.getDefaultSlippageDecimalPercentageForSwapper = getDefaultSlippageDecimalPercentageForSwapper;
+const isAutoSlippageSupportedBySwapper = (swapperName) => {
+    switch (swapperName) {
+        case types_1.SwapperName.Jupiter:
+            return true;
+        case types_1.SwapperName.Relay:
+            return true;
+        default:
+            return false;
+    }
+};
+exports.isAutoSlippageSupportedBySwapper = isAutoSlippageSupportedBySwapper;

package/dist/cjs/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/cjs/cowswap-utils/constants.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS = exports.COW_SWAP_SETTLEMENT_ADDRESS = exports.COW_SWAP_VAULT_RELAYER_ADDRESS = exports.SUPPORTED_CHAIN_IDS = exports.DEFAULT_ADDRESS = exports.CANCELLATIONS_TYPE_FIELDS = exports.ORDER_TYPE_FIELDS = void 0;
+const types_1 = require("@shapeshiftoss/types");
+const viem_1 = require("viem");
+exports.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' },
+];
+exports.CANCELLATIONS_TYPE_FIELDS = [{ name: 'orderUids', type: 'bytes[]' }];
+exports.DEFAULT_ADDRESS = viem_1.zeroAddress;
+exports.SUPPORTED_CHAIN_IDS = [
+    types_1.KnownChainIds.EthereumMainnet,
+    types_1.KnownChainIds.GnosisMainnet,
+    types_1.KnownChainIds.ArbitrumMainnet,
+    types_1.KnownChainIds.BaseMainnet,
+    types_1.KnownChainIds.AvalancheMainnet,
+    types_1.KnownChainIds.PolygonMainnet,
+];
+exports.COW_SWAP_VAULT_RELAYER_ADDRESS = '0xc92e8bdf79f0507f65a392b0ab4667716bfe0110';
+exports.COW_SWAP_SETTLEMENT_ADDRESS = '0x9008D19f58AAbD9eD0D60971565AA8510560ab41';
+// Address used by CowSwap to buy ETH
+// See https://github.com/gnosis/gp-v2-contracts/commit/821b5a8da213297b0f7f1d8b17c893c5627020af#diff-12bbbe13cd5cf42d639e34a39d8795021ba40d3ee1e1a8282df652eb161a11d6R13
+exports.COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';

package/dist/cjs/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';
+export * from './constants';
+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/cjs/cowswap-utils/index.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFullAppData = exports.getAffiliateAppDataFragmentByChainId = exports.cowSwapTokenToAssetId = exports.signCowOrderCancellation = exports.signCowOrder = exports.signCowMessage = exports.assertGetCowNetwork = exports.getCowNetwork = void 0;
+const app_data_1 = require("@cowprotocol/app-data");
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const types_1 = require("@shapeshiftoss/types");
+const utils_1 = require("@shapeshiftoss/utils");
+const ethers_1 = require("ethers");
+const viem_1 = require("viem");
+const helpers_1 = require("../swappers/utils/helpers/helpers");
+const constants_1 = require("./constants");
+__exportStar(require("./constants"), exports);
+const getCowNetwork = (chainId) => {
+    switch (chainId) {
+        case types_1.KnownChainIds.EthereumMainnet:
+            return types_1.CowNetwork.Mainnet;
+        case types_1.KnownChainIds.GnosisMainnet:
+            return types_1.CowNetwork.Xdai;
+        case types_1.KnownChainIds.ArbitrumMainnet:
+            return types_1.CowNetwork.ArbitrumOne;
+        case types_1.KnownChainIds.BaseMainnet:
+            return types_1.CowNetwork.Base;
+        case types_1.KnownChainIds.AvalancheMainnet:
+            return types_1.CowNetwork.Avalanche;
+        case types_1.KnownChainIds.PolygonMainnet:
+            return types_1.CowNetwork.Polygon;
+        default:
+            return;
+    }
+};
+exports.getCowNetwork = getCowNetwork;
+const cowDomain = (chainId, verifyingContract) => {
+    return {
+        name: 'Gnosis Protocol',
+        version: 'v2',
+        chainId,
+        verifyingContract,
+    };
+};
+const assertGetCowNetwork = (chainId) => {
+    const maybeNetwork = (0, exports.getCowNetwork)(chainId);
+    if (!maybeNetwork)
+        throw Error('Unsupported chain');
+    return maybeNetwork;
+};
+exports.assertGetCowNetwork = assertGetCowNetwork;
+const signCowMessage = async (typedData, chainAdapter, accountMetadata, wallet) => {
+    const { bip44Params } = accountMetadata;
+    const typedDataToSign = {
+        addressNList: (0, chain_adapters_1.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_1.ethers.Signature.from(ethers_1.ethers.Signature.from(signedTypeData)).serialized;
+    return signature;
+};
+exports.signCowMessage = signCowMessage;
+const getSignTypeDataPayload = (chainId, primaryType, types, message) => {
+    const { chainReference } = (0, caip_1.fromChainId)(chainId);
+    const signingDomain = Number(chainReference);
+    const typedDataDomain = cowDomain(signingDomain, constants_1.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,
+    };
+};
+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, types_1.TypedDataPrimaryType.Order, { Order: constants_1.ORDER_TYPE_FIELDS }, message);
+    const signature = await signMessage(typedData);
+    return signature;
+};
+exports.signCowOrder = signCowOrder;
+const signCowOrderCancellation = async (orderUid, chainId, signMessage) => {
+    const typedData = getSignTypeDataPayload(chainId, types_1.TypedDataPrimaryType.OrderCancellations, { OrderCancellations: constants_1.CANCELLATIONS_TYPE_FIELDS }, { orderUids: [orderUid] });
+    const signature = await signMessage(typedData);
+    return signature;
+};
+exports.signCowOrderCancellation = signCowOrderCancellation;
+const cowSwapTokenToAssetId = (chainId, cowSwapToken) => {
+    const { chainNamespace, chainReference } = (0, caip_1.fromChainId)(chainId);
+    return cowSwapToken.toLowerCase() === constants_1.COW_SWAP_NATIVE_ASSET_MARKER_ADDRESS.toLowerCase()
+        ? (0, caip_1.toAssetId)({
+            chainId,
+            assetNamespace: 'slip44',
+            assetReference: (0, utils_1.getNativeFeeAssetReference)(chainNamespace, chainReference),
+        })
+        : (0, caip_1.toAssetId)({
+            chainId,
+            assetNamespace: caip_1.ASSET_NAMESPACE.erc20,
+            assetReference: cowSwapToken,
+        });
+};
+exports.cowSwapTokenToAssetId = cowSwapTokenToAssetId;
+const getAffiliateAppDataFragmentByChainId = ({ affiliateBps, chainId, }) => {
+    const hasAffiliateFee = (0, utils_1.bnOrZero)(affiliateBps).gt(0);
+    if (!hasAffiliateFee)
+        return {};
+    return {
+        partnerFee: {
+            bps: (0, utils_1.bnOrZero)(affiliateBps).toNumber(),
+            recipient: (0, helpers_1.getTreasuryAddressFromChainId)(chainId),
+        },
+    };
+};
+exports.getAffiliateAppDataFragmentByChainId = getAffiliateAppDataFragmentByChainId;
+const generateAppDataFromDoc = async (doc) => {
+    const appData = await (0, app_data_1.stringifyDeterministic)(doc);
+    const appDataKeccak256 = (0, viem_1.keccak256)((0, viem_1.stringToBytes)(appData));
+    return { fullAppData: appData, appDataKeccak256 };
+};
+const metadataApi = new app_data_1.MetadataApi();
+// See https://api.cow.fi/docs/#/default/post_api_v1_quote / https://github.com/cowprotocol/app-data
+const getFullAppData = async (slippageTolerancePercentage, affiliateAppDataFragment, orderClass1) => {
+    const APP_CODE = 'shapeshift';
+    const orderClass = { orderClass: orderClass1 };
+    const quote = {
+        slippageBips: (0, utils_1.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 };
+};
+exports.getFullAppData = getFullAppData;

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testData = void 0;
+__exportStar(require("./constants"), exports);
+__exportStar(require("./cowswap-utils"), exports);
+__exportStar(require("./safe-utils"), exports);
+__exportStar(require("./swapper"), exports);
+__exportStar(require("./swappers/ArbitrumBridgeSwapper"), exports);
+__exportStar(require("./swappers/BebopSwapper"), exports);
+__exportStar(require("./swappers/CetusSwapper"), exports);
+__exportStar(require("./swappers/ChainflipSwapper"), exports);
+__exportStar(require("./swappers/CowSwapper"), exports);
+__exportStar(require("./swappers/JupiterSwapper"), exports);
+__exportStar(require("./swappers/PortalsSwapper"), exports);
+__exportStar(require("./swappers/ThorchainSwapper"), exports);
+__exportStar(require("./swappers/MayachainSwapper"), exports);
+__exportStar(require("./swappers/ButterSwap"), exports);
+__exportStar(require("./swappers/utils/helpers/helpers"), exports);
+__exportStar(require("./thorchain-utils"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+exports.testData = __importStar(require("./swappers/utils/test-data"));

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/cjs/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/cjs/safe-utils/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainIdToSafeBaseUrl = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+exports.ChainIdToSafeBaseUrl = {
+    [caip_1.ethChainId]: 'https://safe-transaction-mainnet.safe.global',
+    [caip_1.avalancheChainId]: 'https://safe-transaction-avalanche.safe.global',
+    [caip_1.optimismChainId]: 'https://safe-transaction-optimism.safe.global',
+    [caip_1.bscChainId]: 'https://safe-transaction-bsc.safe.global',
+    [caip_1.polygonChainId]: 'https://safe-transaction-polygon.safe.global',
+    [caip_1.gnosisChainId]: 'https://safe-transaction-gnosis-chain.safe.global',
+    [caip_1.arbitrumChainId]: 'https://safe-transaction-arbitrum.safe.global',
+    [caip_1.baseChainId]: 'https://safe-transaction-base.safe.global',
+};

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

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

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

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSafeTransactionInfo = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("./constants");
+const nilSafeTransctionInfo = {
+    transaction: null,
+    isSafeTxHash: false,
+    isQueuedSafeTx: false,
+    isExecutedSafeTx: false,
+};
+const fetchSafeTransactionInfo = async ({ safeTxHash, address, chainId, fetchIsSmartContractAddressQuery, }) => {
+    if (!address || !chainId || !(0, chain_adapters_1.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 = constants_1.ChainIdToSafeBaseUrl[chainId];
+    if (!baseUrl) {
+        throw new Error(`Unsupported chain ID: ${chainId}`);
+    }
+    try {
+        const response = await axios_1.default.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;
+    }
+};
+exports.fetchSafeTransactionInfo = fetchSafeTransactionInfo;
+__exportStar(require("./types"), exports);

package/dist/cjs/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/cjs/safe-utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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