@shapeshiftoss/swapper 17.6.3 → 17.6.5

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

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

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

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

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,187 @@
+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 { 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,
+    });
+    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,
+                },
+                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,
+            },
+        ],
+    };
+    quotes.push(tradeQuote);
+    return Ok(quotes);
+};

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,168 @@
+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 { 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,
+            },
+        ],
+    };
+    rates.push(tradeRate);
+    return Ok(rates);
+};

package/dist/esm/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/esm/swappers/JupiterSwapper/utils/constants.js

@@ -0,0 +1,11 @@
+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

@@ -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.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

@@ -0,0 +1,169 @@
+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

@@ -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("../../../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>>;
+};

package/dist/esm/swappers/JupiterSwapper/utils/jupiterService.js

@@ -0,0 +1,12 @@
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+const maxAgeMillis = 15 * 1000;
+const cachedUrls = [];
+const axiosConfig = {
+    timeout: 10000,
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+    },
+};
+const jupiterServiceBase = createCache(maxAgeMillis, cachedUrls, axiosConfig);
+export const jupiterService = makeSwapperAxiosServiceMonadic(jupiterServiceBase);

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

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

package/dist/esm/swappers/MayachainSwapper/MayachainSwapper.js

@@ -0,0 +1,10 @@
+import { executeEvmTransaction } from '../../utils.js';
+export const mayachainSwapper = {
+    executeEvmTransaction,
+    executeCosmosSdkTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

package/dist/esm/swappers/MayachainSwapper/constants.d.ts

@@ -0,0 +1,6 @@
+import type { SwapSource } from '../../types.js';
+export declare const CACAO_PRECISION = 10;
+export declare const MAYACHAIN_PRECISION = 8;
+export declare const MAYACHAIN_AFFILIATE_NAME = "ssmaya";
+export declare const MAYACHAIN_SUPPORTED_CHAIN_IDS: import("@shapeshiftoss/caip").ChainId[];
+export declare const MAYACHAIN_STREAM_SWAP_SOURCE: SwapSource;