@xswap-link/sdk 0.0.13 → 0.1.0

package/src/services/api.ts

@@ -1,31 +1,33 @@
+import xSwapConfig from "../../xswap.config";
 import {
-  ApiOverrides,
   BridgeToken,
   Chain,
   Ecosystem,
+  GetPricesPayload,
   GetRoutePayload,
   Route,
   Token,
-} from "../models";
-import { DEFAULT_API_URL } from "../constants";
+  TokenPrices,
+  TransactionHistory,
+} from "@src/models";
 
 async function _sendRequest<T>(
   urlPath: string,
-  options: RequestInit,
-  overrides?: ApiOverrides
+  options?: RequestInit,
 ): Promise<T> {
-  const apiUrl = overrides?.apiUrl || DEFAULT_API_URL;
-  const response = await fetch(`${apiUrl}${urlPath}`, {
-    ...options,
+  const response = await fetch(`${xSwapConfig.apiUrl}${urlPath}`, {
+    method: "GET",
     headers: {
       "Content-Type": "application/json",
-      ...options.headers,
+      "Cache-Control": "no-cache",
+      ...options?.headers,
     },
+    ...options,
   });
 
   if (!response.ok) {
     throw new Error(
-      `API request failed with status ${response.status}: ${response.statusText}`
+      `API request failed with status ${response.status}: ${response.statusText}`,
     );
   }
 
@@ -35,61 +37,37 @@ async function _sendRequest<T>(
 /**
  * Get swap route based on provided criteria.
  * @param payload required
- * @param overrides optional - e.g. {apiUrl}
  */
-export async function getRoute(
-  payload: GetRoutePayload,
-  overrides?: ApiOverrides
-): Promise<Route> {
-  return _sendRequest<Route>(
-    "/route",
-    {
-      method: "POST",
-      body: JSON.stringify(payload),
-    },
-    overrides
-  );
+export async function getRoute(payload: GetRoutePayload): Promise<Route> {
+  return _sendRequest<Route>("/route", {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
 }
 
 /**
  * GET chains based on provided criteria.
  * @param ecosystem optional
- * @param overrides optional - e.g. {apiUrl}
  */
-export async function getChains(
-  ecosystem?: Ecosystem,
-  overrides?: ApiOverrides
-): Promise<Chain[]> {
-  const data = { ecosystem };
-
-  return _sendRequest<Chain[]>(
-    `/chains?data=${JSON.stringify(data)}`,
-    {
-      method: "GET",
-    },
-    overrides
-  );
+export async function getChains(ecosystem?: Ecosystem): Promise<Chain[]> {
+  return _sendRequest<Chain[]>(`/chains?data=${JSON.stringify({ ecosystem })}
+    `);
 }
 
 /**
  * GET chain data based on provided criteria.
  * @param chainId
  * @param ecosystem optional - Default: {@link DEFAULT_ECOSYSTEM}
- * @param overrides optional - e.g. {apiUrl}
  */
 export async function getChainData(
   chainId?: string,
   ecosystem?: Ecosystem,
-  overrides?: ApiOverrides
 ): Promise<Chain> {
-  const data = { chainId, ecosystem };
-
   return _sendRequest<Chain>(
-    `/chains?data=${JSON.stringify(data)}`,
-    {
-      method: "GET",
-    },
-    overrides
+    `/chains?data=${JSON.stringify({
+      chainId,
+      ecosystem,
+    })}`,
   );
 }
 
@@ -98,33 +76,37 @@ export async function getChainData(
  * @param chainId required
  * @param address optional
  * @param ecosystem optional but {@link DEFAULT_ECOSYSTEM} will be considered
- * @param overrides optional - e.g. {apiUrl}
  */
 export async function getTokens(
   chainId: string,
   address?: string,
   ecosystem?: Ecosystem,
-  overrides?: ApiOverrides
 ): Promise<Token[]> {
-  const data = { chainId, address, ecosystem };
-
   return _sendRequest<Token[]>(
-    `/tokens?data=${JSON.stringify(data)}`,
-    {
-      method: "GET",
-    },
-    overrides
+    `/tokens?data=${JSON.stringify({
+      chainId,
+      address,
+      ecosystem,
+    })}`,
   );
 }
 
-export async function getBridgeTokens(
-  overrides?: ApiOverrides
-): Promise<BridgeToken[]> {
-  return _sendRequest<BridgeToken[]>(
-    `/bridgeTokens`,
-    {
-      method: "GET",
-    },
-    overrides
+export async function getBridgeTokens(): Promise<BridgeToken[]> {
+  return _sendRequest<BridgeToken[]>(`/bridgeTokens`);
+}
+
+export async function getHistory(payload: { walletAddress: string }) {
+  return await _sendRequest<TransactionHistory>(
+    `/history?${new URLSearchParams({
+      data: JSON.stringify(payload),
+    })}`,
+  );
+}
+
+export async function getPrices(payload: GetPricesPayload) {
+  return await _sendRequest<TokenPrices>(
+    `/tokenPrices?${new URLSearchParams({
+      data: JSON.stringify(payload),
+    })}`,
   );
 }

package/src/services/index.ts

@@ -1 +1,2 @@
 export * from "./api";
+export * from "./integrations";

package/src/services/integrations/customCalls/index.ts

@@ -0,0 +1 @@
+export * from "./staking";

package/src/services/integrations/customCalls/staking.ts

@@ -0,0 +1,83 @@
+import { ethers } from "ethers";
+import {
+  ContractCall,
+  GenerateStakingCallsParams,
+  XSwapCallType,
+} from "@src/models";
+import {
+  findPlaceholderIndex,
+  generateUniqueRandomBigNumber,
+  IERC20,
+  replaceNull,
+} from "@src/utils";
+import { ERC20Abi } from "@src/contracts";
+
+export const generateStakingCalls = ({
+  token,
+  staking,
+  stakingAbi,
+  stakingFunName,
+  stakingFunParams,
+}: GenerateStakingCallsParams): ContractCall[] => {
+  const flatStakingFunParams = stakingFunParams.flat(Infinity);
+
+  if (flatStakingFunParams.filter((param) => param === null).length !== 1) {
+    throw new Error(
+      "Exactly 1 'null' value should be provided in 'funParams' in order to override token balance",
+    );
+  }
+
+  const randomBigNumber = generateUniqueRandomBigNumber(
+    32,
+    flatStakingFunParams,
+  );
+
+  const modifiedStakingFunParams = replaceNull(
+    stakingFunParams,
+    randomBigNumber,
+  );
+
+  const approveFunParams = [staking, randomBigNumber];
+  const stakingApproveCall: ContractCall = {
+    callType: XSwapCallType.FULL_TOKEN_BALANCE,
+    target: token,
+    callData: IERC20.encodeFunctionData("approve", approveFunParams),
+    payload: ethers.utils.defaultAbiCoder.encode(
+      ["address", "uint256"],
+      [
+        token,
+        findPlaceholderIndex(
+          JSON.stringify(ERC20Abi),
+          "approve",
+          approveFunParams,
+          randomBigNumber,
+        ),
+      ],
+    ),
+    value: "0",
+  };
+
+  const stakingCall: ContractCall = {
+    callType: XSwapCallType.FULL_TOKEN_BALANCE,
+    target: staking,
+    callData: new ethers.utils.Interface(stakingAbi).encodeFunctionData(
+      stakingFunName,
+      modifiedStakingFunParams,
+    ),
+    payload: ethers.utils.defaultAbiCoder.encode(
+      ["address", "uint256"],
+      [
+        token,
+        findPlaceholderIndex(
+          stakingAbi,
+          stakingFunName,
+          modifiedStakingFunParams,
+          randomBigNumber,
+        ),
+      ],
+    ),
+    value: "0",
+  };
+
+  return [stakingApproveCall, stakingCall];
+};

package/src/services/integrations/index.ts

@@ -0,0 +1,2 @@
+export * from "./customCalls";
+export * from "./transactions";

package/src/services/integrations/transactions.ts

@@ -0,0 +1,30 @@
+import {
+  Chain,
+  GetSwapTxPayload,
+  Transactions,
+  Web3Environment,
+} from "@src/models";
+import { getChains } from "@src/services";
+import { openTxConfigForm } from "@src/components";
+
+export const getSwapTx = async ({
+  dstChain,
+  dstToken,
+  customContractCalls = [],
+  desc,
+}: GetSwapTxPayload): Promise<Transactions> => {
+  const supportedChains: Chain[] = (await getChains()).filter(
+    ({ web3Environment, swapSupported }) =>
+      web3Environment === Web3Environment.MAINNET && swapSupported,
+  );
+
+  const route = await openTxConfigForm({
+    dstChainId: dstChain,
+    dstTokenAddr: dstToken,
+    customContractCalls,
+    desc,
+    supportedChains,
+  });
+
+  return route.transactions;
+};

package/src/utils/contracts.ts

@@ -1,19 +1,161 @@
-import { BigNumberish, ethers } from "ethers";
-import { ERC20Abi } from "../contracts";
-import { safeBigNumberFrom } from "./bigNumbers";
+import { BigNumber, BigNumberish, ethers } from "ethers";
+import { TransactionRequest } from "@ethersproject/providers";
+import { safeBigNumberFrom } from "./numbers";
+import { ADDRESSES, BatchQueryAbi, ERC20Abi } from "@src/contracts";
+import { Chain, TokenBalances } from "@src/models";
+import { chunkArray } from "@src/utils";
+import { BALANCES_CHUNK_SIZE } from "@src/constants";
 
-const erc20Interface = new ethers.utils.Interface(ERC20Abi);
+export const IERC20 = new ethers.utils.Interface(ERC20Abi);
+
+export const getBalanceOf = async (
+  wallet: string,
+  token: string,
+  rpcUrl: string,
+): Promise<string> => {
+  const provider = ethers.getDefaultProvider(rpcUrl);
+
+  if (token === ethers.constants.AddressZero) {
+    return ethers.utils.formatEther(await provider.getBalance(wallet));
+  }
+
+  const contract = new ethers.Contract(token, ERC20Abi, provider);
+  return ethers.utils.formatUnits(
+    await contract.balanceOf(wallet),
+    await contract.decimals(),
+  );
+};
+
+export const getBalances = async (
+  chain: Chain,
+  wallet: string,
+): Promise<TokenBalances> => {
+  return {
+    ...(await getNativeBalance(chain, wallet)),
+    ...(await getErc20Balances(chain, wallet)),
+  };
+};
+
+const getNativeBalance = async (
+  chain: Chain,
+  wallet: string,
+): Promise<TokenBalances> => {
+  const native = chain.tokens.find(
+    ({ address }) => address === ethers.constants.AddressZero,
+  );
+
+  if (native) {
+    const provider = ethers.getDefaultProvider(chain.publicRpcUrls[0]);
+    const balance = await provider.getBalance(wallet);
+    return {
+      [native.address]: balance,
+    };
+  }
+  return {};
+};
+
+const getErc20Balances = async (
+  chain: Chain,
+  wallet: string,
+): Promise<TokenBalances> => {
+  const erc20Tokens = chain.tokens.filter(
+    ({ address }) => address !== ethers.constants.AddressZero,
+  );
+  const tokenChunks = chunkArray(erc20Tokens, BALANCES_CHUNK_SIZE);
+  const promises = tokenChunks.map(async (tokenChunk) => {
+    const tokenAddresses = tokenChunk.map((token) => token.address);
+    const calldatas = tokenChunk.map(() =>
+      IERC20.encodeFunctionData("balanceOf", [wallet]),
+    );
+
+    const contractAddress = ADDRESSES[chain.chainId]?.BatchQuery;
+    const rpcUrl = chain.publicRpcUrls[0];
+    if (contractAddress && rpcUrl) {
+      const contract = new ethers.Contract(
+        contractAddress,
+        BatchQueryAbi,
+        ethers.getDefaultProvider(rpcUrl),
+      );
+      return await contract["batchQuery"](tokenAddresses, calldatas);
+    }
+    return Promise.resolve();
+  });
+
+  const tokenBalances: BigNumber[] = (await Promise.all(promises))
+    .flat()
+    .map(
+      (encodedBalance) =>
+        ethers.utils.defaultAbiCoder.decode(["uint256"], encodedBalance)[0],
+    );
+
+  const balances: TokenBalances = {};
+
+  erc20Tokens.forEach((token, index) => {
+    balances[token.address] = tokenBalances[index];
+  });
+  return balances;
+};
 
 export const generateApproveTxData = (
   tokenAddress: string,
   spender: string,
-  amount: BigNumberish
+  amount: BigNumberish,
+): TransactionRequest | undefined => {
+  return tokenAddress !== ethers.constants.AddressZero
+    ? {
+        to: tokenAddress,
+        value: safeBigNumberFrom("0"),
+        data: IERC20.encodeFunctionData("approve", [spender, amount]),
+      }
+    : undefined;
+};
+
+/**
+ * Calculate param's value offset within the encoded function's bytecode.
+ * @param abi
+ * @param funName
+ * @param funParams
+ * @param placeholderValue
+ */
+export const findPlaceholderIndex = (
+  abi: string,
+  funName: string,
+  // eslint-disable-next-line
+  funParams: any[],
+  placeholderValue: BigNumber,
 ) => {
-  const data = erc20Interface.encodeFunctionData("approve", [spender, amount]);
+  if (
+    funParams.flat(Infinity).filter((param) => param === placeholderValue)
+      .length !== 1
+  ) {
+    throw new Error("Random placeholder value must be provided and unique.");
+  }
 
-  return {
-    to: tokenAddress,
-    value: safeBigNumberFrom("0"),
-    data,
-  };
+  const iface = new ethers.utils.Interface(abi);
+  const functionFragment = iface.getFunction(funName);
+
+  if (!functionFragment) {
+    throw new Error(`Can't find function "${funName}" in provided ABI.`);
+  }
+
+  const encodedFunData = iface.encodeFunctionData(functionFragment, funParams);
+
+  // Remove the 4-byte selector
+  const paramData = encodedFunData.slice(10);
+
+  // Split into 32-byte (64 hex characters) chunks
+  const chunks: string[] = [];
+  for (let i = 0; i < paramData.length; i += 64) {
+    chunks.push(paramData.slice(i, i + 64));
+  }
+
+  // Find the index of the chunk containing the random value
+  const searchValue = placeholderValue.toHexString().slice(2).padStart(64, "0");
+  const result = chunks.findIndex((chunk) => chunk === searchValue);
+
+  if (result === -1) {
+    throw new Error("Randomized parameter not found in the encoded data.");
+  }
+
+  return result;
 };

package/src/utils/index.ts

@@ -1,2 +1,50 @@
-export * from "./bigNumbers";
 export * from "./contracts";
+export * from "./numbers";
+export * from "./strings";
+
+// eslint-disable-next-line
+export const replaceNull = (values: any[], newValue: any) => {
+  const modifiedValues = [...values];
+  for (let i = 0; i < modifiedValues.length; i++) {
+    if (Array.isArray(modifiedValues[i])) {
+      modifiedValues[i] = replaceNull(modifiedValues[i], newValue);
+    } else {
+      if (modifiedValues[i] === null) {
+        modifiedValues[i] = newValue;
+      }
+    }
+  }
+  return modifiedValues;
+};
+
+export const deepMergeObjects = (
+  // eslint-disable-next-line
+  obj1: Record<string, any>,
+  // eslint-disable-next-line
+  obj2: Record<string, any>,
+) => {
+  for (const key in obj2) {
+    if (obj2.hasOwnProperty(key)) {
+      if (
+        obj1.hasOwnProperty(key) &&
+        typeof obj1[key] === "object" &&
+        typeof obj2[key] === "object"
+      ) {
+        deepMergeObjects(obj1[key], obj2[key]);
+      } else {
+        obj1[key] = obj2[key];
+      }
+    }
+  }
+  return { ...obj1 };
+};
+
+// eslint-disable-next-line
+export const chunkArray = (array: any[], chunkSize: number): any[][] => {
+  // eslint-disable-next-line
+  const result: any[][] = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+};

package/src/utils/numbers.ts

@@ -0,0 +1,47 @@
+import { BigNumber as BigNumberJS } from "bignumber.js";
+import { BigNumber, utils } from "ethers";
+
+export const safeBigNumberFrom = (value: string) => {
+  BigNumberJS.config({ DECIMAL_PLACES: 0 });
+  return BigNumber.from(new BigNumberJS(value).div(1).toFixed());
+};
+
+export const weiToHumanReadable = ({
+  amount,
+  decimals,
+  precisionFractionalPlaces,
+  prettifySmallNumber = false,
+}: {
+  amount: string;
+  decimals: number;
+  precisionFractionalPlaces: number;
+  prettifySmallNumber?: boolean;
+}): string => {
+  const decimalsFactor = Math.pow(10, decimals);
+
+  BigNumberJS.config({ DECIMAL_PLACES: precisionFractionalPlaces });
+
+  const res = new BigNumberJS(amount).div(decimalsFactor).toFixed();
+  if (prettifySmallNumber && res === "0" && amount !== "0") {
+    return `<${(1 / 10 ** precisionFractionalPlaces).toFixed(
+      precisionFractionalPlaces,
+    )}`;
+  }
+  return res;
+};
+
+export const generateRandomBigNumber = (length: number) => {
+  return BigNumber.from(utils.randomBytes(length));
+};
+
+export const generateUniqueRandomBigNumber = (
+  length: number,
+  // eslint-disable-next-line
+  existingValues: any[],
+) => {
+  let result;
+  while (result === undefined || existingValues.includes(result)) {
+    result = generateRandomBigNumber(length);
+  }
+  return result;
+};

package/src/utils/strings.ts

@@ -0,0 +1,6 @@
+export const shortAddress = (address: string): string => {
+  return `${address?.substring(0, 5)}...${address?.substring(
+    address.length - 5,
+    address.length,
+  )}`;
+};

package/tailwind.config.js

@@ -0,0 +1,14 @@
+/** @type {import("tailwindcss").Config} */
+module.exports = {
+  content: ["./src/components/**/*.{js,ts,jsx,tsx,mdx}"],
+  theme: {
+    extend: {
+      colors: {
+        x_alert: "rgb(255, 183, 77)",
+        x_alert_light: "rgb(255, 226, 183)",
+        x_blue: "#3396FF",
+      },
+    },
+  },
+  plugins: [],
+};

package/test/api.test.ts

@@ -1,6 +1,6 @@
 import fetch from "jest-fetch-mock";
 import { chains } from "./api.mock";
-import { getChains } from "../src/services";
+import { getChains } from "@src/services";
 
 describe("API", () => {
   beforeEach(() => {

package/tsconfig.json

@@ -11,6 +11,15 @@
     "noUncheckedIndexedAccess": true,
     "moduleResolution": "Bundler",
     "module": "ESNext",
-    "noEmit": true
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "paths": {
+      "@src/*": [
+        "./src/*"
+      ],
+      "@src/global.css": [
+        "./src/components/global.css"
+      ]
+    }
   }
 }

package/xswap.config.ts

@@ -0,0 +1,18 @@
+import { XSwapConfig } from "@src/models";
+
+const xSwapConfig: XSwapConfig = {
+  apiUrl: "https://xswap.link/api",
+};
+
+let xSwapConfigLocal = {};
+try {
+  // eslint-disable-next-line
+  xSwapConfigLocal = require("./xswap.config.local").default;
+} catch {
+  // There's no local config, nothing to override.
+}
+
+export default {
+  ...xSwapConfig,
+  ...xSwapConfigLocal,
+};

package/index.ts

@@ -1,5 +0,0 @@
-export * from "./src/constants";
-export * from "./src/contracts";
-export * from "./src/models";
-export * from "./src/services";
-export * from "./src/utils";

package/src/models/ApiOverrides.ts

@@ -1,3 +0,0 @@
-export type ApiOverrides = {
-  apiUrl?: string;
-};

package/src/models/Chain.ts

@@ -1,20 +0,0 @@
-import { Web3Environment } from "./Web3Environment";
-import { Token } from "./Token";
-
-export type Chain = {
-  ecosystem: string;
-  chainId: string;
-  name: string;
-  displayName: string;
-  image: string;
-  web3Environment: Web3Environment;
-  tokenSymbol: string;
-  ccipChainId: string;
-  transactionExplorer: string;
-  bridgeSupported: boolean;
-  swapSupported: boolean;
-  tokens: Token[];
-  publicRpcUrls: string[];
-  privateRpcUrls?: string[];
-  scanApiURL?: string;
-};

package/src/models/Prices.ts

@@ -1,9 +0,0 @@
-export type Prices = {
-  blockchainId: string;
-  updatedAt: Date;
-  prices: TokenPrice;
-};
-
-export type TokenPrice = {
-  [tokenAddress: string]: string;
-};