|
| 1 | +import { Connection, PublicKey } from "@solana/web3.js"; |
| 2 | +import fetch from "isomorphic-fetch"; |
| 3 | + |
| 4 | +import { Jupiter, RouteInfo, TOKEN_LIST_URL } from "@jup-ag/core"; |
| 5 | +import { |
| 6 | + ENV, |
| 7 | + INPUT_MINT_ADDRESS, |
| 8 | + OUTPUT_MINT_ADDRESS, |
| 9 | + SOLANA_RPC_ENDPOINT, |
| 10 | + Token, |
| 11 | + USER_KEYPAIR, |
| 12 | +} from "./constants"; |
| 13 | + |
| 14 | +const getPossiblePairsTokenInfo = ({ |
| 15 | + tokens, |
| 16 | + routeMap, |
| 17 | + inputToken, |
| 18 | +}: { |
| 19 | + tokens: Token[]; |
| 20 | + routeMap: Map<string, string[]>; |
| 21 | + inputToken?: Token; |
| 22 | +}) => { |
| 23 | + try { |
| 24 | + if (!inputToken) { |
| 25 | + return {}; |
| 26 | + } |
| 27 | + |
| 28 | + const possiblePairs = inputToken |
| 29 | + ? routeMap.get(inputToken.address) || [] |
| 30 | + : []; // return an array of token mints that can be swapped with SOL |
| 31 | + const possiblePairsTokenInfo: { [key: string]: Token | undefined } = {}; |
| 32 | + possiblePairs.forEach((address) => { |
| 33 | + possiblePairsTokenInfo[address] = tokens.find((t) => { |
| 34 | + return t.address == address; |
| 35 | + }); |
| 36 | + }); |
| 37 | + // Perform your conditionals here to use other outputToken |
| 38 | + // const alternativeOutputToken = possiblePairsTokenInfo[USDT_MINT_ADDRESS] |
| 39 | + return possiblePairsTokenInfo; |
| 40 | + } catch (error) { |
| 41 | + throw error; |
| 42 | + } |
| 43 | +}; |
| 44 | + |
| 45 | +const getRoutes = async ({ |
| 46 | + jupiter, |
| 47 | + inputToken, |
| 48 | + outputToken, |
| 49 | + inputAmount, |
| 50 | + slippage, |
| 51 | +}: { |
| 52 | + jupiter: Jupiter; |
| 53 | + inputToken?: Token; |
| 54 | + outputToken?: Token; |
| 55 | + inputAmount: number; |
| 56 | + slippage: number; |
| 57 | +}) => { |
| 58 | + try { |
| 59 | + if (!inputToken || !outputToken) { |
| 60 | + return null; |
| 61 | + } |
| 62 | + |
| 63 | + console.log( |
| 64 | + `Getting routes for ${inputAmount} ${inputToken.symbol} -> ${outputToken.symbol}...` |
| 65 | + ); |
| 66 | + const inputAmountInSmallestUnits = inputToken |
| 67 | + ? Math.round(inputAmount * 10 ** inputToken.decimals) |
| 68 | + : 0; |
| 69 | + const routes = |
| 70 | + inputToken && outputToken |
| 71 | + ? await jupiter.computeRoutes({ |
| 72 | + inputMint: new PublicKey(inputToken.address), |
| 73 | + outputMint: new PublicKey(outputToken.address), |
| 74 | + inputAmount: inputAmountInSmallestUnits, // raw input amount of tokens |
| 75 | + slippage, |
| 76 | + forceFetch: true, |
| 77 | + }) |
| 78 | + : null; |
| 79 | + |
| 80 | + if (routes && routes.routesInfos) { |
| 81 | + console.log("Possible number of routes:", routes.routesInfos.length); |
| 82 | + console.log( |
| 83 | + "Best quote: ", |
| 84 | + routes.routesInfos[0].outAmount / 10 ** outputToken.decimals, |
| 85 | + `(${outputToken.symbol})` |
| 86 | + ); |
| 87 | + return routes; |
| 88 | + } else { |
| 89 | + return null; |
| 90 | + } |
| 91 | + } catch (error) { |
| 92 | + throw error; |
| 93 | + } |
| 94 | +}; |
| 95 | + |
| 96 | +const executeSwap = async ({ |
| 97 | + jupiter, |
| 98 | + route, |
| 99 | +}: { |
| 100 | + jupiter: Jupiter; |
| 101 | + route: RouteInfo; |
| 102 | +}) => { |
| 103 | + try { |
| 104 | + // Prepare execute exchange |
| 105 | + const { execute } = await jupiter.exchange({ |
| 106 | + route, |
| 107 | + }); |
| 108 | + |
| 109 | + // Execute swap |
| 110 | + const swapResult: any = await execute(); // Force any to ignore TS misidentifying SwapResult type |
| 111 | + |
| 112 | + if (swapResult.error) { |
| 113 | + console.log(swapResult.error); |
| 114 | + } else { |
| 115 | + console.log(`https://explorer.solana.com/tx/${swapResult.txid}`); |
| 116 | + console.log( |
| 117 | + `inputAddress=${swapResult.inputAddress.toString()} outputAddress=${swapResult.outputAddress.toString()}` |
| 118 | + ); |
| 119 | + console.log( |
| 120 | + `inputAmount=${swapResult.inputAmount} outputAmount=${swapResult.outputAmount}` |
| 121 | + ); |
| 122 | + } |
| 123 | + } catch (error) { |
| 124 | + throw error; |
| 125 | + } |
| 126 | +}; |
| 127 | + |
| 128 | +const main = async () => { |
| 129 | + try { |
| 130 | + const connection = new Connection(SOLANA_RPC_ENDPOINT); // Setup Solana RPC connection |
| 131 | + const tokens: Token[] = await (await fetch(TOKEN_LIST_URL[ENV])).json(); // Fetch token list from Jupiter API |
| 132 | + |
| 133 | + // Load Jupiter |
| 134 | + const jupiter = await Jupiter.load({ |
| 135 | + connection, |
| 136 | + cluster: ENV, |
| 137 | + user: USER_KEYPAIR, // or public key |
| 138 | + }); |
| 139 | + |
| 140 | + // Get routeMap, which maps each tokenMint and their respective tokenMints that are swappable |
| 141 | + const routeMap = jupiter.getRouteMap(); |
| 142 | + |
| 143 | + // If you know which input/output pair you want |
| 144 | + const inputToken = tokens.find((t) => t.address == INPUT_MINT_ADDRESS); // USDC Mint Info |
| 145 | + const outputToken = tokens.find((t) => t.address == OUTPUT_MINT_ADDRESS); // USDT Mint Info |
| 146 | + |
| 147 | + // Alternatively, find all possible outputToken based on your inputToken |
| 148 | + const possiblePairsTokenInfo = await getPossiblePairsTokenInfo({ |
| 149 | + tokens, |
| 150 | + routeMap, |
| 151 | + inputToken, |
| 152 | + }); |
| 153 | + |
| 154 | + const routes = await getRoutes({ |
| 155 | + jupiter, |
| 156 | + inputToken, |
| 157 | + outputToken, |
| 158 | + inputAmount: .01, // 1 unit in UI |
| 159 | + slippage: 1, // 1% slippage |
| 160 | + }); |
| 161 | + |
| 162 | + // Routes are sorted based on outputAmount, so ideally the first route is the best. |
| 163 | + await executeSwap({ jupiter, route: routes!.routesInfos[0] }); |
| 164 | + } catch (error) { |
| 165 | + console.log({ error }); |
| 166 | + } |
| 167 | +}; |
| 168 | + |
| 169 | +main(); |
0 commit comments