@bitflowlabs/core-sdk 2.2.0 → 2.3.1-beta.0

package/src/config.ts

@@ -1,37 +0,0 @@
-import { BitflowSDKConfig } from "./types";
-
-export const configs: BitflowSDKConfig = {
-  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) ||
-    "",
-  BITFLOW_PROVIDER_ADDRESS:
-      (process.env.NEXT_PUBLIC_BITFLOW_PROVIDER_ADDRESS ??
-        process.env.BITFLOW_PROVIDER_ADDRESS) ||
-      "",
-  READONLY_CALL_API_HOST:
-    (process.env.NEXT_PUBLIC_READONLY_CALL_API_HOST ??
-      process.env.READONLY_CALL_API_HOST) ||
-    "",
-  KEEPER_API_KEY:
-    (process.env.NEXT_PUBLIC_KEEPER_API_KEY ?? process.env.KEEPER_API_KEY) ||
-    "",
-  KEEPER_API_HOST:
-    (process.env.NEXT_PUBLIC_KEEPER_API_HOST ?? process.env.KEEPER_API_HOST) ||
-    "",
-};
-
-export function validateConfig() {
-  const optionalEnvVars: (keyof BitflowSDKConfig)[] = ['BITFLOW_PROVIDER_ADDRESS'];
-  const requiredEnvVars = (Object.keys(configs) as (keyof BitflowSDKConfig)[])
-    .filter((key) => !optionalEnvVars.includes(key));
-
-  for (const envVar of requiredEnvVars) {
-    if (!configs[envVar]) {
-      throw new Error(`Missing required configuration: ${envVar}`);
-    }
-  }
-}

package/src/helpers/callGetSwapParams.ts

@@ -1,122 +0,0 @@
-import { createSwapPostConditions } from "./postConditionsHelper";
-import {
-  SwapContext,
-  SwapDataParamsAndPostConditions,
-  SwapExecutionData,
-} from "../types";
-import { constructFunctionArgs } from "./constructFunctionArgs";
-import { getContractInterfaceAndFunction } from "./getContractInterfaceAndFunction";
-import { stringifyWithBigInt } from "./callReadOnlyHelper";
-
-const applySlippage = (
-  value: string | number | bigint,
-  slippageTolerance: number
-): bigint => {
-  const bigIntValue = BigInt(value);
-  const slippageFactor = BigInt(Math.floor((1 - slippageTolerance) * 10000));
-  return (bigIntValue * slippageFactor) / BigInt(10000);
-};
-
-export const executeGetParams = async (
-  swapExecutionData: SwapExecutionData,
-  senderAddress: string,
-  slippageTolerance: number,
-  context: SwapContext
-): Promise<SwapDataParamsAndPostConditions> => {
-  const network = context.network;
-  const { route, amount, tokenXDecimals, tokenYDecimals } = swapExecutionData;
-  const [contractAddress, contractName] = route.swapData.contract.split(".");
-
-  try {
-    const contractKey = `${contractAddress}.${contractName}`;
-    let contractInterface = context.contractInterfaces[contractKey];
-    let functionArgsDefinition =
-      context.functionArgs[contractKey]?.[route.swapData.function];
-
-    if (!contractInterface || !functionArgsDefinition) {
-      const result = await getContractInterfaceAndFunction(
-        contractAddress,
-        contractName,
-        route.swapData.function
-      );
-
-      if (!contractInterface) {
-        contractInterface = result.contractInterface;
-        context.contractInterfaces[contractKey] = contractInterface;
-      }
-
-      if (!functionArgsDefinition) {
-        functionArgsDefinition = result.functionArgs;
-        if (!context.functionArgs[contractKey]) {
-          context.functionArgs[contractKey] = {};
-        }
-        context.functionArgs[contractKey][route.swapData.function] =
-          functionArgsDefinition;
-      }
-    }
-
-    const swapParameters = { ...route.swapData.parameters };
-
-    // Apply slippage to various parameters
-    const slippageParams = [
-      "min-received",
-      "min-dy",
-      "min-dx",
-      "min-dz",
-      "min-dw",
-      "amt-out",
-      "amt-out-min",
-      "min-x-amount",
-      "min-dv",
-      "min-y-amount",
-    ];
-
-    slippageParams.forEach((param) => {
-      if (swapParameters[param]) {
-        swapParameters[param] = applySlippage(
-          swapParameters[param],
-          slippageTolerance
-        );
-      }
-    });
-
-    // Convert input amounts to BigInt
-    const inputParams = [
-      "amount",
-      "dx",
-      "amt-in",
-      "amt-in-max",
-      "y-amount",
-      "dy",
-    ];
-    inputParams.forEach((param) => {
-      if (param in swapParameters) {
-        swapParameters[param] = BigInt(swapParameters[param]);
-      }
-    });
-
-    const functionArgs = constructFunctionArgs(
-      swapParameters,
-      functionArgsDefinition
-    );
-
-    const postConditions = await createSwapPostConditions(
-      swapParameters,
-      route.postConditions,
-      senderAddress,
-      tokenXDecimals,
-      tokenYDecimals
-    );
-
-    return {
-      functionArgs,
-      postConditions,
-      contractAddress,
-      contractName,
-      functionName: route.swapData.function,
-    };
-  } catch (error) {
-    console.error("Error getting swap parameters:", error);
-    throw error;
-  }
-};

package/src/helpers/callReadOnlyHelper.ts

@@ -1,474 +0,0 @@
-import { fetchCallReadOnlyFunction } from '@stacks/transactions';
-import { SwapContext } from '../types';
-import { getTokenDecimals } from './getTokenDecimalsHelper';
-import { constructFunctionArgs } from './constructFunctionArgs';
-import { configs } from '../config';
-import { getContractInterfaceAndFunction } from './getContractInterfaceAndFunction';
-import { handleResult } from './handleResultHelper';
-
-export const stringifyWithBigInt = (obj: any): string => {
-  return JSON.stringify(obj, (_, v) =>
-    typeof v === 'bigint' ? v.toString() : v
-  );
-};
-
-export const callReadOnlyFunctionHelper = async (
-  contractDeployer: string,
-  contractName: string,
-  functionName: string,
-  parameters: any,
-  senderAddress: string,
-  tokenXId: string,
-  tokenYId: string,
-  swapData: any,
-  context: SwapContext
-): Promise<{
-  convertedResult: number;
-  rawResult: number;
-  tokenXDecimals: number;
-  tokenYDecimals: number;
-}> => {
-  const network = 'mainnet';
-
-  const client = {
-    baseUrl: configs.READONLY_CALL_API_HOST,
-  };
-
-  try {
-    const contractKey = `${contractDeployer}.${contractName}`;
-    let contractInterface = context.contractInterfaces[contractKey];
-    let functionArgsDefinition =
-      context.functionArgs[contractKey]?.[functionName];
-
-    if (!contractInterface || !functionArgsDefinition) {
-      const result = await getContractInterfaceAndFunction(
-        contractDeployer,
-        contractName,
-        functionName
-      );
-
-      if (!contractInterface) {
-        contractInterface = result.contractInterface;
-        context.contractInterfaces[contractKey] = contractInterface;
-      }
-
-      if (!functionArgsDefinition) {
-        functionArgsDefinition = result.functionArgs;
-        if (!context.functionArgs[contractKey]) {
-          context.functionArgs[contractKey] = {};
-        }
-        context.functionArgs[contractKey][functionName] =
-          functionArgsDefinition;
-      }
-    }
-
-    const tokenXDecimals = getTokenDecimals(tokenXId, context);
-    let tokenXMatchingDecimal:
-      | { 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]) {
-          const contractValue = parameters[key][subKey];
-          tokenXMatchingDecimal = tokenXDecimals.find(
-            (d) => d.tokenContract === contractValue
-          );
-          if (tokenXMatchingDecimal) break;
-        }
-      } else if (typeof parameters[key] === 'string') {
-        tokenXMatchingDecimal = tokenXDecimals.find(
-          (d) => d.tokenContract === parameters[key]
-        );
-      }
-      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) {
-        if (typeof swapParameters[key] === 'object') {
-          for (const subKey in swapParameters[key]) {
-            const contractValue = swapParameters[key][subKey];
-            tokenXMatchingDecimal = tokenXDecimals.find(
-              (d) => d.tokenContract === contractValue
-            );
-            if (tokenXMatchingDecimal) break;
-          }
-        } else if (typeof swapParameters[key] === 'string') {
-          tokenXMatchingDecimal = tokenXDecimals.find(
-            (d) => d.tokenContract === swapParameters[key]
-          );
-        }
-        if (tokenXMatchingDecimal) break;
-      }
-    }
-
-    // Scale parameters if we find a matching decimal for tokenX
-    if (tokenXMatchingDecimal) {
-      const scaleAmount = (amount: number | string) => {
-        const scaledAmount =
-          parseFloat(amount.toString()) *
-          10 ** tokenXMatchingDecimal!.tokenDecimals;
-        return BigInt(Math.floor(scaledAmount));
-      };
-
-      if (parameters.dx !== undefined && parameters.dx !== null) {
-        parameters.dx = scaleAmount(parameters.dx);
-      } else if (
-        parameters.amount !== undefined &&
-        parameters.amount !== null
-      ) {
-        parameters.amount = scaleAmount(parameters.amount);
-      } else if (
-        parameters['amt-in'] !== undefined &&
-        parameters['amt-in'] !== null
-      ) {
-        parameters['amt-in'] = scaleAmount(parameters['amt-in']);
-      } else if (
-        parameters['amt-in-max'] !== undefined &&
-        parameters['amt-in-max'] !== null
-      ) {
-        parameters['amt-in-max'] = scaleAmount(parameters['amt-in-max']);
-      } else if (
-        parameters['y-amount'] !== undefined &&
-        parameters['y-amount'] !== null
-      ) {
-        parameters['y-amount'] = scaleAmount(parameters['y-amount']);
-        parameters['x-amount'] = scaleAmount(parameters['x-amount']);
-      } else if (
-        parameters['x-amount'] !== undefined &&
-        parameters['x-amount'] !== null
-      ) {
-        parameters['x-amount'] = scaleAmount(parameters['x-amount']);
-      } else if (parameters.dy !== undefined && parameters.dy !== null) {
-        parameters.dy = scaleAmount(parameters.dy);
-      }
-    } else {
-      console.warn(`No matching decimal found for tokenX: ${tokenXId}`);
-    }
-
-    const functionArgs = constructFunctionArgs(
-      parameters,
-      functionArgsDefinition
-    );
-
-    const result = await fetchCallReadOnlyFunction({
-      contractAddress: contractDeployer,
-      contractName,
-      functionName,
-      functionArgs,
-      network,
-      client,
-      senderAddress: senderAddress,
-    });
-
-    const { rawResult, convertedResult } = handleResult(result);
-
-    try {
-      const tokenYDecimals = getTokenDecimals(tokenYId, context);
-
-      let tokenYMatchingDecimal:
-        | { tokenContract: string; tokenDecimals: number }
-        | undefined;
-
-      for (const key in parameters) {
-        if (typeof parameters[key] === 'object') {
-          for (const subKey in parameters[key]) {
-            const contractValue = parameters[key][subKey];
-            tokenYMatchingDecimal = tokenYDecimals.find(
-              (d) => d.tokenContract === contractValue
-            );
-            if (tokenYMatchingDecimal) break;
-          }
-        } else if (typeof parameters[key] === 'string') {
-          tokenYMatchingDecimal = tokenYDecimals.find(
-            (d) => d.tokenContract === parameters[key]
-          );
-        }
-        if (tokenYMatchingDecimal) break;
-      }
-
-      if (!tokenYMatchingDecimal && swapData && swapData.parameters) {
-        const swapParameters = swapData.parameters;
-        for (const key in swapParameters) {
-          if (typeof swapParameters[key] === 'object') {
-            for (const subKey in swapParameters[key]) {
-              const contractValue = swapParameters[key][subKey];
-              tokenYMatchingDecimal = tokenYDecimals.find(
-                (d) => d.tokenContract === contractValue
-              );
-              if (tokenYMatchingDecimal) break;
-            }
-          } else if (typeof swapParameters[key] === 'string') {
-            tokenYMatchingDecimal = tokenYDecimals.find(
-              (d) => d.tokenContract === swapParameters[key]
-            );
-          }
-          if (tokenYMatchingDecimal) break;
-        }
-      }
-
-      if (tokenYMatchingDecimal && typeof convertedResult === 'number') {
-        const adjustedResult =
-          convertedResult / 10 ** tokenYMatchingDecimal.tokenDecimals;
-        return {
-          convertedResult: adjustedResult,
-          rawResult,
-          tokenXDecimals: tokenXMatchingDecimal?.tokenDecimals || 0,
-          tokenYDecimals: tokenYMatchingDecimal.tokenDecimals,
-        };
-      } else {
-        console.warn(
-          `No matching decimal found for tokenY: ${tokenYId} or result is not a number`
-        );
-        return {
-          convertedResult,
-          rawResult,
-          tokenXDecimals: tokenXMatchingDecimal?.tokenDecimals || 0,
-          tokenYDecimals: 0,
-        };
-      }
-    } catch (error) {
-      console.warn(`Couldn't apply decimal conversion: ${error}`);
-      console.warn('Using raw result without decimal conversion');
-      return {
-        convertedResult,
-        rawResult,
-        tokenXDecimals: tokenXMatchingDecimal?.tokenDecimals || 0,
-        tokenYDecimals: 0,
-      };
-    }
-  } catch (error) {
-    console.error(`Error calling read-only function ${functionName}:`, error);
-    throw error;
-  }
-};
-
-export const callReadOnlyFunctionHelperWithoutScaling = async (
-  contractDeployer: string,
-  contractName: string,
-  functionName: string,
-  parameters: any,
-  senderAddress: string,
-  tokenXId: string,
-  tokenYId: string,
-  swapData: any,
-  context: SwapContext
-): Promise<{
-  convertedResult: number;
-  rawResult: number;
-  tokenXDecimals: number;
-  tokenYDecimals: number;
-}> => {
-  const network = 'mainnet';
-
-  const client = {
-    baseUrl: configs.READONLY_CALL_API_HOST,
-  };
-
-  try {
-    const contractKey = `${contractDeployer}.${contractName}`;
-    let contractInterface = context.contractInterfaces[contractKey];
-    let functionArgsDefinition =
-      context.functionArgs[contractKey]?.[functionName];
-
-    if (!contractInterface || !functionArgsDefinition) {
-      const result = await getContractInterfaceAndFunction(
-        contractDeployer,
-        contractName,
-        functionName
-      );
-
-      if (!contractInterface) {
-        contractInterface = result.contractInterface;
-        context.contractInterfaces[contractKey] = contractInterface;
-      }
-
-      if (!functionArgsDefinition) {
-        functionArgsDefinition = result.functionArgs;
-        if (!context.functionArgs[contractKey]) {
-          context.functionArgs[contractKey] = {};
-        }
-        context.functionArgs[contractKey][functionName] =
-          functionArgsDefinition;
-      }
-    }
-
-    const tokenXDecimals = getTokenDecimals(tokenXId, context);
-    let tokenXMatchingDecimal:
-      | { 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]) {
-          const contractValue = parameters[key][subKey];
-          tokenXMatchingDecimal = tokenXDecimals.find(
-            (d) => d.tokenContract === contractValue
-          );
-          if (tokenXMatchingDecimal) break;
-        }
-      } else if (typeof parameters[key] === 'string') {
-        tokenXMatchingDecimal = tokenXDecimals.find(
-          (d) => d.tokenContract === parameters[key]
-        );
-      }
-      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) {
-        if (typeof swapParameters[key] === 'object') {
-          for (const subKey in swapParameters[key]) {
-            const contractValue = swapParameters[key][subKey];
-            tokenXMatchingDecimal = tokenXDecimals.find(
-              (d) => d.tokenContract === contractValue
-            );
-            if (tokenXMatchingDecimal) break;
-          }
-        } else if (typeof swapParameters[key] === 'string') {
-          tokenXMatchingDecimal = tokenXDecimals.find(
-            (d) => d.tokenContract === swapParameters[key]
-          );
-        }
-        if (tokenXMatchingDecimal) break;
-      }
-    }
-
-    // Skip scaling and use raw input values
-    // Just convert any numerical values to BigInt to maintain type compatibility
-    if (parameters.dx !== undefined && parameters.dx !== null) {
-      parameters.dx = BigInt(Math.floor(parameters.dx));
-    } else if (parameters.amount !== undefined && parameters.amount !== null) {
-      parameters.amount = BigInt(Math.floor(parameters.amount));
-    } else if (
-      parameters['amt-in'] !== undefined &&
-      parameters['amt-in'] !== null
-    ) {
-      parameters['amt-in'] = BigInt(Math.floor(parameters['amt-in']));
-    } else if (
-      parameters['amt-in-max'] !== undefined &&
-      parameters['amt-in-max'] !== null
-    ) {
-      parameters['amt-in-max'] = BigInt(Math.floor(parameters['amt-in-max']));
-    } else if (
-      parameters['y-amount'] !== undefined &&
-      parameters['y-amount'] !== null
-    ) {
-      parameters['y-amount'] = BigInt(Math.floor(parameters['y-amount']));
-      if (
-        parameters['x-amount'] !== undefined &&
-        parameters['x-amount'] !== null
-      ) {
-        parameters['x-amount'] = BigInt(Math.floor(parameters['x-amount']));
-      }
-    } else if (
-      parameters['x-amount'] !== undefined &&
-      parameters['x-amount'] !== null
-    ) {
-      parameters['x-amount'] = BigInt(Math.floor(parameters['x-amount']));
-    } else if (parameters.dy !== undefined && parameters.dy !== null) {
-      parameters.dy = BigInt(Math.floor(parameters.dy));
-    }
-
-    const functionArgs = constructFunctionArgs(
-      parameters,
-      functionArgsDefinition
-    );
-
-    const result = await fetchCallReadOnlyFunction({
-      contractAddress: contractDeployer,
-      contractName,
-      functionName,
-      functionArgs,
-      network,
-      client,
-      senderAddress: senderAddress,
-    });
-
-    const { rawResult, convertedResult } = handleResult(result);
-
-    try {
-      const tokenYDecimals = getTokenDecimals(tokenYId, context);
-
-      let tokenYMatchingDecimal:
-        | { tokenContract: string; tokenDecimals: number }
-        | undefined;
-
-      for (const key in parameters) {
-        if (typeof parameters[key] === 'object') {
-          for (const subKey in parameters[key]) {
-            const contractValue = parameters[key][subKey];
-            tokenYMatchingDecimal = tokenYDecimals.find(
-              (d) => d.tokenContract === contractValue
-            );
-            if (tokenYMatchingDecimal) break;
-          }
-        } else if (typeof parameters[key] === 'string') {
-          tokenYMatchingDecimal = tokenYDecimals.find(
-            (d) => d.tokenContract === parameters[key]
-          );
-        }
-        if (tokenYMatchingDecimal) break;
-      }
-
-      if (!tokenYMatchingDecimal && swapData && swapData.parameters) {
-        const swapParameters = swapData.parameters;
-        for (const key in swapParameters) {
-          if (typeof swapParameters[key] === 'object') {
-            for (const subKey in swapParameters[key]) {
-              const contractValue = swapParameters[key][subKey];
-              tokenYMatchingDecimal = tokenYDecimals.find(
-                (d) => d.tokenContract === contractValue
-              );
-              if (tokenYMatchingDecimal) break;
-            }
-          } else if (typeof swapParameters[key] === 'string') {
-            tokenYMatchingDecimal = tokenYDecimals.find(
-              (d) => d.tokenContract === swapParameters[key]
-            );
-          }
-          if (tokenYMatchingDecimal) break;
-        }
-      }
-
-      if (tokenYMatchingDecimal && typeof convertedResult === 'number') {
-        const adjustedResult =
-          convertedResult / 10 ** tokenYMatchingDecimal.tokenDecimals;
-        return {
-          convertedResult: adjustedResult,
-          rawResult,
-          tokenXDecimals: tokenXMatchingDecimal?.tokenDecimals || 0,
-          tokenYDecimals: tokenYMatchingDecimal.tokenDecimals,
-        };
-      } else {
-        console.warn(
-          `No matching decimal found for tokenY: ${tokenYId} or result is not a number`
-        );
-        return {
-          convertedResult,
-          rawResult,
-          tokenXDecimals: tokenXMatchingDecimal?.tokenDecimals || 0,
-          tokenYDecimals: 0,
-        };
-      }
-    } catch (error) {
-      console.warn(`Couldn't apply decimal conversion: ${error}`);
-      return {
-        convertedResult,
-        rawResult,
-        tokenXDecimals: tokenXMatchingDecimal?.tokenDecimals || 0,
-        tokenYDecimals: 0,
-      };
-    }
-  } catch (error) {
-    console.error(`Error calling read-only function ${functionName}:`, error);
-    throw error;
-  }
-};

package/src/helpers/callSwapHelper.ts

@@ -1,67 +0,0 @@
-import { AnchorMode, PostConditionMode } from "@stacks/transactions";
-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[];
-    postConditions: any[];
-    contractAddress: string;
-    contractName: string;
-    functionName: string;
-  },
-  senderAddress: string,
-  context: SwapContext,
-  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,
-      functionName: swapParams.functionName,
-      functionArgs: swapParams.functionArgs,
-      senderAddress,
-      network,
-      anchorMode: AnchorMode.Any,
-      postConditionMode: PostConditionMode.Deny,
-      postConditions: swapParams.postConditions,
-      onFinish:
-        onFinish ||
-        ((data: any) => {
-          console.log("Transaction submitted:", data);
-        }),
-      onCancel:
-        onCancel ||
-        (() => {
-          console.log("Transaction canceled");
-        }),
-    };
-
-    await openContractCall({ ...txOptions }, stacksProvider);
-  } catch (error) {
-    console.error("Error executing swap:", error);
-    throw error;
-  }
-};