@bitflowlabs/core-sdk 1.0.1 → 2.0.0

package/src/config.ts

@@ -1,13 +1,17 @@
-import { BitflowSDKConfig } from './types';
+import { BitflowSDKConfig } from "./types";
 
 export const configs: BitflowSDKConfig = {
   BITFLOW_API_HOST:
-    process.env.NEXT_PUBLIC_BITFLOW_API_HOST ?? process.env.BITFLOW_API_HOST,
+    (process.env.NEXT_PUBLIC_BITFLOW_API_HOST ??
+      process.env.BITFLOW_API_HOST) ||
+    "",
   BITFLOW_API_KEY:
-    process.env.NEXT_PUBLIC_BITFLOW_API_KEY ?? process.env.BITFLOW_API_KEY,
+    (process.env.NEXT_PUBLIC_BITFLOW_API_KEY ?? process.env.BITFLOW_API_KEY) ||
+    "",
   READONLY_CALL_API_HOST:
-    process.env.NEXT_PUBLIC_READONLY_CALL_API_HOST ??
-    process.env.READONLY_CALL_API_HOST,
+    (process.env.NEXT_PUBLIC_READONLY_CALL_API_HOST ??
+      process.env.READONLY_CALL_API_HOST) ||
+    "",
 };
 
 export function validateConfig() {
@@ -15,7 +19,6 @@ export function validateConfig() {
 
   for (const envVar of requiredEnvVars) {
     if (!configs[envVar]) {
-      console.error(`Missing required configuration: ${envVar}`);
       throw new Error(`Missing required configuration: ${envVar}`);
     }
   }

package/src/helpers/callReadOnlyHelper.ts

@@ -1,8 +1,7 @@
-import { callReadOnlyFunction } from "@stacks/transactions";
+import { fetchCallReadOnlyFunction } from "@stacks/transactions";
 import { SwapContext } from "../types";
 import { getTokenDecimals } from "./getTokenDecimalsHelper";
 import { constructFunctionArgs } from "./constructFunctionArgs";
-import { StacksMainnet } from "@stacks/network";
 import { configs } from "../config";
 import { getContractInterfaceAndFunction } from "./getContractInterfaceAndFunction";
 import { handleResult } from "./handleResultHelper";
@@ -29,7 +28,11 @@ export const callReadOnlyFunctionHelper = async (
   tokenXDecimals: number;
   tokenYDecimals: number;
 }> => {
-  const network = new StacksMainnet({ url: configs.READONLY_CALL_API_HOST });
+  const network = "mainnet";
+
+  const client = {
+    baseUrl: configs.READONLY_CALL_API_HOST,
+  };
 
   try {
     const contractKey = `${contractDeployer}.${contractName}`;
@@ -64,6 +67,7 @@ export const callReadOnlyFunctionHelper = async (
       | { tokenContract: string; tokenDecimals: number }
       | undefined;
 
+    // Attempt to find matching token decimals from parameters
     for (const key in parameters) {
       if (typeof parameters[key] === "object") {
         for (const subKey in parameters[key]) {
@@ -81,6 +85,7 @@ export const callReadOnlyFunctionHelper = async (
       if (tokenXMatchingDecimal) break;
     }
 
+    // If not found yet, also check swapData parameters
     if (!tokenXMatchingDecimal && swapData && swapData.parameters) {
       const swapParameters = swapData.parameters;
       for (const key in swapParameters) {
@@ -101,6 +106,7 @@ export const callReadOnlyFunctionHelper = async (
       }
     }
 
+    // Scale parameters if we find a matching decimal for tokenX
     if (tokenXMatchingDecimal) {
       const scaleAmount = (amount: number | string) => {
         const scaledAmount =
@@ -149,13 +155,14 @@ export const callReadOnlyFunctionHelper = async (
       functionArgsDefinition
     );
 
-    const result = await callReadOnlyFunction({
+    const result = await fetchCallReadOnlyFunction({
       contractAddress: contractDeployer,
       contractName,
       functionName,
       functionArgs,
-      senderAddress,
       network,
+      client,
+      senderAddress: senderAddress,
     });
 
     const { rawResult, convertedResult } = handleResult(result);
@@ -217,7 +224,6 @@ export const callReadOnlyFunctionHelper = async (
         console.warn(
           `No matching decimal found for tokenY: ${tokenYId} or result is not a number`
         );
-
         return {
           convertedResult,
           rawResult,
@@ -228,7 +234,6 @@ export const callReadOnlyFunctionHelper = async (
     } catch (error) {
       console.warn(`Couldn't apply decimal conversion: ${error}`);
       console.warn("Using raw result without decimal conversion");
-
       return {
         convertedResult,
         rawResult,

package/src/helpers/callSwapHelper.ts

@@ -1,7 +1,23 @@
 import { AnchorMode, PostConditionMode } from "@stacks/transactions";
-import { openContractCall, StacksProvider } from "@stacks/connect";
+import type { StacksProvider } from "@stacks/connect";
 import { SwapContext } from "../types";
 
+const loadStacksConnect = async () => {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "Stacks Connect functionality is only available in browser environments"
+    );
+  }
+
+  try {
+    const { openContractCall } = await import("@stacks/connect");
+    return { openContractCall };
+  } catch (error) {
+    console.error("Error loading Stacks Connect:", error);
+    throw new Error("Failed to load Stacks Connect dependencies");
+  }
+};
+
 export const executeSwapHelper = async (
   swapParams: {
     functionArgs: any[];
@@ -12,13 +28,15 @@ export const executeSwapHelper = async (
   },
   senderAddress: string,
   context: SwapContext,
-  stacksProvider?: StacksProvider,
+  stacksProvider: StacksProvider,
   onFinish?: (data: any) => void,
   onCancel?: () => void
 ): Promise<void> => {
   const network = context.network;
 
   try {
+    const { openContractCall } = await loadStacksConnect();
+
     const txOptions = {
       contractAddress: swapParams.contractAddress,
       contractName: swapParams.contractName,
@@ -41,11 +59,7 @@ export const executeSwapHelper = async (
         }),
     };
 
-    if (stacksProvider) {
-      await openContractCall(txOptions, stacksProvider);
-    } else {
-      await openContractCall(txOptions);
-    }
+    await openContractCall({ ...txOptions }, stacksProvider);
   } catch (error) {
     console.error("Error executing swap:", error);
     throw error;

package/src/helpers/fetchDataHelper.ts

@@ -1,5 +1,5 @@
-import { configs } from '../config';
-import { Token } from '../types';
+import { configs } from "../config";
+import { Token, LayerOneAsset, PriceData } from "../types";
 
 export const fetchAllTokensFromAPI = async (): Promise<Token[]> => {
   const url = `${configs.BITFLOW_API_HOST}/getAllTokensAndPools?key=${configs.BITFLOW_API_KEY}`;
@@ -10,30 +10,69 @@ export const fetchAllTokensFromAPI = async (): Promise<Token[]> => {
     }
     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');
+      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) => {
+    return data.tokens.map((token: any) => {
+      // Basic token properties
+      const mappedToken: Token = {
+        icon: token.icon || "",
+        name: token.name || "",
+        status: token.status || "",
+        symbol: token.symbol || "",
+        "token-id": token["token-id"] || "",
+        tokenId: token["token-id"] || "", // Duplicate for compatibility
+        tokenContract: token.tokenContract || null,
+        tokenDecimals: token.tokenDecimals || 0,
+        tokenName: token.tokenName || null,
+        wrapTokens: null,
+        base: token.base || "",
+        type: token.type || "",
+        isKeeperToken: token.isKeeperToken || false,
+        bridge: token.bridge || "FALSE",
+        layerOneAsset: token.layerOneAsset || null,
+        priceData: token.priceData || {
+          "1h_change": null,
+          "1yr_change": null,
+          "24h_change": null,
+          "30d_change": null,
+          "7d_change": null,
+          last_price: null,
+          last_updated: null,
+        },
+      };
+
+      // Handle wrapTokens if present
+      if (token.wrapTokens) {
+        mappedToken.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,
+              tokenName: token.wrapTokens[key].tokenName || null,
             };
             return acc;
-          }, {})
-        : null,
-    }));
+          },
+          {}
+        );
+      }
+
+      // Handle layerOneAsset if present
+      if (token.layerOneAsset && Object.keys(token.layerOneAsset).length > 0) {
+        mappedToken.layerOneAsset = {
+          address: token.layerOneAsset.address || "",
+          divisibility: token.layerOneAsset.divisibility || 0,
+          icon: token.layerOneAsset.icon || "",
+          isBitcoin: token.layerOneAsset.isBitcoin || false,
+          runeid: token.layerOneAsset.runeid || "",
+          spacedRune: token.layerOneAsset.spacedRune || "",
+          symbol: token.layerOneAsset.symbol || null,
+        };
+      }
+
+      return mappedToken;
+    });
   } catch (error) {
     console.error(`Error fetching data from ${url}:`, error);
     throw error;

package/src/helpers/fetchPossibleSwap.ts

@@ -1,10 +1,24 @@
-import { configs } from '../config';
-import { SwapOptions } from '../types';
+import { configs } from "../config";
+import { SwapOptions } from "../types";
 
 export const fetchPossibleSwapsFromAPI = async (
-  tokenX: string
+  tokenX: string,
+  page?: "KEEPER"
 ): Promise<SwapOptions> => {
-  const url = `${configs.BITFLOW_API_HOST}/getAllRoutes?key=${configs.BITFLOW_API_KEY}&tokenX=${tokenX}&depth=4`;
+  const queryParams = new URLSearchParams({
+    key: configs.BITFLOW_API_KEY,
+    tokenX: tokenX,
+    depth: "4",
+  });
+
+  if (page) {
+    queryParams.append("page", page);
+  }
+
+  const url = `${
+    configs.BITFLOW_API_HOST
+  }/getAllRoutes?${queryParams.toString()}`;
+
   try {
     const response = await fetch(url);
     if (!response.ok) {

package/src/helpers/handleResultHelper.ts

@@ -1,3 +1,5 @@
+import { ClarityType } from "@stacks/transactions";
+
 export const handleResult = (
   result: any
 ): { rawResult: any; convertedResult: any } => {
@@ -10,53 +12,52 @@ export const handleResult = (
 
   // 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:
+    case "int":
       rawResult = BigInt(result.value);
       convertedResult = Number(rawResult);
       break;
-    case 1:
+    case "uint":
       rawResult = BigInt(result.value);
       convertedResult = Number(rawResult);
       break;
-    case 2:
+    case "buffer":
       rawResult = Buffer.from(result.value);
       convertedResult = rawResult.toString("hex");
       break;
-    case 3:
+    case "true":
       rawResult = true;
       convertedResult = true;
       break;
-    case 4:
+    case "false":
       rawResult = false;
       convertedResult = false;
       break;
-    case 5:
+    case "address":
       rawResult = result.value;
       convertedResult = result.value;
       break;
-    case 6:
+    case "contract":
       rawResult = `${result.value.address}.${result.value.contractName}`;
       convertedResult = rawResult;
       break;
-    case 7:
+    case "ok":
       return handleResult(result.value);
-    case 8:
+    case "err":
       return handleResult(result.value);
-    case 9:
+    case "none":
       rawResult = null;
       convertedResult = null;
       break;
-    case 10:
+    case "some":
       return handleResult(result.value);
-    case 11:
+    case "list":
       rawResult = result.value.map((item: any) => handleResult(item).rawResult);
       convertedResult = result.value.map(
         (item: any) => handleResult(item).convertedResult
       );
       break;
-    case 12: // tuple
+    case "tuple":
       if (typeof value !== "object" || value === null) {
         console.error("Tuple value is not an object:", value);
         return { rawResult: null, convertedResult: null };
@@ -69,11 +70,11 @@ export const handleResult = (
       const lastKey = sortedKeys[0];
 
       return handleResult(value[lastKey]);
-    case 13:
+    case "ascii":
       rawResult = result.value;
       convertedResult = result.value;
       break;
-    case 14:
+    case "utf8":
       rawResult = result.value;
       convertedResult = result.value;
       break;

package/src/helpers/newPostConditionsHelper.ts

@@ -0,0 +1,172 @@
+import { Pc, 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;
+};
+
+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: string;
+
+    if (isAutoAlexV3OrLqstx && (isFirst || isLast)) {
+      postConditionAmount = BigInt(0);
+      conditionCode = "willSendGte";
+    } else {
+      if (isFirst) {
+        postConditionAmount = functionArgs.dx;
+        conditionCode = "willSendEq";
+      } else if (isLast) {
+        postConditionAmount = functionArgs["min-dy"];
+        conditionCode = "willSendGte";
+      } else {
+        postConditionAmount = BigInt(0);
+        conditionCode = "willSendGte";
+      }
+    }
+
+    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(
+            conditionCode === "willSendEq"
+              ? Pc.principal(senderAddress)
+                  .willSendEq(postConditionAmount)
+                  .ustx()
+              : Pc.principal(senderAddress)
+                  .willSendGte(postConditionAmount)
+                  .ustx()
+          );
+        } else {
+          postConditions.push(
+            conditionCode === "willSendEq"
+              ? Pc.principal(senderAddress)
+                  .willSendEq(postConditionAmount)
+                  .ft(pcData.tokenContract, pcData.tokenName)
+              : Pc.principal(senderAddress)
+                  .willSendGte(postConditionAmount)
+                  .ft(pcData.tokenContract, pcData.tokenName)
+          );
+        }
+      } else {
+        if (isSTX) {
+          postConditions.push(
+            conditionCode === "willSendEq"
+              ? Pc.principal(pcData.senderAddress)
+                  .willSendEq(postConditionAmount)
+                  .ustx()
+              : Pc.principal(pcData.senderAddress)
+                  .willSendGte(postConditionAmount)
+                  .ustx()
+          );
+        } else {
+          postConditions.push(
+            conditionCode === "willSendEq"
+              ? Pc.principal(pcData.senderAddress)
+                  .willSendEq(postConditionAmount)
+                  .ft(pcData.tokenContract, pcData.tokenName)
+              : Pc.principal(pcData.senderAddress)
+                  .willSendGte(postConditionAmount)
+                  .ft(pcData.tokenContract, pcData.tokenName)
+          );
+        }
+      }
+
+      if (pcData.shareFeeContract !== null) {
+        if (isSTX) {
+          postConditions.push(
+            Pc.principal(pcData.shareFeeContract).willSendGte(0).ustx()
+          );
+        } else {
+          postConditions.push(
+            Pc.principal(pcData.shareFeeContract)
+              .willSendGte(0)
+              .ft(pcData.tokenContract, pcData.tokenName)
+          );
+        }
+      }
+
+      if (pcData.dikoStx !== null) {
+        if (isTxSender) {
+          postConditions.push(
+            Pc.principal(senderAddress)
+              .willSendGte(0)
+              .ft(pcData.dikoStx, "wstx")
+          );
+        } else {
+          postConditions.push(
+            Pc.principal(pcData.senderAddress)
+              .willSendGte(0)
+              .ft(pcData.dikoStx, "wstx")
+          );
+        }
+      }
+    } 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/helpers/postConditionsHelper.ts

@@ -1,12 +1,4 @@
-import {
-  FungibleConditionCode,
-  makeStandardFungiblePostCondition,
-  makeStandardSTXPostCondition,
-  makeContractFungiblePostCondition,
-  makeContractSTXPostCondition,
-  createAssetInfo,
-  PostCondition,
-} from "@stacks/transactions";
+import { FungibleConditionCode, Pc, PostCondition } from "@stacks/transactions";
 
 const isWSTXv2Token = (value: any): boolean =>
   typeof value === "string" &&
@@ -34,17 +26,77 @@ const createSafeAssetInfo = (
   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}`
-    );
+  return {
+    contract: `${contractAddress}.${contractName}` as `${string}.${string}`,
+    tokenName: `${assetName}`,
+  };
+};
+
+const makeStandardSTXPostCondition = (
+  senderAddress: string,
+  conditionCode:
+    | FungibleConditionCode.Equal
+    | FungibleConditionCode.GreaterEqual,
+  postConditionAmount: bigint
+) => {
+  let initialPostCondition = Pc.principal(senderAddress);
+  let postCondition;
+  if (conditionCode === FungibleConditionCode.Equal) {
+    postCondition = initialPostCondition.willSendEq(postConditionAmount);
+  } else {
+    postCondition = initialPostCondition.willSendGte(postConditionAmount);
+  }
+  return postCondition.ustx();
+};
+
+const makeStandardFungiblePostCondition = (
+  senderAddress: string,
+  conditionCode:
+    | FungibleConditionCode.Equal
+    | FungibleConditionCode.GreaterEqual,
+  postConditionAmount: bigint,
+  asset: { contract: `${string}.${string}`; tokenName: string }
+) => {
+  let initialPostCondition = Pc.principal(senderAddress);
+  let postCondition;
+  if (conditionCode === FungibleConditionCode.Equal) {
+    postCondition = initialPostCondition.willSendEq(postConditionAmount);
+  } else {
+    postCondition = initialPostCondition.willSendGte(postConditionAmount);
   }
+  return postCondition.ft(asset.contract, asset.tokenName);
+};
+
+const makeContractSTXPostCondition = (
+  contractAddress: string,
+  contractName: string,
+  conditionCode:
+    | FungibleConditionCode.Equal
+    | FungibleConditionCode.GreaterEqual,
+  postConditionAmount: bigint
+) => {
+  return makeStandardSTXPostCondition(
+    `${contractAddress}.${contractName}`,
+    conditionCode,
+    postConditionAmount
+  );
+};
+
+const makeContractFungiblePostCondition = (
+  contractAddress: string,
+  contractName: string,
+  conditionCode:
+    | FungibleConditionCode.Equal
+    | FungibleConditionCode.GreaterEqual,
+  postConditionAmount: bigint,
+  asset: { contract: `${string}.${string}`; tokenName: string }
+) => {
+  return makeStandardFungiblePostCondition(
+    `${contractAddress}.${contractName}`,
+    conditionCode,
+    postConditionAmount,
+    asset
+  );
 };
 
 export const createSwapPostConditions = async (

package/src/index.ts

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