@shapeshiftoss/swapper 17.6.11 → 17.7.0

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

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

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

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

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

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

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

@@ -1,219 +0,0 @@
-import { ASSET_NAMESPACE, CHAIN_NAMESPACE, CHAIN_REFERENCE, fromAssetId, solAssetId, toAssetId, wrappedSolAssetId, } from '@shapeshiftoss/caip';
-import { bn, bnOrZero, convertDecimalPercentageToBasisPoints } from '@shapeshiftoss/utils';
-import { Err, Ok } from '@sniptt/monads';
-import { AddressLookupTableAccount, MessageV0, PublicKey, VersionedTransaction, } from '@solana/web3.js';
-import { v4 as uuid } from 'uuid';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { COMPUTE_UNIT_MARGIN_MULTIPLIER, TOKEN_2022_PROGRAM_ID } from '../utils/constants.js';
-import { calculateAccountCreationCosts, createSwapInstructions, getJupiterPrice, isSupportedChainId, } from '../utils/helpers.js';
-export 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[solAssetId];
-    if (accountNumber === undefined) {
-        return Err(makeSwapErrorRight({
-            message: `accountNumber is required`,
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
-    if (!isSupportedChainId(sellAsset.chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (!isSupportedChainId(buyAsset.chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (!sendAddress) {
-        return Err(makeSwapErrorRight({
-            message: `sendAddress is required`,
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
-    if (!solAsset) {
-        return Err(makeSwapErrorRight({
-            message: `solAsset is required`,
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
-    const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
-    const buyAssetAddress = buyAsset.assetId === solAssetId
-        ? fromAssetId(wrappedSolAssetId).assetReference
-        : fromAssetId(buyAsset.assetId).assetReference;
-    const sellAssetAddress = sellAsset.assetId === solAssetId
-        ? fromAssetId(wrappedSolAssetId).assetReference
-        : fromAssetId(sellAsset.assetId).assetReference;
-    const sellTokenInfo = await adapter
-        .getConnection()
-        .getAccountInfo(new PublicKey(sellAssetAddress));
-    const buyTokenInfo = await adapter.getConnection().getAccountInfo(new PublicKey(buyAssetAddress));
-    const isSellTokenToken2022 = sellTokenInfo?.owner.toString() === TOKEN_2022_PROGRAM_ID.toString();
-    const isBuyTokenToken2022 = buyTokenInfo?.owner.toString() === TOKEN_2022_PROGRAM_ID.toString();
-    const affiliateBps = isSellTokenToken2022 || isBuyTokenToken2022 ? '0' : input.affiliateBps;
-    const maybePriceResponse = await getJupiterPrice({
-        apiUrl: jupiterUrl,
-        sourceAssetAddress: sellAssetAddress,
-        destinationAssetAddress: buyAssetAddress,
-        commissionBps: affiliateBps,
-        amount: sellAmount,
-        slippageBps: input.slippageTolerancePercentageDecimal
-            ? convertDecimalPercentageToBasisPoints(input.slippageTolerancePercentageDecimal).toFixed()
-            : undefined,
-    });
-    if (maybePriceResponse.isErr()) {
-        return Err(makeSwapErrorRight({
-            message: 'Quote request failed',
-            code: 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
-    bn(priceResponse.slippageBps).div(100).div(100).toString();
-    const { instructions, addressLookupTableAddresses } = await createSwapInstructions({
-        priceResponse,
-        sendAddress,
-        receiveAddress,
-        affiliateBps,
-        buyAsset,
-        sellAsset,
-        adapter,
-        jupiterUrl,
-    });
-    // Build a trial VersionedTransaction to check if it exceeds the 1232-byte Solana tx size limit
-    const isOversized = await (async () => {
-        try {
-            const lookupTableInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAddresses);
-            const lookupTableAccounts = lookupTableInfos.map(info => new AddressLookupTableAccount({
-                key: new PublicKey(info.key),
-                state: AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
-            }));
-            const messageV0 = MessageV0.compile({
-                payerKey: new PublicKey(sendAddress),
-                instructions,
-                // Blockhash doesn't affect size, use a dummy one
-                recentBlockhash: PublicKey.default.toString(),
-                addressLookupTableAccounts: lookupTableAccounts,
-            });
-            const txBytes = new VersionedTransaction(messageV0).serialize();
-            return txBytes.length > 1232;
-        }
-        catch {
-            return false;
-        }
-    })();
-    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: bnOrZero(feeData.fast.chainSpecific.computeUnits)
-                    .times(COMPUTE_UNIT_MARGIN_MULTIPLIER)
-                    .toFixed(0),
-                priorityFee: feeData.fast.chainSpecific.priorityFee,
-            },
-        };
-    };
-    const protocolFees = priceResponse.routePlan.reduce((acc, route) => {
-        const feeAssetId = toAssetId({
-            assetReference: route.swapInfo.feeMint,
-            assetNamespace: ASSET_NAMESPACE.splToken,
-            chainNamespace: CHAIN_NAMESPACE.Solana,
-            chainReference: 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: bnOrZero(route.swapInfo.feeAmount).toFixed(0),
-            asset: feeAsset,
-        };
-        return acc;
-    }, {});
-    const quotes = [];
-    const feeData = await getFeeData();
-    const rate = getInputOutputRate({
-        sellAmountCryptoBaseUnit: priceResponse.inAmount,
-        buyAmountCryptoBaseUnit: priceResponse.outAmount,
-        sellAsset,
-        buyAsset,
-    });
-    const accountCreationFees = calculateAccountCreationCosts(instructions);
-    if (accountCreationFees !== '0') {
-        const solProtocolFeeAmount = bnOrZero(protocolFees[solAssetId]?.amountCryptoBaseUnit);
-        protocolFees[solAssetId] = {
-            requiresBalance: true,
-            amountCryptoBaseUnit: bnOrZero(solProtocolFeeAmount).plus(accountCreationFees).toFixed(),
-            asset: solAsset,
-        };
-    }
-    const tradeQuote = {
-        id: uuid(),
-        quoteOrRate: 'quote',
-        rate,
-        affiliateBps,
-        receiveAddress,
-        slippageTolerancePercentageDecimal,
-        priceImpactPercentageDecimal: priceResponse.priceImpactPct,
-        swapperName: SwapperName.Jupiter,
-        steps: [
-            {
-                accountNumber,
-                buyAmountBeforeFeesCryptoBaseUnit: priceResponse.outAmount,
-                buyAmountAfterFeesCryptoBaseUnit: priceResponse.outAmount,
-                sellAmountIncludingProtocolFeesCryptoBaseUnit: priceResponse.inAmount,
-                jupiterQuoteResponse: priceResponse,
-                solanaTransactionMetadata: {
-                    addressLookupTableAddresses,
-                    instructions,
-                    isOversized,
-                },
-                feeData: {
-                    protocolFees,
-                    networkFeeCryptoBaseUnit: feeData.txFee,
-                    chainSpecific: feeData.chainSpecific,
-                },
-                rate,
-                source: 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,
-                affiliateFee: buildAffiliateFee({
-                    strategy: 'buy_asset',
-                    affiliateBps,
-                    sellAsset,
-                    buyAsset,
-                    sellAmountCryptoBaseUnit: priceResponse.inAmount,
-                    buyAmountCryptoBaseUnit: priceResponse.outAmount,
-                }),
-            },
-        ],
-    };
-    quotes.push(tradeQuote);
-    return Ok(quotes);
-};

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

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

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

@@ -1,177 +0,0 @@
-import { ASSET_NAMESPACE, CHAIN_NAMESPACE, CHAIN_REFERENCE, fromAssetId, solAssetId, toAssetId, wrappedSolAssetId, } from '@shapeshiftoss/caip';
-import { bn, bnOrZero, convertDecimalPercentageToBasisPoints } from '@shapeshiftoss/utils';
-import { Err, Ok } from '@sniptt/monads';
-import { PublicKey } from '@solana/web3.js';
-import { v4 as uuid } from 'uuid';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { SOLANA_RANDOM_ADDRESS, TOKEN_2022_PROGRAM_ID } from '../utils/constants.js';
-import { calculateAccountCreationCosts, createSwapInstructions, getJupiterPrice, isSupportedChainId, } from '../utils/helpers.js';
-export 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[solAssetId];
-    if (!isSupportedChainId(sellAsset.chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (!isSupportedChainId(buyAsset.chainId)) {
-        return Err(makeSwapErrorRight({
-            message: `unsupported chainId`,
-            code: TradeQuoteError.UnsupportedChain,
-            details: { chainId: sellAsset.chainId },
-        }));
-    }
-    if (buyAsset.assetId === wrappedSolAssetId || sellAsset.assetId === wrappedSolAssetId) {
-        return Err(makeSwapErrorRight({
-            message: `Unsupported trade pair`,
-            code: TradeQuoteError.UnsupportedTradePair,
-        }));
-    }
-    if (!solAsset) {
-        return Err(makeSwapErrorRight({
-            message: `solAsset should be defined`,
-            code: TradeQuoteError.UnknownError,
-        }));
-    }
-    const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
-    const buyAssetAddress = buyAsset.assetId === solAssetId
-        ? fromAssetId(wrappedSolAssetId).assetReference
-        : fromAssetId(buyAsset.assetId).assetReference;
-    const sellAssetAddress = sellAsset.assetId === solAssetId
-        ? fromAssetId(wrappedSolAssetId).assetReference
-        : fromAssetId(sellAsset.assetId).assetReference;
-    const sellTokenInfo = await adapter
-        .getConnection()
-        .getAccountInfo(new PublicKey(sellAssetAddress));
-    const buyTokenInfo = await adapter.getConnection().getAccountInfo(new PublicKey(buyAssetAddress));
-    const isSellTokenToken2022 = sellTokenInfo?.owner.toString() === TOKEN_2022_PROGRAM_ID.toString();
-    const isBuyTokenToken2022 = buyTokenInfo?.owner.toString() === TOKEN_2022_PROGRAM_ID.toString();
-    const affiliateBps = isSellTokenToken2022 || isBuyTokenToken2022 ? '0' : input.affiliateBps;
-    const maybePriceResponse = await getJupiterPrice({
-        apiUrl: jupiterUrl,
-        sourceAssetAddress: sellAssetAddress,
-        destinationAssetAddress: buyAssetAddress,
-        commissionBps: affiliateBps,
-        amount: sellAmount,
-        slippageBps: input.slippageTolerancePercentageDecimal
-            ? convertDecimalPercentageToBasisPoints(input.slippageTolerancePercentageDecimal).toFixed()
-            : undefined,
-    });
-    if (maybePriceResponse.isErr()) {
-        return Err(makeSwapErrorRight({
-            message: 'Quote request failed',
-            code: TradeQuoteError.NoRouteFound,
-        }));
-    }
-    const { data: priceResponse } = maybePriceResponse.unwrap();
-    const { instructions } = await createSwapInstructions({
-        priceResponse,
-        sendAddress: input.sendAddress ?? 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 ?? SOLANA_RANDOM_ADDRESS,
-            value: sellAmount,
-            chainSpecific: {
-                from: input.sendAddress ?? SOLANA_RANDOM_ADDRESS,
-                instructions,
-            },
-        };
-        const { fast } = await sellAdapter.getFeeData(getFeeDataInput);
-        return { networkFeeCryptoBaseUnit: fast.txFee };
-    };
-    const protocolFees = priceResponse.routePlan.reduce((acc, route) => {
-        const feeAssetId = toAssetId({
-            assetReference: route.swapInfo.feeMint,
-            assetNamespace: ASSET_NAMESPACE.splToken,
-            chainNamespace: CHAIN_NAMESPACE.Solana,
-            chainReference: 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: bnOrZero(route.swapInfo.feeAmount).toFixed(0),
-            asset: feeAsset,
-        };
-        return acc;
-    }, {});
-    const rates = [];
-    const feeData = await getFeeData();
-    const inputOutputRate = 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
-    bn(priceResponse.slippageBps).div(100).div(100).toString();
-    const accountCreationFees = calculateAccountCreationCosts(instructions);
-    if (accountCreationFees !== '0') {
-        const solProtocolFeeAmount = bnOrZero(protocolFees[solAssetId]?.amountCryptoBaseUnit);
-        protocolFees[solAssetId] = {
-            requiresBalance: true,
-            amountCryptoBaseUnit: bnOrZero(solProtocolFeeAmount).plus(accountCreationFees).toFixed(),
-            asset: solAsset,
-        };
-    }
-    const tradeRate = {
-        id: uuid(),
-        quoteOrRate: 'rate',
-        rate: inputOutputRate,
-        receiveAddress,
-        affiliateBps,
-        priceImpactPercentageDecimal: priceResponse.priceImpactPct,
-        slippageTolerancePercentageDecimal,
-        swapperName: SwapperName.Jupiter,
-        steps: [
-            {
-                buyAmountBeforeFeesCryptoBaseUnit: priceResponse.outAmount,
-                buyAmountAfterFeesCryptoBaseUnit: priceResponse.outAmount,
-                sellAmountIncludingProtocolFeesCryptoBaseUnit: priceResponse.inAmount,
-                jupiterQuoteResponse: priceResponse,
-                feeData: {
-                    protocolFees,
-                    ...feeData,
-                },
-                rate: inputOutputRate,
-                source: 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,
-                affiliateFee: buildAffiliateFee({
-                    strategy: 'buy_asset',
-                    affiliateBps,
-                    sellAsset,
-                    buyAsset,
-                    sellAmountCryptoBaseUnit: priceResponse.inAmount,
-                    buyAmountCryptoBaseUnit: priceResponse.outAmount,
-                }),
-            },
-        ],
-    };
-    rates.push(tradeRate);
-    return Ok(rates);
-};

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

@@ -1,9 +0,0 @@
-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/esm/swappers/JupiterSwapper/utils/constants.js

@@ -1,11 +0,0 @@
-import { KnownChainIds } from '@shapeshiftoss/types';
-export const jupiterSupportedChainIds = [KnownChainIds.SolanaMainnet];
-export const PDA_ACCOUNT_CREATION_COST = 2040000;
-export const SOLANA_RANDOM_ADDRESS = '2zHKF6tqam3tnNFPK2E9nBDkV7GMXnvdJautmzqQdn8A';
-export const 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
-export const COMPUTE_UNIT_MARGIN_MULTIPLIER = 1.6;
-export const SHAPESHIFT_JUPITER_REFERRAL_KEY = 'Ajgmo453yGmcHDPoJBrMUj3GFwLVL7HaaZGNLkB8vREG';
-export const JUPITER_AFFILIATE_CONTRACT_ADDRESS = 'REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3';
-export const JUPITER_REFERALL_FEE_PROJECT_ACCOUNT = '45ruCyfdRkWpRNGEqWzjCiXRHkZs8WXCLQ67Pnpye7Hp';

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

@@ -1,56 +0,0 @@
-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.js';
-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/esm/swappers/JupiterSwapper/utils/helpers.js

@@ -1,169 +0,0 @@
-import { BorshInstructionCoder } from '@coral-xyz/anchor';
-import { ASSOCIATED_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@coral-xyz/anchor/dist/cjs/utils/token';
-import { fromAssetId, solAssetId, wrappedSolAssetId } from '@shapeshiftoss/caip';
-import { bnOrZero } from '@shapeshiftoss/utils';
-import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
-import { referralIdl } from '../idls/referral.js';
-import { JUPITER_AFFILIATE_CONTRACT_ADDRESS, JUPITER_REFERALL_FEE_PROJECT_ACCOUNT, jupiterSupportedChainIds, PDA_ACCOUNT_CREATION_COST, SHAPESHIFT_JUPITER_REFERRAL_KEY, TOKEN_2022_PROGRAM_ID, } from './constants.js';
-import { jupiterService } from './jupiterService.js';
-export const isSupportedChainId = (chainId) => {
-    return jupiterSupportedChainIds.includes(chainId);
-};
-const JUPITER_TRANSACTION_MAX_ACCOUNTS = 54;
-export const getJupiterPrice = ({ apiUrl, sourceAssetAddress, destinationAssetAddress, commissionBps, amount, slippageBps, }) => jupiterService.get(`${apiUrl}/quote` +
-    `?inputMint=${sourceAssetAddress}` +
-    `&outputMint=${destinationAssetAddress}` +
-    `&amount=${amount}` +
-    (slippageBps ? `&slippageBps=${slippageBps}` : `&dynamicSlippage=true`) +
-    `&maxAccounts=${JUPITER_TRANSACTION_MAX_ACCOUNTS}` +
-    `&platformFeeBps=${commissionBps}`);
-export const getJupiterSwapInstructions = ({ apiUrl, fromAddress, toAddress, rawQuote, feeAccount, }) => jupiterService.post(`${apiUrl}/swap-instructions`, {
-    userPublicKey: fromAddress,
-    destinationTokenAccount: toAddress,
-    quoteResponse: rawQuote,
-    dynamicComputeUnitLimit: true,
-    prioritizationFeeLamports: 'auto',
-    feeAccount,
-});
-export 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 PublicKey(buyTokenId));
-    const sellTokenInfo = await connection.getAccountInfo(new PublicKey(sellTokenId));
-    const isSellTokenToken2022 = sellTokenInfo?.owner.toString() === TOKEN_2022_PROGRAM_ID.toString();
-    if (buyTokenInfo?.owner.toString() !== TOKEN_PROGRAM_ID.toString() &&
-        sellTokenInfo?.owner.toString() !== TOKEN_PROGRAM_ID.toString()) {
-        return { tokenAccount: undefined, instruction: undefined };
-    }
-    const project = new PublicKey(JUPITER_REFERALL_FEE_PROJECT_ACCOUNT);
-    const referralPubkey = isSellTokenToken2022 ? buyAssetReferralPubKey : sellAssetReferralPubKey;
-    return {
-        tokenAccount: referralPubkey,
-        instruction: new TransactionInstruction({
-            keys: [
-                {
-                    pubkey: feePayerPubKey,
-                    isSigner: true,
-                    isWritable: true,
-                },
-                {
-                    pubkey: project,
-                    isWritable: false,
-                    isSigner: false,
-                },
-                {
-                    pubkey: new PublicKey(SHAPESHIFT_JUPITER_REFERRAL_KEY),
-                    isSigner: false,
-                    isWritable: false,
-                },
-                {
-                    pubkey: referralPubkey,
-                    isSigner: false,
-                    isWritable: true,
-                },
-                {
-                    pubkey: new PublicKey(isSellTokenToken2022 ? buyTokenId : sellTokenId),
-                    isSigner: false,
-                    isWritable: false,
-                },
-                {
-                    pubkey: SystemProgram.programId,
-                    isSigner: false,
-                    isWritable: false,
-                },
-                { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
-            ],
-            data: instructionData,
-            programId,
-        }),
-    };
-};
-export const calculateAccountCreationCosts = (instructions) => {
-    let totalCost = bnOrZero(0);
-    for (const ix of instructions) {
-        if (ix.programId.toString() === ASSOCIATED_PROGRAM_ID.toString()) {
-            if (ix.data?.[0] === 1) {
-                totalCost = totalCost.plus(PDA_ACCOUNT_CREATION_COST);
-            }
-        }
-    }
-    return totalCost.toString();
-};
-export const createSwapInstructions = async ({ priceResponse, sendAddress, receiveAddress, affiliateBps, buyAsset, sellAsset, adapter, jupiterUrl, }) => {
-    const isCrossAccountTrade = receiveAddress ? receiveAddress !== sendAddress : false;
-    const buyAssetAddress = buyAsset.assetId === solAssetId
-        ? fromAssetId(wrappedSolAssetId).assetReference
-        : fromAssetId(buyAsset.assetId).assetReference;
-    const sellAssetAddress = sellAsset.assetId === solAssetId
-        ? fromAssetId(wrappedSolAssetId).assetReference
-        : fromAssetId(sellAsset.assetId).assetReference;
-    const contractAddress = buyAsset.assetId === solAssetId ? undefined : 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] = PublicKey.findProgramAddressSync([
-        Buffer.from('referral_ata'),
-        new PublicKey(SHAPESHIFT_JUPITER_REFERRAL_KEY).toBuffer(),
-        new PublicKey(buyAssetAddress).toBuffer(),
-    ], new PublicKey(JUPITER_AFFILIATE_CONTRACT_ADDRESS));
-    const [sellAssetReferralPubKey] = PublicKey.findProgramAddressSync([
-        Buffer.from('referral_ata'),
-        new PublicKey(SHAPESHIFT_JUPITER_REFERRAL_KEY).toBuffer(),
-        new PublicKey(sellAssetAddress).toBuffer(),
-    ], new PublicKey(JUPITER_AFFILIATE_CONTRACT_ADDRESS));
-    const instructionData = new BorshInstructionCoder(referralIdl).encode('initializeReferralTokenAccount', {});
-    const { instruction: feeAccountInstruction, tokenAccount } = await getFeeTokenAccountAndInstruction({
-        feePayerPubKey: new PublicKey(sendAddress),
-        buyAssetReferralPubKey,
-        sellAssetReferralPubKey,
-        programId: new PublicKey(JUPITER_AFFILIATE_CONTRACT_ADDRESS),
-        instructionData,
-        buyTokenId: buyAssetAddress,
-        sellTokenId: sellAssetAddress,
-        connection: adapter.getConnection(),
-    });
-    const maybeSwapResponse = await 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 PublicKey(account.pubkey),
-        })),
-        data: Buffer.from(instruction.data, 'base64'),
-        programId: new 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 };
-};

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

@@ -1,5 +0,0 @@
-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("../../../index.js").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("../../../index.js").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("../../../index.js").SwapErrorRight>>;
-};