@bitflowlabs/core-sdk 2.3.0 → 2.3.2-beta.0

package/src/helpers/constructFunctionArgs.ts

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

@@ -1,220 +0,0 @@
-import {
-  boolCV,
-  bufferCV,
-  ClarityValue,
-  contractPrincipalCV,
-  intCV,
-  listCV,
-  noneCV,
-  principalCV,
-  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, undefined, or invalid 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") ||
-      (type.optional && type.optional === "principal")
-    ) {
-      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)":
-    case "optional(principal)":
-      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.optional === "principal") {
-    return someCV(principalCV(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

@@ -1,27 +0,0 @@
-import { configs } from "../config";
-
-const getReadonlyHeaders = () => ({
-  Accept: "application/json",
-  "Content-Type": "application/json",
-  ...(configs.READONLY_CALL_API_KEY && { "x-api-key": configs.READONLY_CALL_API_KEY }),
-});
-
-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, {
-      headers: getReadonlyHeaders(),
-    });
-    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;
-  }
-};

package/src/helpers/fetchDataHelper.ts

@@ -1,88 +0,0 @@
-import { configs } from "../config";
-import { Token, LayerOneAsset, PriceData } from "../types";
-
-const getBitflowHeaders = () => ({
-  Accept: "application/json",
-  "Content-Type": "application/json",
-  ...(configs.BITFLOW_API_KEY && { "x-api-key": configs.BITFLOW_API_KEY }),
-});
-
-export const fetchAllTokensFromAPI = async (): Promise<Token[]> => {
-  const url = `${configs.BITFLOW_API_HOST}/getAllTokensAndPools`;
-  try {
-    const response = await fetch(url, {
-      headers: getBitflowHeaders(),
-    });
-    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) => {
-      // 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 || null,
-            };
-            return acc;
-          },
-          {}
-        );
-      }
-
-      // 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,39 +0,0 @@
-import { configs } from "../config";
-import { SwapOptions } from "../types";
-
-const getBitflowHeaders = () => ({
-  Accept: "application/json",
-  "Content-Type": "application/json",
-  ...(configs.BITFLOW_API_KEY && { "x-api-key": configs.BITFLOW_API_KEY }),
-});
-
-export const fetchPossibleSwapsFromAPI = async (
-  tokenX: string,
-  page?: "KEEPER"
-): Promise<SwapOptions> => {
-  const queryParams = new URLSearchParams({
-    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, {
-      headers: getBitflowHeaders(),
-    });
-    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

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

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

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

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

@@ -1,84 +0,0 @@
-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 "int":
-      rawResult = BigInt(result.value);
-      convertedResult = Number(rawResult);
-      break;
-    case "uint":
-      rawResult = BigInt(result.value);
-      convertedResult = Number(rawResult);
-      break;
-    case "buffer":
-      rawResult = Buffer.from(result.value);
-      convertedResult = rawResult.toString("hex");
-      break;
-    case "true":
-      rawResult = true;
-      convertedResult = true;
-      break;
-    case "false":
-      rawResult = false;
-      convertedResult = false;
-      break;
-    case "address":
-      rawResult = result.value;
-      convertedResult = result.value;
-      break;
-    case "contract":
-      rawResult = `${result.value.address}.${result.value.contractName}`;
-      convertedResult = rawResult;
-      break;
-    case "ok":
-      return handleResult(result.value);
-    case "err":
-      return handleResult(result.value);
-    case "none":
-      rawResult = null;
-      convertedResult = null;
-      break;
-    case "some":
-      return handleResult(result.value);
-    case "list":
-      rawResult = result.value.map((item: any) => handleResult(item).rawResult);
-      convertedResult = result.value.map(
-        (item: any) => handleResult(item).convertedResult
-      );
-      break;
-    case "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 "ascii":
-      rawResult = result.value;
-      convertedResult = result.value;
-      break;
-    case "utf8":
-      rawResult = result.value;
-      convertedResult = result.value;
-      break;
-    default:
-      throw new Error(`Unexpected result type: ${result.type}`);
-  }
-
-  return { rawResult, convertedResult };
-};