@bitflowlabs/core-sdk 1.0.0

package/src/helpers/callGetSwapParams.ts

@@ -0,0 +1,122 @@
+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

@@ -0,0 +1,243 @@
+import { callReadOnlyFunction } 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";
+
+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 = new StacksMainnet({ url: 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;
+
+    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 (!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;
+      }
+    }
+
+    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 callReadOnlyFunction({
+      contractAddress: contractDeployer,
+      contractName,
+      functionName,
+      functionArgs,
+      senderAddress,
+      network,
+    });
+
+    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;
+  }
+};

package/src/helpers/callSwapHelper.ts

@@ -0,0 +1,53 @@
+import { AnchorMode, PostConditionMode } from "@stacks/transactions";
+import { openContractCall, StacksProvider } from "@stacks/connect";
+import { SwapContext } from "../types";
+
+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 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");
+        }),
+    };
+
+    if (stacksProvider) {
+      await openContractCall(txOptions, stacksProvider);
+    } else {
+      await openContractCall(txOptions);
+    }
+  } catch (error) {
+    console.error("Error executing swap:", error);
+    throw error;
+  }
+};

package/src/helpers/constructFunctionArgs.ts

@@ -0,0 +1,24 @@
+import { stringifyWithBigInt } from "./callReadOnlyHelper";
+import { convertValue } from "./convertValuesHelper";
+
+export const constructFunctionArgs = (
+  parameters: any,
+  functionArgsDefinition: any[]
+) => {
+  return functionArgsDefinition.map((arg) => {
+    const value = parameters[arg.name];
+
+    if (value === undefined || value === null) {
+      console.warn(`Value for ${arg.name} is ${value}`);
+    }
+
+    try {
+      const convertedValue = convertValue(value, arg.type);
+
+      return convertedValue;
+    } catch (error) {
+      console.error(`Error converting value for ${arg.name}:`, error);
+      throw error;
+    }
+  });
+};

package/src/helpers/convertValuesHelper.ts

@@ -0,0 +1,214 @@
+import {
+  boolCV,
+  bufferCV,
+  ClarityValue,
+  contractPrincipalCV,
+  intCV,
+  listCV,
+  noneCV,
+  responseErrorCV,
+  responseOkCV,
+  someCV,
+  standardPrincipalCV,
+  stringAsciiCV,
+  stringUtf8CV,
+  tupleCV,
+  uintCV,
+} from "@stacks/transactions";
+
+export const convertValue = (value: any, type: any): ClarityValue => {
+  if (value === null || value === undefined) {
+    console.warn(
+      `Received null or undefined value for type ${JSON.stringify(
+        type
+      )}. Using default value.`
+    );
+    return getDefaultValue(type);
+  }
+
+  if (typeof type === "object") {
+    return handleObjectType(value, type);
+  }
+
+  switch (type) {
+    case "uint128":
+    case "uint":
+      return handleUintType(value);
+    case "int128":
+    case "int":
+      return handleIntType(value);
+    case "bool":
+      return handleBoolType(value);
+    case "principal":
+      return handlePrincipalType(value);
+    case "trait_reference":
+      return handleTraitReferenceType(value);
+    case "optional":
+      return handleOptionalType(value);
+    case "response":
+      return handleResponseType(value);
+    case "string-ascii":
+      return stringAsciiCV(value);
+    case "string-utf8":
+      return stringUtf8CV(value);
+    case "list":
+      return handleListType(value);
+    case "buffer":
+      return bufferCV(Buffer.from(value));
+    default:
+      if (typeof value === "object") {
+        return handleTupleType(value);
+      }
+      throw new Error(`Unsupported argument type: ${type}`);
+  }
+};
+
+const getDefaultValue = (type: any): ClarityValue => {
+  if (typeof type === "object") {
+    if (
+      type.type === "uint128" ||
+      (type.optional && type.optional === "uint128")
+    ) {
+      return noneCV();
+    }
+    if (type.tuple) {
+      return tupleCV({});
+    }
+    if (type.list) {
+      return listCV([]);
+    }
+  }
+  switch (type) {
+    case "uint128":
+    case "uint":
+      return uintCV(0);
+    case "int128":
+    case "int":
+      return intCV(0);
+    case "bool":
+      return boolCV(false);
+    case "optional":
+    case "optional(uint128)":
+      return noneCV();
+    case "string-ascii":
+    case "string-utf8":
+      return stringAsciiCV("");
+    case "buffer":
+      return bufferCV(Buffer.alloc(0));
+    case "list":
+      return listCV([]);
+    default:
+      throw new Error(
+        `Cannot provide default value for type: ${JSON.stringify(type)}`
+      );
+  }
+};
+
+const handleObjectType = (value: any, type: any): ClarityValue => {
+  if (type.type === "uint128") {
+    return uintCV(value);
+  }
+  if (type.optional === "uint128") {
+    return someCV(uintCV(value));
+  }
+  if (type.tuple) {
+    return handleTupleType(value, type.tuple);
+  }
+  if (type.list) {
+    return handleListType(value, type.list.type);
+  }
+  throw new Error(`Unsupported object-based type: ${JSON.stringify(type)}`);
+};
+
+const handleUintType = (value: any): ClarityValue => {
+  if (typeof value === "number" || typeof value === "bigint") {
+    return uintCV(value);
+  } else if (typeof value === "string") {
+    if (/^\d+$/.test(value)) {
+      return uintCV(value);
+    } else if (/^0x[0-9A-Fa-f]+$/.test(value)) {
+      return uintCV(BigInt(value));
+    }
+  } else if (value instanceof Uint8Array) {
+    return uintCV(value);
+  }
+  throw new Error(`Invalid uint128 value: ${value} (type: ${typeof value})`);
+};
+
+const handleIntType = (value: any): ClarityValue => {
+  if (
+    typeof value === "number" ||
+    typeof value === "bigint" ||
+    (typeof value === "string" && /^-?\d+$/.test(value))
+  ) {
+    return intCV(value);
+  }
+  throw new Error(`Invalid int128 value: ${value} (type: ${typeof value})`);
+};
+
+const handleBoolType = (value: any): ClarityValue => {
+  if (typeof value === "boolean") {
+    return boolCV(value);
+  }
+  throw new Error(`Invalid boolean value: ${value} (type: ${typeof value})`);
+};
+
+const handlePrincipalType = (value: string): ClarityValue => {
+  if (value.includes(".")) {
+    const [addr, name] = value.split(".");
+    return contractPrincipalCV(addr, name);
+  } else {
+    return standardPrincipalCV(value);
+  }
+};
+
+const handleTraitReferenceType = (value: string): ClarityValue => {
+  const [addr, name] = value.split(".");
+  return contractPrincipalCV(addr, name);
+};
+
+const handleOptionalType = (value: any): ClarityValue => {
+  return value !== null && value !== undefined
+    ? someCV(convertValue(value, "uint128"))
+    : noneCV();
+};
+
+const handleResponseType = (value: any): ClarityValue => {
+  if (
+    value &&
+    typeof value === "object" &&
+    ("ok" in value || "error" in value)
+  ) {
+    return "ok" in value
+      ? responseOkCV(convertValue(value.ok, typeof value.ok))
+      : responseErrorCV(convertValue(value.error, typeof value.error));
+  }
+  throw new Error(`Invalid response value: ${JSON.stringify(value)}`);
+};
+
+const handleListType = (value: any[], itemType?: any): ClarityValue => {
+  if (Array.isArray(value)) {
+    return listCV(
+      value.map((item) => convertValue(item, itemType || typeof item))
+    );
+  }
+  throw new Error(`Invalid list value: ${JSON.stringify(value)}`);
+};
+
+const handleTupleType = (value: any, tupleTypes?: any[]): ClarityValue => {
+  const tupleValues: { [key: string]: ClarityValue } = {};
+  if (tupleTypes) {
+    tupleTypes.forEach((item: { name: string; type: any }) => {
+      if (value && value[item.name] !== undefined) {
+        tupleValues[item.name] = convertValue(value[item.name], item.type);
+      } else {
+        tupleValues[item.name] = getDefaultValue(item.type);
+      }
+    });
+  } else {
+    for (const [key, val] of Object.entries(value)) {
+      tupleValues[key] = convertValue(val, typeof val);
+    }
+  }
+  return tupleCV(tupleValues);
+};

package/src/helpers/fetchContractInterfaceHelper.ts

@@ -0,0 +1,19 @@
+import { configs } from "../config";
+
+export const fetchContractInterface = async (
+  contractDeployer: string,
+  contractName: string
+): Promise<any> => {
+  const url = `${configs.READONLY_CALL_API_HOST}/v2/contracts/interface/${contractDeployer}/${contractName}`;
+
+  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 contract interface from ${url}:`, error);
+    throw error;
+  }
+};