@xswap-link/sdk 0.10.6 → 0.10.7

package/src/models/Ecosystem.ts

@@ -1,3 +1,4 @@
 export enum Ecosystem {
   EVM = "evm",
+  SOLANA = "solana",
 }

package/src/models/Route.ts

@@ -1,10 +1,21 @@
-export type Route = {
+interface BaseRoute {
   estAmountOut: string;
   minAmountOut: string;
-  transactions: Transactions;
   xSwapFees: XSwapFees;
   message?: string;
-};
+}
+
+export interface EVMRoute extends BaseRoute {
+  ecosystem: "evm";
+  transactions: Transactions;
+}
+
+export interface SolanaRoute extends BaseRoute {
+  ecosystem: "solana";
+  swapTransaction: string;
+}
+
+export type UnifiedRoute = EVMRoute | SolanaRoute;
 
 export type Transactions = {
   approve?: TransactionRequest;

package/src/models/SolanaTransaction.ts

@@ -0,0 +1,38 @@
+import { IdlEvents, IdlTypes } from "@coral-xyz/anchor";
+import { ParsedInstruction, PublicKey } from "@solana/web3.js";
+import { Jupiter } from "@src/contracts/idl/jupiter";
+
+export type SwapEvent = IdlEvents<Jupiter>["SwapEvent"];
+export type FeeEvent = IdlEvents<Jupiter>["FeeEvent"];
+type RoutePlanStep = IdlTypes<Jupiter>["RoutePlanStep"];
+export type RoutePlan = RoutePlanStep[];
+
+export interface PartialInstruction {
+  programId: PublicKey;
+  data: string /** Expecting base58 */;
+  accounts: PublicKey[];
+}
+
+// Subset of @solana/web3.js ParsedTransactionWithMeta to allow flexible upstream data
+export interface TransactionWithMeta {
+  blockTime: number;
+  meta: {
+    status: {
+      Ok: unknown;
+    };
+    logMessages?: string[] | null;
+    innerInstructions?:
+      | {
+          index: number;
+          instructions: (ParsedInstruction | PartialInstruction)[];
+        }[]
+      | null;
+  } | null;
+  transaction: {
+    signatures: string[];
+    message: {
+      accountKeys: { pubkey: PublicKey }[];
+      instructions: (ParsedInstruction | PartialInstruction)[];
+    };
+  };
+}

package/src/models/SolanaWeb3Network.ts

@@ -0,0 +1,5 @@
+export enum SolanaWeb3Network {
+  DEVNET = "devnet",
+  TESTNET = "testnet",
+  MAINNET = "mainnet-beta",
+}

package/src/models/TxUIWrapper.ts

@@ -1,14 +1,18 @@
-import { TransactionResponse } from "@ethersproject/providers";
-import { EvmHandlers } from "@src/context";
+import { TransactionResponse as EvmTransactionResponse } from "@ethersproject/providers";
+import { VersionedTransaction as SolanaVersionedTransaction } from "@solana/web3.js";
+import { EvmHandlers, SolanaHandlers } from "@src/context";
 import { Ecosystem } from "@src/models";
 import { Dispatch, SetStateAction } from "react";
 
 export type EnqueueTxProps = {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  executeTransaction: () => Promise<TransactionResponse> | undefined;
+  executeTransaction: () =>
+    | Promise<EvmTransactionResponse | undefined>
+    | Promise<SolanaVersionedTransaction | undefined>
+    | undefined;
   txStatus: TxStatus;
   txMsg?: string;
-  handlers?: EvmHandlers;
+  handlers?: EvmHandlers | SolanaHandlers;
   network?: Ecosystem;
   showDefaultSuccessMessage?: boolean;
 };

package/src/models/index.ts

@@ -11,6 +11,7 @@ export * from "./integrations";
 export * from "./payloads";
 export * from "./Protocol";
 export * from "./Route";
+export * from "./SolanaWeb3Network";
 export * from "./TokenData";
 export * from "./TransactionHistory";
 export * from "./TxUIWrapper";

package/src/models/payloads/GetBalancesPayload.ts

@@ -1,3 +1,4 @@
 export type GetTokenBalancesPayload = {
-  walletAddress: string;
+  walletAddress?: string;
+  solanaWalletAddress?: string;
 };

package/src/models/payloads/GetSolanaRoutePayload.ts

@@ -0,0 +1,8 @@
+export type GetSolanaRoutePayload = {
+  integratorId: string;
+  fromToken: string;
+  toToken: string;
+  fromAmount: string;
+  fromAddress: string;
+  slippage: number;
+};

package/src/models/payloads/index.ts

@@ -2,5 +2,6 @@ export * from "./GetBalancesPayload";
 export * from "./GetLeaderboardChangePayload";
 export * from "./GetPricesPayload";
 export * from "./GetRoutePayload";
+export * from "./GetSolanaRoutePayload";
 export * from "./ModalIntegrationPayload";
 export * from "./WidgetIntegrationPayload";

package/src/services/api.ts

@@ -5,8 +5,10 @@ import {
   GetLeaderboardChangePayload,
   GetPricesPayload,
   GetRoutePayload,
+  GetSolanaRoutePayload,
   GetTokenBalancesPayload,
-  Route,
+  EVMRoute,
+  SolanaRoute,
   Token,
   TokenPrices,
   TransactionHistory,
@@ -50,8 +52,24 @@ async function _sendRequest<T>(
 export async function getRoute(
   payload: GetRoutePayload,
   abortSignal?: AbortSignal,
-): Promise<Route> {
-  return _sendRequest<Route>("/route", {
+): Promise<EVMRoute> {
+  return _sendRequest<EVMRoute>("/route", {
+    method: "POST",
+    body: JSON.stringify(payload),
+    signal: abortSignal,
+  });
+}
+
+/**
+ * Get solana swap route based on provided criteria.
+ * @param payload required
+ * @param abortSignal
+ */
+export async function getSolanaRoute(
+  payload: GetSolanaRoutePayload,
+  abortSignal?: AbortSignal,
+): Promise<SolanaRoute> {
+  return _sendRequest<SolanaRoute>("/solanaRoute", {
     method: "POST",
     body: JSON.stringify(payload),
     signal: abortSignal,

package/src/services/solana/jupiter/extract-swap-data.ts

@@ -0,0 +1,183 @@
+/**
+ * This file contains code adapted from the Jupiter Protocol's instruction parser
+ * Source: https://github.com/jup-ag/instruction-parser
+ * Modified for use in XSwap
+ */
+import { Event, Program, Provider } from "@coral-xyz/anchor";
+import { AccountInfo, Connection, PublicKey } from "@solana/web3.js";
+import { JUPITER_V6_PROGRAM_ID } from "@src/constants";
+import { IDL, Jupiter } from "@src/contracts/idl/jupiter";
+import { SwapEvent, TransactionWithMeta } from "@src/models/SolanaTransaction";
+import { getEvents } from "@src/services/solana/jupiter/get-events";
+import { InstructionParser } from "@src/services/solana/jupiter/instruction-parser";
+import { BigNumberUtil } from "@src/services/solana/jupiter/utils";
+import BigNumber from "bignumber.js";
+import { unpackMint } from "@solana/spl-token";
+import { Transaction } from "@src/models";
+
+export const program = new Program<Jupiter>(
+  IDL,
+  JUPITER_V6_PROGRAM_ID,
+  {} as Provider,
+);
+
+type AccountInfoMap = Map<string, AccountInfo<Buffer>>;
+
+export type SwapAttributes = Transaction;
+
+const reduceEventData = <T>(events: Event[], name: string) =>
+  events.reduce((acc, event) => {
+    if (event.name === name) {
+      acc.push(event.data as T);
+    }
+    return acc;
+  }, new Array<T>());
+
+export async function extractSolanaSwapData(
+  signature: string,
+  connection: Connection,
+  tx: TransactionWithMeta,
+): Promise<SwapAttributes | undefined> {
+  const programId = JUPITER_V6_PROGRAM_ID;
+  const accountInfosMap: AccountInfoMap = new Map();
+
+  const logMessages = tx.meta?.logMessages;
+  if (!logMessages) {
+    throw new Error("Missing log messages...");
+  }
+
+  const parser = new InstructionParser(programId);
+  const events = getEvents(program, tx);
+
+  const swapEvents = reduceEventData<SwapEvent>(events, "SwapEvent");
+
+  if (swapEvents.length === 0) {
+    // Not a swap event, for example: https://solscan.io/tx/5ZSozCHmAFmANaqyjRj614zxQY8HDXKyfAs2aAVjZaadS4DbDwVq8cTbxmM5m5VzDcfhysTSqZgKGV1j2A2Hqz1V
+    return;
+  }
+
+  const accountsToBeFetched = new Array<PublicKey>();
+  swapEvents.forEach((swapEvent) => {
+    accountsToBeFetched.push(swapEvent.inputMint);
+    accountsToBeFetched.push(swapEvent.outputMint);
+  });
+
+  const accountInfos = await connection.getMultipleAccountsInfo(
+    accountsToBeFetched,
+  );
+  accountsToBeFetched.forEach((account, index) => {
+    const accountInfo = accountInfos[index];
+    if (accountInfo) {
+      accountInfosMap.set(account.toBase58(), accountInfo);
+    }
+  });
+
+  const swapData = await parseSwapEvents(accountInfosMap, swapEvents);
+  const instructions = parser.getInstructions(tx);
+  const positions = parser.getInitialAndFinalSwapPositions(instructions);
+  if (!positions) {
+    throw new Error("Failed to get initial and final swap positions");
+  }
+
+  const [initialPositions, finalPositions] = positions as [number[], number[]];
+  const initialPosition = initialPositions[0] as number;
+  const finalPosition = finalPositions[0] as number;
+
+  const inMint = swapData[initialPosition]?.inMint as string;
+  const inSwapData = swapData.filter(
+    (swap, index) =>
+      initialPositions?.includes(index) && swap.inMint === inMint,
+  );
+
+  const inAmountInDecimal = inSwapData.reduce((acc, curr) => {
+    return acc.plus(curr.inAmountInDecimal || 0);
+  }, new BigNumber(0));
+
+  const outMint = swapData[finalPosition]?.outMint;
+  const outSwapData = swapData.filter(
+    (swap, index) =>
+      finalPositions?.includes(index) && swap.outMint === outMint,
+  );
+
+  const outAmountInDecimal = outSwapData.reduce((acc, curr) => {
+    return acc.plus(curr.outAmountInDecimal || 0);
+  }, new BigNumber(0));
+
+  const isSuccessful = tx.meta?.status?.Ok === null;
+
+  const swap = {} as SwapAttributes;
+
+  swap.hash = signature;
+  swap.timestamp = tx.blockTime ?? 0;
+
+  swap.amountWei = inAmountInDecimal.toString();
+  swap.tokenAddress = inMint;
+
+  swap.tokenOutAmount = outAmountInDecimal.toString();
+  swap.tokenOutAddress = outMint;
+
+  swap.sourceChainId = "mainnet-beta";
+  swap.targetChainId = "mainnet-beta";
+
+  swap.status = isSuccessful ? "DONE" : "REVERTED";
+
+  return swap;
+}
+
+async function parseSwapEvents(
+  accountInfosMap: AccountInfoMap,
+  swapEvents: SwapEvent[],
+) {
+  const swapData = await Promise.all(
+    swapEvents.map((swapEvent) => extractSwapData(accountInfosMap, swapEvent)),
+  );
+
+  return swapData;
+}
+
+async function extractSwapData(
+  accountInfosMap: AccountInfoMap,
+  swapEvent: SwapEvent,
+) {
+  const inMint = swapEvent.inputMint.toBase58();
+  const inAmount = swapEvent.inputAmount.toString();
+  const inTokenDecimals = extractMintDecimals(
+    accountInfosMap,
+    swapEvent.inputMint,
+  );
+  const inAmountInDecimal = BigNumberUtil.fromBN(
+    swapEvent.inputAmount,
+    inTokenDecimals,
+  );
+
+  const outMint = swapEvent.outputMint.toBase58();
+  const outAmount = swapEvent.outputAmount.toString();
+  const outTokenDecimals = extractMintDecimals(
+    accountInfosMap,
+    swapEvent.outputMint,
+  );
+  const outAmountInDecimal = BigNumberUtil.fromBN(
+    swapEvent.outputAmount,
+    outTokenDecimals,
+  );
+
+  return {
+    inMint,
+    inAmount,
+    inAmountInDecimal,
+    outMint,
+    outAmount,
+    outAmountInDecimal,
+  };
+}
+
+function extractMintDecimals(accountInfosMap: AccountInfoMap, mint: PublicKey) {
+  const mintData = accountInfosMap.get(mint.toBase58());
+
+  if (mintData) {
+    const mintInfo = unpackMint(mint, mintData, mintData.owner);
+    return mintInfo.decimals;
+  }
+
+  return;
+}

package/src/services/solana/jupiter/get-events.ts

@@ -0,0 +1,37 @@
+/**
+ * This file contains code adapted from the Jupiter Protocol's instruction parser
+ * Source: https://github.com/jup-ag/instruction-parser
+ * Modified for use in XSwap
+ */
+import { Event, Program, utils } from "@coral-xyz/anchor";
+import { JUPITER_V6_PROGRAM_ID } from "@src/constants";
+import { Jupiter } from "@src/contracts/idl/jupiter";
+import { TransactionWithMeta } from "@src/models/SolanaTransaction";
+
+export function getEvents(
+  program: Program<Jupiter>,
+  transactionResponse: TransactionWithMeta,
+) {
+  const events: Event[] = [];
+
+  if (transactionResponse && transactionResponse.meta) {
+    const { meta } = transactionResponse;
+
+    meta.innerInstructions?.map(async (ix) => {
+      ix.instructions.map(async (iix) => {
+        if (!iix.programId.equals(JUPITER_V6_PROGRAM_ID)) return;
+        if (!("data" in iix)) return; // Guard in case it is a parsed decoded instruction
+
+        const ixData = utils.bytes.bs58.decode(iix.data);
+        const eventData = utils.bytes.base64.encode(ixData.subarray(8));
+        const event = program.coder.events.decode(eventData);
+
+        if (!event) return;
+
+        events.push(event);
+      });
+    });
+  }
+
+  return events;
+}

package/src/services/solana/jupiter/instruction-parser.ts

@@ -0,0 +1,217 @@
+/**
+ * This file contains code adapted from the Jupiter Protocol's instruction parser
+ * Source: https://github.com/jup-ag/instruction-parser
+ * Modified for use in XSwap
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ParsedInstruction, PublicKey } from "@solana/web3.js";
+import { BorshCoder } from "@coral-xyz/anchor";
+import { IDL } from "@src/contracts/idl/jupiter";
+import {
+  PartialInstruction,
+  RoutePlan,
+  TransactionWithMeta,
+} from "@src/models/SolanaTransaction";
+
+export class InstructionParser {
+  private coder: BorshCoder;
+  private programId: PublicKey;
+
+  constructor(programId: PublicKey) {
+    this.programId = programId;
+    this.coder = new BorshCoder(IDL);
+  }
+
+  getInstructionNameAndTransferAuthorityAndLastAccount(
+    instructions: PartialInstruction[],
+  ) {
+    for (const instruction of instructions) {
+      if (!instruction.programId.equals(this.programId)) {
+        continue;
+      }
+
+      const ix = this.coder.instruction.decode(instruction.data, "base58");
+
+      if (ix && instruction && this.isRouting(ix.name)) {
+        const instructionName = ix.name;
+        const authorityIndex = this.getTransferAuthorityIndex(instructionName);
+        if (authorityIndex === undefined) {
+          continue;
+        }
+        const transferAuthority =
+          instruction.accounts[authorityIndex]?.toString() || "";
+        const lastAccount =
+          instruction.accounts[instruction.accounts.length - 1]?.toString() ||
+          "";
+
+        return [ix.name, transferAuthority, lastAccount];
+      }
+    }
+
+    return [];
+  }
+
+  getTransferAuthorityIndex(instructionName: string) {
+    switch (instructionName) {
+      case "route":
+      case "exactOutRoute":
+      case "routeWithTokenLedger":
+        return 1;
+      case "sharedAccountsRoute":
+      case "sharedAccountsRouteWithTokenLedger":
+      case "sharedAccountsExactOutRoute":
+        return 2;
+    }
+  }
+
+  getInstructions(tx: TransactionWithMeta): PartialInstruction[] {
+    const parsedInstructions: PartialInstruction[] = [];
+    for (const instruction of tx.transaction.message.instructions) {
+      if (instruction.programId.equals(this.programId)) {
+        parsedInstructions.push(instruction as never);
+      }
+    }
+
+    for (const instructions of tx.meta?.innerInstructions || []) {
+      for (const instruction of instructions.instructions) {
+        if (instruction.programId.equals(this.programId)) {
+          parsedInstructions.push(instruction as any);
+        }
+      }
+    }
+
+    return parsedInstructions;
+  }
+
+  // Extract the position of the initial and final swap from the swap array.
+  getInitialAndFinalSwapPositions(instructions: PartialInstruction[]) {
+    for (const instruction of instructions) {
+      if (!instruction.programId.equals(this.programId)) {
+        continue;
+      }
+
+      const ix = this.coder.instruction.decode(instruction.data, "base58");
+      // This will happen because now event is also an CPI instruction.
+      if (!ix) {
+        continue;
+      }
+
+      if (this.isRouting(ix.name)) {
+        const routePlan = (ix.data as any).routePlan as RoutePlan;
+        const inputIndex = 0;
+        const outputIndex = routePlan.length;
+
+        const initialPositions: number[] = [];
+        for (let j = 0; j < routePlan.length; j++) {
+          if (routePlan[j].inputIndex === inputIndex) {
+            initialPositions.push(j);
+          }
+        }
+
+        const finalPositions: number[] = [];
+        for (let j = 0; j < routePlan.length; j++) {
+          if (routePlan[j].outputIndex === outputIndex) {
+            finalPositions.push(j);
+          }
+        }
+
+        if (
+          finalPositions.length === 0 &&
+          this.isCircular((ix.data as any).routePlan)
+        ) {
+          for (let j = 0; j < (ix.data as any).routePlan.length; j++) {
+            if ((ix.data as any).routePlan[j].outputIndex === 0) {
+              finalPositions.push(j);
+            }
+          }
+        }
+
+        return [initialPositions, finalPositions];
+      }
+    }
+  }
+
+  getExactOutAmount(instructions: (ParsedInstruction | PartialInstruction)[]) {
+    for (const instruction of instructions) {
+      if (!instruction.programId.equals(this.programId)) {
+        continue;
+      }
+      if (!("data" in instruction)) continue; // Guard in case it is a parsed decoded instruction, should be impossible
+
+      const ix = this.coder.instruction.decode(instruction.data, "base58");
+
+      if (ix && this.isExactIn(ix.name)) {
+        return (ix.data as any).quotedOutAmount.toString();
+      }
+    }
+
+    return;
+  }
+
+  getExactInAmount(instructions: (ParsedInstruction | PartialInstruction)[]) {
+    for (const instruction of instructions) {
+      if (!instruction.programId.equals(this.programId)) {
+        continue;
+      }
+      if (!("data" in instruction)) continue; // Guard in case it is a parsed decoded instruction, should be impossible
+
+      const ix = this.coder.instruction.decode(instruction.data, "base58");
+
+      if (ix && this.isExactOut(ix.name)) {
+        return (ix.data as any).quotedInAmount.toString();
+      }
+    }
+
+    return;
+  }
+
+  isExactIn(name: string) {
+    return (
+      name === "route" ||
+      name === "routeWithTokenLedger" ||
+      name === "sharedAccountsRoute" ||
+      name === "sharedAccountsRouteWithTokenLedger"
+    );
+  }
+
+  isExactOut(name: string) {
+    return name === "sharedAccountsExactOutRoute" || name === "exactOutRoute";
+  }
+
+  isRouting(name: string) {
+    return (
+      name === "route" ||
+      name === "routeWithTokenLedger" ||
+      name === "sharedAccountsRoute" ||
+      name === "sharedAccountsRouteWithTokenLedger" ||
+      name === "sharedAccountsExactOutRoute" ||
+      name === "exactOutRoute"
+    );
+  }
+
+  isCircular(routePlan: RoutePlan) {
+    if (!routePlan || routePlan.length === 0) {
+      return false;
+    }
+
+    const indexMap = new Map(
+      routePlan.map((obj) => [obj.inputIndex, obj.outputIndex]),
+    );
+    const visited = new Set();
+    let currentIndex = routePlan[0].inputIndex;
+
+    while (!visited.has(currentIndex)) {
+      if (visited.has(currentIndex)) {
+        return currentIndex === routePlan[0].inputIndex;
+      }
+
+      visited.add(currentIndex);
+
+      if (!indexMap.has(currentIndex)) {
+        return false;
+      }
+
+      currentIndex = indexMap.get(currentIndex);
+    }
+  }
+}

package/src/services/solana/jupiter/utils.ts

@@ -0,0 +1,37 @@
+import BigNumber from "bignumber.js";
+import { BN } from "@coral-xyz/anchor";
+import { ParsedTransactionWithMeta } from "@solana/web3.js";
+
+export class BigNumberUtil {
+  public static fromBigInt(input: bigint, shift = 0): BigNumber {
+    return new BigNumber(input.toString()).div(new BigNumber(10).pow(shift));
+  }
+
+  public static fromBN(input: BN, shift = 0): BigNumber {
+    return new BigNumber(input.toString()).div(new BigNumber(10).pow(shift));
+  }
+}
+
+const JUPITER_PROGRAM_IDS = [
+  "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4",
+  "JUP4Fb2cqiRUcaTHdrPC8h2gNsA2ETXiPDD33WcGuJB",
+  "JUP2jxvXaqu7NQY1GmNF4m1vodw12LVXYxbFL2uJvfo",
+  "JUP3c2Uh3WA4Ng34tw6kPd2G4C5BB21Xo36Je1s32Ph",
+];
+
+export const isJupiterTransaction = (
+  tx: ParsedTransactionWithMeta,
+): boolean => {
+  if (!tx || !tx.transaction || !tx.transaction.message) return false;
+
+  for (const innerInstructionSet of tx.meta?.innerInstructions || []) {
+    for (const instruction of innerInstructionSet.instructions) {
+      const programId = instruction.programId?.toString();
+      if (programId && JUPITER_PROGRAM_IDS.includes(programId)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};

package/src/utils/strings.ts

@@ -1,3 +1,5 @@
+import { PublicKey } from "@solana/web3.js";
+
 export const shortAddress = (address: string): string => {
   return `${address?.substring(0, 5)}...${address?.substring(
     address.length - 5,
@@ -8,3 +10,17 @@ export const shortAddress = (address: string): string => {
 export const isETHAddressValid = (address: string): boolean => {
   return /^0x[a-fA-F0-9]{40}$/.test(address);
 };
+
+/**
+ * Checks if a Solana address is on the Ed25519 curve (has a private key)
+ * If true: standard wallet address
+ * If false: program-derived address (PDA)
+ */
+export const isSolanaAddressValid = (address: string): boolean => {
+  try {
+    const publicKey = new PublicKey(address);
+    return PublicKey.isOnCurve(publicKey);
+  } catch (error) {
+    return false;
+  }
+};