@shapeshiftoss/swapper 17.6.6 → 17.6.7

package/dist/cjs/swappers/JupiterSwapper/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils/constants';
+export * from './errorPatterns';

package/dist/cjs/swappers/JupiterSwapper/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./utils/constants"), exports);
+__exportStar(require("./errorPatterns"), exports);

package/dist/cjs/swappers/JupiterSwapper/swapperApi/getTradeQuote.d.ts

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

package/dist/cjs/swappers/JupiterSwapper/swapperApi/getTradeQuote.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeQuote = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const web3_js_1 = require("@solana/web3.js");
+const uuid_1 = require("uuid");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const constants_1 = require("../utils/constants");
+const helpers_1 = require("../utils/helpers");
+const getTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, receiveAddress, accountNumber, sendAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, } = input;
+    const { assetsById } = deps;
+    const jupiterUrl = deps.config.VITE_JUPITER_API_URL;
+    const solAsset = assetsById[caip_1.solAssetId];
+    if (accountNumber === undefined) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `accountNumber is required`,
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    if (!(0, helpers_1.isSupportedChainId)(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!(0, helpers_1.isSupportedChainId)(buyAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!sendAddress) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `sendAddress is required`,
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    if (!solAsset) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `solAsset is required`,
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+    const buyAssetAddress = buyAsset.assetId === caip_1.solAssetId
+        ? (0, caip_1.fromAssetId)(caip_1.wrappedSolAssetId).assetReference
+        : (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference;
+    const sellAssetAddress = sellAsset.assetId === caip_1.solAssetId
+        ? (0, caip_1.fromAssetId)(caip_1.wrappedSolAssetId).assetReference
+        : (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference;
+    const sellTokenInfo = await adapter
+        .getConnection()
+        .getAccountInfo(new web3_js_1.PublicKey(sellAssetAddress));
+    const buyTokenInfo = await adapter.getConnection().getAccountInfo(new web3_js_1.PublicKey(buyAssetAddress));
+    const isSellTokenToken2022 = sellTokenInfo?.owner.toString() === constants_1.TOKEN_2022_PROGRAM_ID.toString();
+    const isBuyTokenToken2022 = buyTokenInfo?.owner.toString() === constants_1.TOKEN_2022_PROGRAM_ID.toString();
+    const affiliateBps = isSellTokenToken2022 || isBuyTokenToken2022 ? '0' : input.affiliateBps;
+    const maybePriceResponse = await (0, helpers_1.getJupiterPrice)({
+        apiUrl: jupiterUrl,
+        sourceAssetAddress: sellAssetAddress,
+        destinationAssetAddress: buyAssetAddress,
+        commissionBps: affiliateBps,
+        amount: sellAmount,
+        slippageBps: input.slippageTolerancePercentageDecimal
+            ? (0, utils_1.convertDecimalPercentageToBasisPoints)(input.slippageTolerancePercentageDecimal).toFixed()
+            : undefined,
+    });
+    if (maybePriceResponse.isErr()) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Quote request failed',
+            code: types_1.TradeQuoteError.NoRouteFound,
+        }));
+    }
+    const { data: priceResponse } = maybePriceResponse.unwrap();
+    const slippageTolerancePercentageDecimal = 
+    // Divide by 100 to get actual decimal percentage from bps
+    // e.g for 0.5% bps, Jupiter represents this as 50. 50/100 = 0.5, then we div by 100 again to honour our decimal format e.g 0.5/100 = 0.005
+    (0, utils_1.bn)(priceResponse.slippageBps).div(100).div(100).toString();
+    const { instructions, addressLookupTableAddresses } = await (0, helpers_1.createSwapInstructions)({
+        priceResponse,
+        sendAddress,
+        receiveAddress,
+        affiliateBps,
+        buyAsset,
+        sellAsset,
+        adapter,
+        jupiterUrl,
+    });
+    const getFeeData = async () => {
+        const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+        const getFeeDataInput = {
+            to: '',
+            value: '0',
+            chainSpecific: {
+                from: sendAddress,
+                addressLookupTableAccounts: addressLookupTableAddresses,
+                instructions,
+            },
+        };
+        const feeData = await sellAdapter.getFeeData(getFeeDataInput);
+        return {
+            txFee: feeData.fast.txFee,
+            chainSpecific: {
+                computeUnits: (0, utils_1.bnOrZero)(feeData.fast.chainSpecific.computeUnits)
+                    .times(constants_1.COMPUTE_UNIT_MARGIN_MULTIPLIER)
+                    .toFixed(0),
+                priorityFee: feeData.fast.chainSpecific.priorityFee,
+            },
+        };
+    };
+    const protocolFees = priceResponse.routePlan.reduce((acc, route) => {
+        const feeAssetId = (0, caip_1.toAssetId)({
+            assetReference: route.swapInfo.feeMint,
+            assetNamespace: caip_1.ASSET_NAMESPACE.splToken,
+            chainNamespace: caip_1.CHAIN_NAMESPACE.Solana,
+            chainReference: caip_1.CHAIN_REFERENCE.SolanaMainnet,
+        });
+        const feeAsset = assetsById[feeAssetId];
+        // If we can't find the feeAsset, we can't provide a protocol fee to display
+        // But these fees exists at protocol level, it's mostly to make TS happy as we should have the market data and assets
+        if (!feeAsset)
+            return acc;
+        acc[feeAssetId] = {
+            requiresBalance: false,
+            amountCryptoBaseUnit: (0, utils_1.bnOrZero)(route.swapInfo.feeAmount).toFixed(0),
+            asset: feeAsset,
+        };
+        return acc;
+    }, {});
+    const quotes = [];
+    const feeData = await getFeeData();
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: priceResponse.inAmount,
+        buyAmountCryptoBaseUnit: priceResponse.outAmount,
+        sellAsset,
+        buyAsset,
+    });
+    const accountCreationFees = (0, helpers_1.calculateAccountCreationCosts)(instructions);
+    if (accountCreationFees !== '0') {
+        const solProtocolFeeAmount = (0, utils_1.bnOrZero)(protocolFees[caip_1.solAssetId]?.amountCryptoBaseUnit);
+        protocolFees[caip_1.solAssetId] = {
+            requiresBalance: true,
+            amountCryptoBaseUnit: (0, utils_1.bnOrZero)(solProtocolFeeAmount).plus(accountCreationFees).toFixed(),
+            asset: solAsset,
+        };
+    }
+    const tradeQuote = {
+        id: (0, uuid_1.v4)(),
+        quoteOrRate: 'quote',
+        rate,
+        affiliateBps,
+        receiveAddress,
+        slippageTolerancePercentageDecimal,
+        priceImpactPercentageDecimal: priceResponse.priceImpactPct,
+        swapperName: types_1.SwapperName.Jupiter,
+        steps: [
+            {
+                accountNumber,
+                buyAmountBeforeFeesCryptoBaseUnit: priceResponse.outAmount,
+                buyAmountAfterFeesCryptoBaseUnit: priceResponse.outAmount,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit: priceResponse.inAmount,
+                jupiterQuoteResponse: priceResponse,
+                solanaTransactionMetadata: {
+                    addressLookupTableAddresses,
+                    instructions,
+                },
+                feeData: {
+                    protocolFees,
+                    networkFeeCryptoBaseUnit: feeData.txFee,
+                    chainSpecific: feeData.chainSpecific,
+                },
+                rate,
+                source: types_1.SwapperName.Jupiter,
+                buyAsset,
+                sellAsset,
+                allowanceContract: '0x0',
+                // Swap are so fasts on solana that times are under 100ms displaying 0 or very small amount of time is not user friendly
+                estimatedExecutionTimeMs: undefined,
+            },
+        ],
+    };
+    quotes.push(tradeQuote);
+    return (0, monads_1.Ok)(quotes);
+};
+exports.getTradeQuote = getTradeQuote;

package/dist/cjs/swappers/JupiterSwapper/swapperApi/getTradeRate.d.ts

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

package/dist/cjs/swappers/JupiterSwapper/swapperApi/getTradeRate.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeRate = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const web3_js_1 = require("@solana/web3.js");
+const uuid_1 = require("uuid");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const constants_1 = require("../utils/constants");
+const helpers_1 = require("../utils/helpers");
+const getTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, receiveAddress, accountNumber, } = input;
+    const { assetsById } = deps;
+    const jupiterUrl = deps.config.VITE_JUPITER_API_URL;
+    const solAsset = assetsById[caip_1.solAssetId];
+    if (!(0, helpers_1.isSupportedChainId)(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!(0, helpers_1.isSupportedChainId)(buyAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (buyAsset.assetId === caip_1.wrappedSolAssetId || sellAsset.assetId === caip_1.wrappedSolAssetId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Unsupported trade pair`,
+            code: types_1.TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    if (!solAsset) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `solAsset should be defined`,
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+    const buyAssetAddress = buyAsset.assetId === caip_1.solAssetId
+        ? (0, caip_1.fromAssetId)(caip_1.wrappedSolAssetId).assetReference
+        : (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference;
+    const sellAssetAddress = sellAsset.assetId === caip_1.solAssetId
+        ? (0, caip_1.fromAssetId)(caip_1.wrappedSolAssetId).assetReference
+        : (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference;
+    const sellTokenInfo = await adapter
+        .getConnection()
+        .getAccountInfo(new web3_js_1.PublicKey(sellAssetAddress));
+    const buyTokenInfo = await adapter.getConnection().getAccountInfo(new web3_js_1.PublicKey(buyAssetAddress));
+    const isSellTokenToken2022 = sellTokenInfo?.owner.toString() === constants_1.TOKEN_2022_PROGRAM_ID.toString();
+    const isBuyTokenToken2022 = buyTokenInfo?.owner.toString() === constants_1.TOKEN_2022_PROGRAM_ID.toString();
+    const affiliateBps = isSellTokenToken2022 || isBuyTokenToken2022 ? '0' : input.affiliateBps;
+    const maybePriceResponse = await (0, helpers_1.getJupiterPrice)({
+        apiUrl: jupiterUrl,
+        sourceAssetAddress: sellAssetAddress,
+        destinationAssetAddress: buyAssetAddress,
+        commissionBps: affiliateBps,
+        amount: sellAmount,
+        slippageBps: input.slippageTolerancePercentageDecimal
+            ? (0, utils_1.convertDecimalPercentageToBasisPoints)(input.slippageTolerancePercentageDecimal).toFixed()
+            : undefined,
+    });
+    if (maybePriceResponse.isErr()) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Quote request failed',
+            code: types_1.TradeQuoteError.NoRouteFound,
+        }));
+    }
+    const { data: priceResponse } = maybePriceResponse.unwrap();
+    const { instructions } = await (0, helpers_1.createSwapInstructions)({
+        priceResponse,
+        sendAddress: input.sendAddress ?? constants_1.SOLANA_RANDOM_ADDRESS,
+        receiveAddress,
+        affiliateBps,
+        buyAsset,
+        sellAsset,
+        adapter,
+        jupiterUrl,
+    });
+    const getFeeData = async () => {
+        const sellAdapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+        const getFeeDataInput = {
+            // Use real address and instructions for accurate fee estimation whenever possible (Solana account connected)
+            to: input.sendAddress ?? constants_1.SOLANA_RANDOM_ADDRESS,
+            value: sellAmount,
+            chainSpecific: {
+                from: input.sendAddress ?? constants_1.SOLANA_RANDOM_ADDRESS,
+                instructions,
+            },
+        };
+        const { fast } = await sellAdapter.getFeeData(getFeeDataInput);
+        return { networkFeeCryptoBaseUnit: fast.txFee };
+    };
+    const protocolFees = priceResponse.routePlan.reduce((acc, route) => {
+        const feeAssetId = (0, caip_1.toAssetId)({
+            assetReference: route.swapInfo.feeMint,
+            assetNamespace: caip_1.ASSET_NAMESPACE.splToken,
+            chainNamespace: caip_1.CHAIN_NAMESPACE.Solana,
+            chainReference: caip_1.CHAIN_REFERENCE.SolanaMainnet,
+        });
+        const feeAsset = assetsById[feeAssetId];
+        // If we can't find the feeAsset, we can't provide a protocol fee to display
+        // But these fees exists at protocol level, it's mostly to make TS happy as we should have the market data and assets
+        if (!feeAsset)
+            return acc;
+        acc[feeAssetId] = {
+            requiresBalance: false,
+            amountCryptoBaseUnit: (0, utils_1.bnOrZero)(route.swapInfo.feeAmount).toFixed(0),
+            asset: feeAsset,
+        };
+        return acc;
+    }, {});
+    const rates = [];
+    const feeData = await getFeeData();
+    const inputOutputRate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: priceResponse.inAmount,
+        buyAmountCryptoBaseUnit: priceResponse.outAmount,
+        sellAsset,
+        buyAsset,
+    });
+    const slippageTolerancePercentageDecimal = 
+    // Divide by 100 to get actual decimal percentage from bps
+    // e.g for 0.5% bps, Jupiter represents this as 50. 50/100 = 0.5, then we div by 100 again to honour our decimal format e.g 0.5/100 = 0.005
+    (0, utils_1.bn)(priceResponse.slippageBps).div(100).div(100).toString();
+    const accountCreationFees = (0, helpers_1.calculateAccountCreationCosts)(instructions);
+    if (accountCreationFees !== '0') {
+        const solProtocolFeeAmount = (0, utils_1.bnOrZero)(protocolFees[caip_1.solAssetId]?.amountCryptoBaseUnit);
+        protocolFees[caip_1.solAssetId] = {
+            requiresBalance: true,
+            amountCryptoBaseUnit: (0, utils_1.bnOrZero)(solProtocolFeeAmount).plus(accountCreationFees).toFixed(),
+            asset: solAsset,
+        };
+    }
+    const tradeRate = {
+        id: (0, uuid_1.v4)(),
+        quoteOrRate: 'rate',
+        rate: inputOutputRate,
+        receiveAddress,
+        affiliateBps,
+        priceImpactPercentageDecimal: priceResponse.priceImpactPct,
+        slippageTolerancePercentageDecimal,
+        swapperName: types_1.SwapperName.Jupiter,
+        steps: [
+            {
+                buyAmountBeforeFeesCryptoBaseUnit: priceResponse.outAmount,
+                buyAmountAfterFeesCryptoBaseUnit: priceResponse.outAmount,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit: priceResponse.inAmount,
+                jupiterQuoteResponse: priceResponse,
+                feeData: {
+                    protocolFees,
+                    ...feeData,
+                },
+                rate: inputOutputRate,
+                source: types_1.SwapperName.Jupiter,
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                allowanceContract: '0x0',
+                // Swap are so fasts on solana that times are under 100ms displaying 0 or very small amount of time is not user friendly
+                estimatedExecutionTimeMs: undefined,
+            },
+        ],
+    };
+    rates.push(tradeRate);
+    return (0, monads_1.Ok)(rates);
+};
+exports.getTradeRate = getTradeRate;

package/dist/cjs/swappers/JupiterSwapper/utils/constants.d.ts

@@ -0,0 +1,9 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const jupiterSupportedChainIds: ChainId[];
+export declare const PDA_ACCOUNT_CREATION_COST = 2040000;
+export declare const SOLANA_RANDOM_ADDRESS = "2zHKF6tqam3tnNFPK2E9nBDkV7GMXnvdJautmzqQdn8A";
+export declare const TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+export declare const COMPUTE_UNIT_MARGIN_MULTIPLIER = 1.6;
+export declare const SHAPESHIFT_JUPITER_REFERRAL_KEY = "Ajgmo453yGmcHDPoJBrMUj3GFwLVL7HaaZGNLkB8vREG";
+export declare const JUPITER_AFFILIATE_CONTRACT_ADDRESS = "REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3";
+export declare const JUPITER_REFERALL_FEE_PROJECT_ACCOUNT = "45ruCyfdRkWpRNGEqWzjCiXRHkZs8WXCLQ67Pnpye7Hp";

package/dist/cjs/swappers/JupiterSwapper/utils/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JUPITER_REFERALL_FEE_PROJECT_ACCOUNT = exports.JUPITER_AFFILIATE_CONTRACT_ADDRESS = exports.SHAPESHIFT_JUPITER_REFERRAL_KEY = exports.COMPUTE_UNIT_MARGIN_MULTIPLIER = exports.TOKEN_2022_PROGRAM_ID = exports.SOLANA_RANDOM_ADDRESS = exports.PDA_ACCOUNT_CREATION_COST = exports.jupiterSupportedChainIds = void 0;
+const types_1 = require("@shapeshiftoss/types");
+exports.jupiterSupportedChainIds = [types_1.KnownChainIds.SolanaMainnet];
+exports.PDA_ACCOUNT_CREATION_COST = 2040000;
+exports.SOLANA_RANDOM_ADDRESS = '2zHKF6tqam3tnNFPK2E9nBDkV7GMXnvdJautmzqQdn8A';
+exports.TOKEN_2022_PROGRAM_ID = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
+// Jupiter use 40% as a compute unit margin while calculating them, some TX reverts without this, as we add some compute units
+// for account creations and referral, for stability purposes we add 60% margin
+exports.COMPUTE_UNIT_MARGIN_MULTIPLIER = 1.6;
+exports.SHAPESHIFT_JUPITER_REFERRAL_KEY = 'Ajgmo453yGmcHDPoJBrMUj3GFwLVL7HaaZGNLkB8vREG';
+exports.JUPITER_AFFILIATE_CONTRACT_ADDRESS = 'REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3';
+exports.JUPITER_REFERALL_FEE_PROJECT_ACCOUNT = '45ruCyfdRkWpRNGEqWzjCiXRHkZs8WXCLQ67Pnpye7Hp';

package/dist/cjs/swappers/JupiterSwapper/utils/helpers.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { QuoteResponse, SwapInstructionsResponse } from '@jup-ag/api';
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { solana } from '@shapeshiftoss/chain-adapters';
+import type { Asset, KnownChainIds } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { Connection } from '@solana/web3.js';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+import type { AxiosResponse } from 'axios';
+import type { SwapErrorRight } from '../../../types';
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownChainIds.SolanaMainnet;
+type GetJupiterQuoteArgs = {
+    apiUrl: string;
+    sourceAssetAddress: string;
+    destinationAssetAddress: string;
+    commissionBps: string;
+    amount: string;
+    slippageBps: string | undefined;
+};
+type GetJupiterSwapArgs = {
+    apiUrl: string;
+    fromAddress: string;
+    rawQuote: unknown;
+    toAddress?: string;
+    feeAccount: string | undefined;
+};
+type CreateInstructionsParams = {
+    priceResponse: QuoteResponse;
+    sendAddress: string;
+    receiveAddress?: string;
+    affiliateBps: string;
+    buyAsset: Asset;
+    sellAsset: any;
+    adapter: solana.ChainAdapter;
+    jupiterUrl: string;
+};
+export declare const getJupiterPrice: ({ apiUrl, sourceAssetAddress, destinationAssetAddress, commissionBps, amount, slippageBps, }: GetJupiterQuoteArgs) => Promise<Result<AxiosResponse<QuoteResponse, any>, SwapErrorRight>>;
+export declare const getJupiterSwapInstructions: ({ apiUrl, fromAddress, toAddress, rawQuote, feeAccount, }: GetJupiterSwapArgs) => Promise<Result<AxiosResponse<SwapInstructionsResponse, any>, SwapErrorRight>>;
+export declare const getFeeTokenAccountAndInstruction: ({ feePayerPubKey, programId, buyAssetReferralPubKey, sellAssetReferralPubKey, buyTokenId, sellTokenId, instructionData, connection, }: {
+    feePayerPubKey: PublicKey;
+    programId: PublicKey;
+    buyAssetReferralPubKey: PublicKey;
+    sellAssetReferralPubKey: PublicKey;
+    buyTokenId: string;
+    sellTokenId: string;
+    instructionData: Buffer;
+    connection: Connection;
+}) => Promise<{
+    tokenAccount?: PublicKey;
+    instruction?: TransactionInstruction | undefined;
+}>;
+export declare const calculateAccountCreationCosts: (instructions: TransactionInstruction[]) => string;
+export declare const createSwapInstructions: ({ priceResponse, sendAddress, receiveAddress, affiliateBps, buyAsset, sellAsset, adapter, jupiterUrl, }: CreateInstructionsParams) => Promise<{
+    instructions: TransactionInstruction[];
+    addressLookupTableAddresses: string[];
+}>;
+export {};

package/dist/cjs/swappers/JupiterSwapper/utils/helpers.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSwapInstructions = exports.calculateAccountCreationCosts = exports.getFeeTokenAccountAndInstruction = exports.getJupiterSwapInstructions = exports.getJupiterPrice = exports.isSupportedChainId = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const token_1 = require("@coral-xyz/anchor/dist/cjs/utils/token");
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const web3_js_1 = require("@solana/web3.js");
+const referral_1 = require("../idls/referral");
+const constants_1 = require("./constants");
+const jupiterService_1 = require("./jupiterService");
+const isSupportedChainId = (chainId) => {
+    return constants_1.jupiterSupportedChainIds.includes(chainId);
+};
+exports.isSupportedChainId = isSupportedChainId;
+const JUPITER_TRANSACTION_MAX_ACCOUNTS = 54;
+const getJupiterPrice = ({ apiUrl, sourceAssetAddress, destinationAssetAddress, commissionBps, amount, slippageBps, }) => jupiterService_1.jupiterService.get(`${apiUrl}/quote` +
+    `?inputMint=${sourceAssetAddress}` +
+    `&outputMint=${destinationAssetAddress}` +
+    `&amount=${amount}` +
+    (slippageBps ? `&slippageBps=${slippageBps}` : `&dynamicSlippage=true`) +
+    `&maxAccounts=${JUPITER_TRANSACTION_MAX_ACCOUNTS}` +
+    `&platformFeeBps=${commissionBps}`);
+exports.getJupiterPrice = getJupiterPrice;
+const getJupiterSwapInstructions = ({ apiUrl, fromAddress, toAddress, rawQuote, feeAccount, }) => jupiterService_1.jupiterService.post(`${apiUrl}/swap-instructions`, {
+    userPublicKey: fromAddress,
+    destinationTokenAccount: toAddress,
+    quoteResponse: rawQuote,
+    dynamicComputeUnitLimit: true,
+    prioritizationFeeLamports: 'auto',
+    feeAccount,
+});
+exports.getJupiterSwapInstructions = getJupiterSwapInstructions;
+const getFeeTokenAccountAndInstruction = async ({ feePayerPubKey, programId, buyAssetReferralPubKey, sellAssetReferralPubKey, buyTokenId, sellTokenId, instructionData, connection, }) => {
+    const sellAssetTokenAccount = await connection.getAccountInfo(sellAssetReferralPubKey);
+    if (sellAssetTokenAccount)
+        return { tokenAccount: sellAssetReferralPubKey };
+    const buyAssetTokenAccount = await connection.getAccountInfo(buyAssetReferralPubKey);
+    if (buyAssetTokenAccount)
+        return { tokenAccount: buyAssetReferralPubKey };
+    const buyTokenInfo = await connection.getAccountInfo(new web3_js_1.PublicKey(buyTokenId));
+    const sellTokenInfo = await connection.getAccountInfo(new web3_js_1.PublicKey(sellTokenId));
+    const isSellTokenToken2022 = sellTokenInfo?.owner.toString() === constants_1.TOKEN_2022_PROGRAM_ID.toString();
+    if (buyTokenInfo?.owner.toString() !== token_1.TOKEN_PROGRAM_ID.toString() &&
+        sellTokenInfo?.owner.toString() !== token_1.TOKEN_PROGRAM_ID.toString()) {
+        return { tokenAccount: undefined, instruction: undefined };
+    }
+    const project = new web3_js_1.PublicKey(constants_1.JUPITER_REFERALL_FEE_PROJECT_ACCOUNT);
+    const referralPubkey = isSellTokenToken2022 ? buyAssetReferralPubKey : sellAssetReferralPubKey;
+    return {
+        tokenAccount: referralPubkey,
+        instruction: new web3_js_1.TransactionInstruction({
+            keys: [
+                {
+                    pubkey: feePayerPubKey,
+                    isSigner: true,
+                    isWritable: true,
+                },
+                {
+                    pubkey: project,
+                    isWritable: false,
+                    isSigner: false,
+                },
+                {
+                    pubkey: new web3_js_1.PublicKey(constants_1.SHAPESHIFT_JUPITER_REFERRAL_KEY),
+                    isSigner: false,
+                    isWritable: false,
+                },
+                {
+                    pubkey: referralPubkey,
+                    isSigner: false,
+                    isWritable: true,
+                },
+                {
+                    pubkey: new web3_js_1.PublicKey(isSellTokenToken2022 ? buyTokenId : sellTokenId),
+                    isSigner: false,
+                    isWritable: false,
+                },
+                {
+                    pubkey: web3_js_1.SystemProgram.programId,
+                    isSigner: false,
+                    isWritable: false,
+                },
+                { pubkey: token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            ],
+            data: instructionData,
+            programId,
+        }),
+    };
+};
+exports.getFeeTokenAccountAndInstruction = getFeeTokenAccountAndInstruction;
+const calculateAccountCreationCosts = (instructions) => {
+    let totalCost = (0, utils_1.bnOrZero)(0);
+    for (const ix of instructions) {
+        if (ix.programId.toString() === token_1.ASSOCIATED_PROGRAM_ID.toString()) {
+            if (ix.data?.[0] === 1) {
+                totalCost = totalCost.plus(constants_1.PDA_ACCOUNT_CREATION_COST);
+            }
+        }
+    }
+    return totalCost.toString();
+};
+exports.calculateAccountCreationCosts = calculateAccountCreationCosts;
+const createSwapInstructions = async ({ priceResponse, sendAddress, receiveAddress, affiliateBps, buyAsset, sellAsset, adapter, jupiterUrl, }) => {
+    const isCrossAccountTrade = receiveAddress ? receiveAddress !== sendAddress : false;
+    const buyAssetAddress = buyAsset.assetId === caip_1.solAssetId
+        ? (0, caip_1.fromAssetId)(caip_1.wrappedSolAssetId).assetReference
+        : (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference;
+    const sellAssetAddress = sellAsset.assetId === caip_1.solAssetId
+        ? (0, caip_1.fromAssetId)(caip_1.wrappedSolAssetId).assetReference
+        : (0, caip_1.fromAssetId)(sellAsset.assetId).assetReference;
+    const contractAddress = buyAsset.assetId === caip_1.solAssetId ? undefined : (0, caip_1.fromAssetId)(buyAsset.assetId).assetReference;
+    const { instruction: createTokenAccountInstruction, destinationTokenAccount } = contractAddress && isCrossAccountTrade && receiveAddress
+        ? await adapter.createAssociatedTokenAccountInstruction({
+            from: sendAddress,
+            to: receiveAddress,
+            tokenId: contractAddress,
+        })
+        : { instruction: undefined, destinationTokenAccount: undefined };
+    const [buyAssetReferralPubKey] = web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from('referral_ata'),
+        new web3_js_1.PublicKey(constants_1.SHAPESHIFT_JUPITER_REFERRAL_KEY).toBuffer(),
+        new web3_js_1.PublicKey(buyAssetAddress).toBuffer(),
+    ], new web3_js_1.PublicKey(constants_1.JUPITER_AFFILIATE_CONTRACT_ADDRESS));
+    const [sellAssetReferralPubKey] = web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from('referral_ata'),
+        new web3_js_1.PublicKey(constants_1.SHAPESHIFT_JUPITER_REFERRAL_KEY).toBuffer(),
+        new web3_js_1.PublicKey(sellAssetAddress).toBuffer(),
+    ], new web3_js_1.PublicKey(constants_1.JUPITER_AFFILIATE_CONTRACT_ADDRESS));
+    const instructionData = new anchor_1.BorshInstructionCoder(referral_1.referralIdl).encode('initializeReferralTokenAccount', {});
+    const { instruction: feeAccountInstruction, tokenAccount } = await (0, exports.getFeeTokenAccountAndInstruction)({
+        feePayerPubKey: new web3_js_1.PublicKey(sendAddress),
+        buyAssetReferralPubKey,
+        sellAssetReferralPubKey,
+        programId: new web3_js_1.PublicKey(constants_1.JUPITER_AFFILIATE_CONTRACT_ADDRESS),
+        instructionData,
+        buyTokenId: buyAssetAddress,
+        sellTokenId: sellAssetAddress,
+        connection: adapter.getConnection(),
+    });
+    const maybeSwapResponse = await (0, exports.getJupiterSwapInstructions)({
+        apiUrl: jupiterUrl,
+        fromAddress: sendAddress,
+        toAddress: isCrossAccountTrade ? destinationTokenAccount?.toString() : undefined,
+        rawQuote: priceResponse,
+        feeAccount: affiliateBps !== '0' && tokenAccount ? tokenAccount.toString() : undefined,
+    });
+    if (maybeSwapResponse.isErr()) {
+        const error = maybeSwapResponse.unwrapErr();
+        const cause = error.cause;
+        throw Error(cause.response?.data.detail);
+    }
+    const { data: swapResponse } = maybeSwapResponse.unwrap();
+    const convertJupiterInstruction = (instruction) => ({
+        ...instruction,
+        keys: instruction.accounts.map(account => ({
+            ...account,
+            pubkey: new web3_js_1.PublicKey(account.pubkey),
+        })),
+        data: Buffer.from(instruction.data, 'base64'),
+        programId: new web3_js_1.PublicKey(instruction.programId),
+    });
+    const instructions = [
+        ...swapResponse.setupInstructions.map(convertJupiterInstruction),
+        convertJupiterInstruction(swapResponse.swapInstruction),
+    ];
+    if (feeAccountInstruction && affiliateBps !== '0') {
+        instructions.unshift(feeAccountInstruction);
+    }
+    if (createTokenAccountInstruction) {
+        instructions.unshift(createTokenAccountInstruction);
+    }
+    if (swapResponse.cleanupInstruction) {
+        instructions.push(convertJupiterInstruction(swapResponse.cleanupInstruction));
+    }
+    return { instructions, addressLookupTableAddresses: swapResponse.addressLookupTableAddresses };
+};
+exports.createSwapInstructions = createSwapInstructions;

package/dist/cjs/swappers/JupiterSwapper/utils/jupiterService.d.ts

@@ -0,0 +1,5 @@
+export declare const jupiterService: {
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../..").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../..").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../..").SwapErrorRight>>;
+};