@bitflowlabs/core-sdk 1.0.0

package/src/helpers/fetchDataHelper.ts

@@ -0,0 +1,41 @@
+import { configs } from '../config';
+import { Token } from '../types';
+
+export const fetchAllTokensFromAPI = async (): Promise<Token[]> => {
+  const url = `${configs.BITFLOW_API_HOST}/getAllTokensAndPools?key=${configs.BITFLOW_API_KEY}`;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data.tokens || !Array.isArray(data.tokens)) {
+      console.error('Unexpected data structure returned by API:', data);
+      throw new Error('Unexpected data structure returned by API');
+    }
+
+    return data.tokens.map((token: any) => ({
+      icon: token.icon,
+      name: token.name,
+      status: token.status,
+      symbol: token.symbol,
+      tokenId: token['token-id'],
+      tokenContract: token.tokenContract,
+      tokenDecimals: token.tokenDecimals,
+      tokenName: token.tokenName,
+      wrapTokens: token.wrapTokens
+        ? Object.keys(token.wrapTokens).reduce((acc: any, key: string) => {
+            acc[key] = {
+              tokenContract: token.wrapTokens[key].tokenContract,
+              tokenDecimals: token.wrapTokens[key].tokenDecimals,
+              tokenName: token.wrapTokens[key].tokenName,
+            };
+            return acc;
+          }, {})
+        : null,
+    }));
+  } catch (error) {
+    console.error(`Error fetching data from ${url}:`, error);
+    throw error;
+  }
+};

package/src/helpers/fetchPossibleSwap.ts

@@ -0,0 +1,18 @@
+import { configs } from '../config';
+import { SwapOptions } from '../types';
+
+export const fetchPossibleSwapsFromAPI = async (
+  tokenX: string
+): Promise<SwapOptions> => {
+  const url = `${configs.BITFLOW_API_HOST}/getAllRoutes?key=${configs.BITFLOW_API_KEY}&tokenX=${tokenX}&depth=4`;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    return await response.json();
+  } catch (error) {
+    console.error(`Error fetching possible swaps from ${url}:`, error);
+    throw error;
+  }
+};

package/src/helpers/getContractInterfaceAndFunction.ts

@@ -0,0 +1,20 @@
+import { fetchContractInterface } from "./fetchContractInterfaceHelper";
+import { getFunctionArguments } from "./getFunctionArgs";
+
+export const getContractInterfaceAndFunction = async (
+  contractDeployer: string,
+  contractName: string,
+  functionName: string
+) => {
+  const contractInterface = await fetchContractInterface(
+    contractDeployer,
+    contractName
+  );
+
+  const functionArgs = getFunctionArguments(contractInterface, functionName);
+
+  return {
+    contractInterface,
+    functionArgs,
+  };
+};

package/src/helpers/getFunctionArgs.ts

@@ -0,0 +1,12 @@
+export const getFunctionArguments = (
+  contractInterface: any,
+  functionName: string
+) => {
+  const func = contractInterface.functions.find(
+    (f: any) => f.name === functionName
+  );
+  if (!func) {
+    throw new Error(`Function ${functionName} not found in contract interface`);
+  }
+  return func.args;
+};

package/src/helpers/getTokenDecimalsHelper.ts

@@ -0,0 +1,33 @@
+import { SwapContext, Token } from "../types";
+
+export const getTokenDecimals = (
+  tokenId: string,
+  context: SwapContext
+): { tokenContract: string; tokenDecimals: number }[] => {
+  const decimals: { tokenContract: string; tokenDecimals: number }[] = [];
+
+  const token = context.availableTokens.find((t) => t.tokenId === tokenId);
+
+  if (!token) {
+    throw new Error(`Token with id ${tokenId} not found`);
+  }
+
+  if (token.tokenContract) {
+    decimals.push({
+      tokenContract: token.tokenContract,
+      tokenDecimals: token.tokenDecimals,
+    });
+  }
+
+  if (token.wrapTokens) {
+    for (const wrapTokenKey in token.wrapTokens) {
+      const wrapToken = token.wrapTokens[wrapTokenKey];
+      decimals.push({
+        tokenContract: wrapToken.tokenContract,
+        tokenDecimals: wrapToken.tokenDecimals,
+      });
+    }
+  }
+
+  return decimals;
+};

package/src/helpers/getTokenNameHelper.ts

@@ -0,0 +1,26 @@
+import { SwapContext } from "../types";
+
+export const getTokenName = (
+  tokenContract: string,
+  context: SwapContext
+): string => {
+  for (const token of context.availableTokens) {
+    if (
+      token.tokenContract &&
+      token.tokenContract.toLowerCase() === tokenContract.toLowerCase()
+    ) {
+      return token.tokenName || token.name;
+    }
+    if (token.wrapTokens) {
+      for (const wrapTokenKey in token.wrapTokens) {
+        const wrapToken = token.wrapTokens[wrapTokenKey];
+        if (
+          wrapToken.tokenContract.toLowerCase() === tokenContract.toLowerCase()
+        ) {
+          return wrapToken.tokenName || token.name;
+        }
+      }
+    }
+  }
+  throw new Error(`Token contract ${tokenContract} not found`);
+};

package/src/helpers/handleResultHelper.ts

@@ -0,0 +1,85 @@
+export const handleResult = (
+  result: any
+): { rawResult: any; convertedResult: any } => {
+  if (result === null || result === undefined) {
+    return { rawResult: null, convertedResult: null };
+  }
+
+  let rawResult: any;
+  let convertedResult: any;
+
+  // Check if the result has a 'data' property and use it if present
+  const value = result.data !== undefined ? result.data : result.value;
+
+  switch (result.type) {
+    case 0:
+      rawResult = BigInt(result.value);
+      convertedResult = Number(rawResult);
+      break;
+    case 1:
+      rawResult = BigInt(result.value);
+      convertedResult = Number(rawResult);
+      break;
+    case 2:
+      rawResult = Buffer.from(result.value);
+      convertedResult = rawResult.toString("hex");
+      break;
+    case 3:
+      rawResult = true;
+      convertedResult = true;
+      break;
+    case 4:
+      rawResult = false;
+      convertedResult = false;
+      break;
+    case 5:
+      rawResult = result.value;
+      convertedResult = result.value;
+      break;
+    case 6:
+      rawResult = `${result.value.address}.${result.value.contractName}`;
+      convertedResult = rawResult;
+      break;
+    case 7:
+      return handleResult(result.value);
+    case 8:
+      return handleResult(result.value);
+    case 9:
+      rawResult = null;
+      convertedResult = null;
+      break;
+    case 10:
+      return handleResult(result.value);
+    case 11:
+      rawResult = result.value.map((item: any) => handleResult(item).rawResult);
+      convertedResult = result.value.map(
+        (item: any) => handleResult(item).convertedResult
+      );
+      break;
+    case 12: // tuple
+      if (typeof value !== "object" || value === null) {
+        console.error("Tuple value is not an object:", value);
+        return { rawResult: null, convertedResult: null };
+      }
+      const sortedKeys = Object.keys(value).sort((a, b) => b.localeCompare(a));
+
+      if (sortedKeys.length === 0) {
+        return { rawResult: null, convertedResult: null };
+      }
+      const lastKey = sortedKeys[0];
+
+      return handleResult(value[lastKey]);
+    case 13:
+      rawResult = result.value;
+      convertedResult = result.value;
+      break;
+    case 14:
+      rawResult = result.value;
+      convertedResult = result.value;
+      break;
+    default:
+      throw new Error(`Unexpected result type: ${result.type}`);
+  }
+
+  return { rawResult, convertedResult };
+};

package/src/helpers/postConditionsHelper.ts

@@ -0,0 +1,246 @@
+import {
+  FungibleConditionCode,
+  makeStandardFungiblePostCondition,
+  makeStandardSTXPostCondition,
+  makeContractFungiblePostCondition,
+  makeContractSTXPostCondition,
+  createAssetInfo,
+  PostCondition,
+} from "@stacks/transactions";
+
+const isWSTXv2Token = (value: any): boolean =>
+  typeof value === "string" &&
+  value.includes("SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.token-wstx-v2");
+
+const checkForWSTXv2 = (obj: any): boolean => {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+
+  for (const key in obj) {
+    if (isWSTXv2Token(obj[key])) {
+      return true;
+    }
+    if (typeof obj[key] === "object" && checkForWSTXv2(obj[key])) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+const createSafeAssetInfo = (
+  contractAddress: string,
+  contractName: string,
+  assetName: string
+) => {
+  try {
+    return createAssetInfo(contractAddress, contractName, assetName);
+  } catch (error) {
+    console.error(
+      `Failed to create asset info for ${contractAddress}.${contractName}::${assetName}`,
+      error
+    );
+    throw new Error(
+      `Invalid asset info: ${contractAddress}.${contractName}::${assetName}`
+    );
+  }
+};
+
+export const createSwapPostConditions = async (
+  functionArgs: any,
+  postConditionsData: any,
+  senderAddress: string,
+  tokenXDecimals: number,
+  tokenYDecimals: number
+): Promise<PostCondition[]> => {
+  const postConditions: PostCondition[] = [];
+  const postConditionKeys = Object.keys(postConditionsData);
+
+  const isWSTXv2Involved = checkForWSTXv2(functionArgs);
+
+  for (let i = 0; i < postConditionKeys.length; i++) {
+    const key = postConditionKeys[i];
+    const pcData = postConditionsData[key];
+    const isFirst = i === 0;
+    const isLast = i === postConditionKeys.length - 1;
+    const isTxSender = pcData.senderAddress === "tx-sender";
+    const isSTX =
+      pcData.tokenContract === "token-stx" || pcData.tokenName === "token-stx";
+    const isAutoAlexV3OrLqstx =
+      pcData.tokenName === "auto-alex-v3" || pcData.tokenName === "lqstx";
+
+    let postConditionAmount: bigint;
+    let conditionCode: FungibleConditionCode;
+
+    if (isAutoAlexV3OrLqstx && (isFirst || isLast)) {
+      postConditionAmount = BigInt(0);
+      conditionCode = FungibleConditionCode.GreaterEqual;
+    } else {
+      if (isFirst) {
+        postConditionAmount = functionArgs.dx;
+        conditionCode = FungibleConditionCode.Equal;
+      } else if (isLast) {
+        postConditionAmount = functionArgs["min-dy"];
+        conditionCode = FungibleConditionCode.GreaterEqual;
+      } else {
+        postConditionAmount = BigInt(0);
+        conditionCode = FungibleConditionCode.GreaterEqual;
+      }
+    }
+
+    if (isSTX && isWSTXv2Involved) {
+      postConditionAmount = postConditionAmount / BigInt(100);
+    } else if (!isSTX && (isFirst || isLast)) {
+      let decimalDifference: number;
+      if (isFirst) {
+        decimalDifference = tokenXDecimals - pcData.tokenDecimals;
+      } else {
+        decimalDifference = tokenYDecimals - pcData.tokenDecimals;
+      }
+
+      if (decimalDifference > 0) {
+        postConditionAmount =
+          postConditionAmount / BigInt(10 ** decimalDifference);
+      } else if (decimalDifference < 0) {
+        postConditionAmount =
+          postConditionAmount * BigInt(10 ** Math.abs(decimalDifference));
+      }
+    }
+
+    try {
+      if (isTxSender) {
+        if (isSTX) {
+          postConditions.push(
+            makeStandardSTXPostCondition(
+              senderAddress,
+              conditionCode,
+              postConditionAmount
+            )
+          );
+        } else {
+          const [contractAddress, contractName] =
+            pcData.tokenContract.split(".");
+          const assetInfo = createSafeAssetInfo(
+            contractAddress,
+            contractName,
+            pcData.tokenName
+          );
+          postConditions.push(
+            makeStandardFungiblePostCondition(
+              senderAddress,
+              conditionCode,
+              postConditionAmount,
+              assetInfo
+            )
+          );
+        }
+      } else {
+        const [contractAddress, contractName] = pcData.senderAddress.split(".");
+        if (isSTX) {
+          postConditions.push(
+            makeContractSTXPostCondition(
+              contractAddress,
+              contractName,
+              conditionCode,
+              postConditionAmount
+            )
+          );
+        } else {
+          const [tokenContractAddress, tokenContractName] =
+            pcData.tokenContract.split(".");
+          const assetInfo = createSafeAssetInfo(
+            tokenContractAddress,
+            tokenContractName,
+            pcData.tokenName
+          );
+          postConditions.push(
+            makeContractFungiblePostCondition(
+              contractAddress,
+              contractName,
+              conditionCode,
+              postConditionAmount,
+              assetInfo
+            )
+          );
+        }
+      }
+
+      if (pcData.shareFeeContract !== null) {
+        const [shareFeeContractAddress, shareFeeContractName] =
+          pcData.shareFeeContract.split(".");
+
+        if (isSTX) {
+          postConditions.push(
+            makeContractSTXPostCondition(
+              shareFeeContractAddress,
+              shareFeeContractName,
+              FungibleConditionCode.GreaterEqual,
+              BigInt(0)
+            )
+          );
+        } else {
+          const [tokenContractAddress, tokenContractName] =
+            pcData.tokenContract.split(".");
+          const assetInfo = createSafeAssetInfo(
+            tokenContractAddress,
+            tokenContractName,
+            pcData.tokenName
+          );
+
+          postConditions.push(
+            makeContractFungiblePostCondition(
+              shareFeeContractAddress,
+              shareFeeContractName,
+              FungibleConditionCode.GreaterEqual,
+              BigInt(0),
+              assetInfo
+            )
+          );
+        }
+      }
+
+      if (pcData.dikoStx !== null) {
+        const [dikoContractAddress, dikoContractName] =
+          pcData.dikoStx.split(".");
+        const dikoAssetInfo = createSafeAssetInfo(
+          dikoContractAddress,
+          dikoContractName,
+          "wstx"
+        );
+
+        if (isTxSender) {
+          postConditions.push(
+            makeStandardFungiblePostCondition(
+              senderAddress,
+              FungibleConditionCode.GreaterEqual,
+              BigInt(0),
+              dikoAssetInfo
+            )
+          );
+        } else {
+          const [senderContractAddress, senderContractName] =
+            pcData.senderAddress.split(".");
+          postConditions.push(
+            makeContractFungiblePostCondition(
+              senderContractAddress,
+              senderContractName,
+              FungibleConditionCode.GreaterEqual,
+              BigInt(0),
+              dikoAssetInfo
+            )
+          );
+        }
+      }
+    } catch (error) {
+      console.error(`Error creating post condition for ${key}:`, error);
+      throw new Error(
+        `Failed to create post condition for ${key}: ${
+          (error as Error).message
+        }`
+      );
+    }
+  }
+
+  return postConditions;
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export { BitflowSDK } from './BitflowSDK';
+export * from './types';