@bitflowlabs/core-sdk 1.0.0

package/dist/src/types.d.ts

@@ -0,0 +1,126 @@
+import { ClarityValue, PostCondition } from '@stacks/transactions';
+import { StacksNetwork } from '@stacks/network';
+export type BitflowSDKConfig = {
+    BITFLOW_API_HOST: string;
+    BITFLOW_API_KEY: string;
+    READONLY_CALL_API_HOST: string;
+};
+export type Token = {
+    icon: string;
+    name: string;
+    status: string;
+    symbol: string;
+    tokenId: string;
+    tokenContract: string | null;
+    tokenDecimals: number;
+    tokenName: string | null;
+    wrapTokens: {
+        [key: string]: {
+            tokenContract: string;
+            tokenDecimals: number;
+            tokenName: string | null;
+        };
+    } | null;
+};
+export type SwapOptions = {
+    [tokenY: string]: SelectedSwapRoute[];
+};
+export type PostConditionType = {
+    senderAddress: string;
+    shareFeeContract: string | null;
+    dikoStx: string | null;
+    tokenContract: string;
+    tokenName: string;
+    tokenDecimals: number | string;
+};
+export type SelectedSwapRoute = {
+    dex_path: string[];
+    postConditions: {
+        [key: string]: PostConditionType;
+    };
+    quoteData: {
+        contract: string;
+        function: string;
+        parameters: {
+            [key: string]: any;
+        };
+    };
+    swapData: {
+        contract: string;
+        function: string;
+        parameters: {
+            [key: string]: any;
+        };
+    };
+    token_path: string[];
+    tokenXDecimals: number;
+    tokenYDecimals: number;
+};
+export type SwapContext = {
+    availableTokens: Token[];
+    contractInterfaces: {
+        [key: string]: any;
+    };
+    functionArgs: {
+        [key: string]: {
+            [functionName: string]: any[];
+        };
+    };
+    network: StacksNetwork;
+    swapOptions: {
+        [tokenX: string]: SwapOptions;
+    };
+};
+export type RouteQuote = {
+    route: SelectedSwapRoute;
+    quote: number | null;
+    params: any;
+    quoteData: {
+        contract: string;
+        function: string;
+        parameters: {
+            [key: string]: any;
+        };
+    };
+    swapData: {
+        contract: string;
+        function: string;
+        parameters: {
+            [key: string]: any;
+        };
+    };
+    dexPath: string[];
+    tokenPath: string[];
+    tokenXDecimals: number;
+    tokenYDecimals: number;
+    error?: string;
+};
+export type QuoteResult = {
+    bestRoute: RouteQuote | null;
+    allRoutes: RouteQuote[];
+    inputData: {
+        tokenX: string;
+        tokenY: string;
+        amountInput: number;
+    };
+};
+export type TxToBroadcast = {
+    contractAddress: string;
+    contractName: string;
+    functionName: string;
+    functionArgs: ClarityValue[];
+    postConditions: PostCondition[];
+};
+export type SwapExecutionData = {
+    route: SelectedSwapRoute;
+    amount: number;
+    tokenXDecimals: number;
+    tokenYDecimals: number;
+};
+export type SwapDataParamsAndPostConditions = {
+    functionArgs: any[];
+    postConditions: any[];
+    contractAddress: string;
+    contractName: string;
+    functionName: string;
+};

package/dist/src/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@bitflowlabs/core-sdk",
+  "version": "1.0.0",
+  "description": "SDK for interacting with Bitflow Protocol",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint . --ext .ts",
+    "prepare": "npm run build",
+    "test:watch": "jest --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BitflowFinance/bitflow-sdk.git"
+  },
+  "keywords": [
+    "bitflow",
+    "blockchain",
+    "defi",
+    "sdk"
+  ],
+  "author": "Bitflow Protocol",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.13",
+    "@types/node": "^20.16.10",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "eslint": "^8.0.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.2"
+  },
+  "dependencies": {
+    "@stacks/connect": "^7.7.1",
+    "@stacks/network": "^6.16.0",
+    "@stacks/transactions": "^6.16.1"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "bugs": {
+    "url": "https://github.com/BitflowFinance/bitflow-sdk/issues"
+  },
+  "homepage": "https://github.com/BitflowFinance/bitflow-sdk#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/BitflowSDK.ts

@@ -0,0 +1,385 @@
+import { StacksMainnet } from '@stacks/network';
+import { StacksProvider } from '@stacks/connect';
+import {
+  SwapContext,
+  Token,
+  SwapOptions,
+  SelectedSwapRoute,
+  QuoteResult,
+  SwapExecutionData,
+  RouteQuote,
+  SwapDataParamsAndPostConditions,
+  BitflowSDKConfig,
+} from './types';
+import { fetchAllTokensFromAPI } from './helpers/fetchDataHelper';
+import { executeSwapHelper } from './helpers/callSwapHelper';
+import { callReadOnlyFunctionHelper } from './helpers/callReadOnlyHelper';
+import { fetchPossibleSwapsFromAPI } from './helpers/fetchPossibleSwap';
+import { getContractInterfaceAndFunction } from './helpers/getContractInterfaceAndFunction';
+import { configs, validateConfig } from './config';
+import { executeGetParams } from './helpers/callGetSwapParams';
+
+export class BitflowSDK {
+  private context: SwapContext;
+
+  constructor(config?: Partial<BitflowSDKConfig>) {
+    if (config) Object.assign(configs, config);
+
+    validateConfig();
+
+    this.context = {
+      availableTokens: [],
+      contractInterfaces: {},
+      functionArgs: {},
+      network: new StacksMainnet(),
+      swapOptions: {},
+    };
+
+    this.initializeContext();
+  }
+
+  private async initializeContext(): Promise<void> {
+    this.context.availableTokens = await fetchAllTokensFromAPI();
+  }
+
+  public async getAvailableTokens(): Promise<Token[]> {
+    if (this.context.availableTokens.length === 0) {
+      await this.initializeContext();
+    }
+    return this.context.availableTokens;
+  }
+
+  public async getPossibleSwaps(tokenX: string): Promise<SwapOptions> {
+    if (!this.context.swapOptions[tokenX]) {
+      this.context.swapOptions[tokenX] = await fetchPossibleSwapsFromAPI(
+        tokenX
+      );
+    }
+    return this.context.swapOptions[tokenX];
+  }
+
+  public async getAllPossibleTokenY(tokenX: string): Promise<string[]> {
+    const swapOptions = await this.getPossibleSwaps(tokenX);
+    return Object.keys(swapOptions);
+  }
+
+  public async getAllPossibleTokenYRoutes(
+    tokenX: string,
+    tokenY: string
+  ): Promise<SelectedSwapRoute[]> {
+    const swapOptions = await this.getPossibleSwaps(tokenX);
+    return swapOptions[tokenY] || [];
+  }
+
+  public async getQuoteForRoute(
+    tokenX: string,
+    tokenY: string,
+    amountInput: number
+  ): Promise<QuoteResult> {
+    const routes = await this.getAllPossibleTokenYRoutes(tokenX, tokenY);
+    const allRoutes: RouteQuote[] = [];
+
+    for (let routeIndex = 0; routeIndex < routes.length; routeIndex++) {
+      const route = routes[routeIndex];
+      try {
+        // Check if quoteData is null or undefined
+        if (!route.quoteData) {
+          console.warn(
+            `Skipping route ${routeIndex + 1} due to null quoteData:`,
+            route
+          );
+          continue;
+        }
+
+        const {
+          contract,
+          function: functionName,
+          parameters,
+        } = route.quoteData;
+
+        // Check if any required property is missing
+        if (!contract || !functionName || !parameters) {
+          console.warn(
+            `Skipping route ${
+              routeIndex + 1
+            } due to missing required properties:`,
+            route.quoteData
+          );
+          continue;
+        }
+
+        const [contractDeployer, contractName] = contract.split('.');
+
+        if (!this.context.contractInterfaces[contract]) {
+          this.context.contractInterfaces[contract] =
+            await getContractInterfaceAndFunction(
+              contractDeployer,
+              contractName,
+              functionName
+            );
+        }
+        const { interface: contractInterface, functionArgs } =
+          this.context.contractInterfaces[contract];
+
+        const params = { ...parameters };
+
+        if ('dx' in params && params.dx === null) {
+          params.dx = amountInput;
+        } else if ('dy' in params && params.dy === null) {
+          params.dy = amountInput;
+        } else if ('amount' in params && params.amount === null) {
+          params.amount = amountInput;
+        } else if ('amt-in' in params && params['amt-in'] === null) {
+          params['amt-in'] = amountInput;
+        } else if ('amt-in-max' in params && params['amt-in-max'] === null) {
+          params['amt-in-max'] = amountInput;
+        } else if ('y-amount' in params && params['y-amount'] === null) {
+          params['y-amount'] = amountInput;
+          params['x-amount'] = amountInput;
+        } else if ('x-amount' in params && params['x-amount'] === null) {
+          params['x-amount'] = amountInput;
+        } else {
+          params.dx = amountInput;
+        }
+
+        const { convertedResult, rawResult, tokenXDecimals, tokenYDecimals } =
+          await callReadOnlyFunctionHelper(
+            contractDeployer,
+            contractName,
+            functionName,
+            params,
+            contractDeployer,
+            tokenX,
+            tokenY,
+            route.swapData,
+            this.context
+          );
+
+        if (typeof convertedResult === 'number' && convertedResult > 0) {
+          const updatedQuoteData = {
+            ...route.quoteData,
+            parameters: { ...params },
+          };
+
+          const updatedSwapData = {
+            ...route.swapData,
+            parameters: {
+              ...route.swapData.parameters,
+              amount:
+                params.amount ||
+                params.dx ||
+                params['amt-in'] ||
+                params['amt-in-max'] ||
+                params['y-amount'] ||
+                params['x-amount'] ||
+                params.dy,
+              dx:
+                params.amount ||
+                params.dx ||
+                params['amt-in'] ||
+                params['amt-in-max'] ||
+                params['y-amount'] ||
+                params['x-amount'] ||
+                params.dy,
+              dy:
+                params.amount ||
+                params.dx ||
+                params['amt-in'] ||
+                params['amt-in-max'] ||
+                params['y-amount'] ||
+                params['x-amount'] ||
+                params.dy,
+              'amt-in':
+                params.amount ||
+                params.dx ||
+                params['amt-in'] ||
+                params['amt-in-max'] ||
+                params['y-amount'] ||
+                params['x-amount'] ||
+                params.dy,
+              'amt-in-max':
+                params.amount ||
+                params.dx ||
+                params['amt-in'] ||
+                params['amt-in-max'] ||
+                params['y-amount'] ||
+                params['x-amount'] ||
+                params.dy,
+              'y-amount':
+                params.amount ||
+                params.dx ||
+                params['amt-in'] ||
+                params['amt-in-max'] ||
+                params['y-amount'] ||
+                params['x-amount'] ||
+                params.dy,
+              'x-amount':
+                params.amount ||
+                params.dx ||
+                params['amt-in'] ||
+                params['amt-in-max'] ||
+                params['y-amount'] ||
+                params['x-amount'] ||
+                params.dy,
+
+              'min-received': rawResult,
+              'min-dy': rawResult,
+              'min-dz': rawResult,
+              'min-dw': rawResult,
+              'amt-out': rawResult,
+              'amt-out-min': rawResult,
+              'min-x-amount': rawResult,
+              'min-dv': rawResult,
+              'min-y-amount': rawResult,
+              'min-dx': rawResult,
+            },
+          };
+
+          const quoteResult: RouteQuote = {
+            route: {
+              ...route,
+              quoteData: updatedQuoteData,
+              swapData: updatedSwapData,
+            },
+            quote: convertedResult,
+            params: params,
+            quoteData: updatedQuoteData,
+            swapData: updatedSwapData,
+            dexPath: route.dex_path,
+            tokenPath: route.token_path,
+            tokenXDecimals: tokenXDecimals,
+            tokenYDecimals: tokenYDecimals,
+          };
+
+          allRoutes.push(quoteResult);
+        } else {
+          throw new Error('Invalid quote result');
+        }
+      } catch (error) {
+        console.warn(
+          `Failed to get quote for route ${routeIndex + 1}:`,
+          route,
+          error
+        );
+        allRoutes.push({
+          route,
+          quote: null,
+          params: route.quoteData
+            ? { ...route.quoteData.parameters, amountInput }
+            : { amountInput },
+          quoteData: route.quoteData,
+          swapData: route.swapData,
+          dexPath: route.dex_path,
+          tokenPath: route.token_path,
+          tokenXDecimals: route.tokenXDecimals,
+          tokenYDecimals: route.tokenYDecimals,
+          error: (error as Error).message,
+        });
+      }
+    }
+
+    allRoutes.sort((a, b) => (b.quote || 0) - (a.quote || 0));
+
+    const result = {
+      bestRoute: allRoutes[0]?.quote !== null ? allRoutes[0] : null,
+      allRoutes,
+      inputData: { tokenX, tokenY, amountInput },
+    };
+
+    return result;
+  }
+
+  public async getSwapParams(
+    swapExecutionData: SwapExecutionData,
+    senderAddress: string,
+    slippageTolerance: number = 0.015
+  ): Promise<SwapDataParamsAndPostConditions> {
+    const { route, amount, tokenXDecimals, tokenYDecimals } = swapExecutionData;
+
+    const executionData: SwapExecutionData = {
+      route: {
+        ...route,
+        swapData: {
+          ...route.swapData,
+          parameters: {
+            ...route.swapData.parameters,
+            amount:
+              route.swapData.parameters.amount ||
+              amount ||
+              route.swapData.parameters['amt-in'] ||
+              route.swapData.parameters['amt-in-max'] ||
+              route.swapData.parameters['y-amount'],
+            dx:
+              route.swapData.parameters.dx ||
+              amount ||
+              route.swapData.parameters['amt-in'] ||
+              route.swapData.parameters['amt-in-max'] ||
+              route.swapData.parameters['y-amount'],
+            'amt-in':
+              route.swapData.parameters.dx ||
+              amount ||
+              route.swapData.parameters['amt-in'] ||
+              route.swapData.parameters['amt-in-max'] ||
+              route.swapData.parameters['y-amount'] ||
+              route.swapData.parameters.dy,
+            'amt-in-max':
+              route.swapData.parameters.dx ||
+              amount ||
+              route.swapData.parameters['amt-in'] ||
+              route.swapData.parameters['amt-in-max'] ||
+              route.swapData.parameters['y-amount'] ||
+              route.swapData.parameters.dy,
+            'y-amount':
+              route.swapData.parameters.dx ||
+              amount ||
+              route.swapData.parameters['amt-in'] ||
+              route.swapData.parameters['amt-in-max'] ||
+              route.swapData.parameters['y-amount'] ||
+              route.swapData.parameters.dy,
+            dy:
+              route.swapData.parameters.dy ||
+              amount ||
+              route.swapData.parameters['amt-in'] ||
+              route.swapData.parameters['amt-in-max'] ||
+              route.swapData.parameters['y-amount'] ||
+              route.swapData.parameters.dy,
+          },
+        },
+      },
+      amount,
+      tokenXDecimals: tokenXDecimals,
+      tokenYDecimals: tokenYDecimals,
+    };
+
+    return await executeGetParams(
+      executionData,
+      senderAddress,
+      slippageTolerance,
+      this.context
+    );
+  }
+
+  public async executeSwap(
+    swapExecutionData: SwapExecutionData,
+    senderAddress: string,
+    slippageTolerance: number = 0.015,
+    stacksProvider?: StacksProvider,
+    onFinish?: (data: any) => void,
+    onCancel?: () => void
+  ): Promise<void> {
+    const swapParams = await this.getSwapParams(
+      swapExecutionData,
+      senderAddress,
+      slippageTolerance
+    );
+
+    await executeSwapHelper(
+      swapParams,
+      senderAddress,
+      this.context,
+      stacksProvider,
+      onFinish,
+      onCancel
+    );
+  }
+}

package/src/config.ts

@@ -0,0 +1,22 @@
+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,
+  READONLY_CALL_API_HOST:
+    process.env.NEXT_PUBLIC_READONLY_CALL_API_HOST ??
+    process.env.READONLY_CALL_API_HOST,
+};
+
+export function validateConfig() {
+  const requiredEnvVars = Object.keys(configs) as (keyof BitflowSDKConfig)[];
+
+  for (const envVar of requiredEnvVars) {
+    if (!configs[envVar]) {
+      console.error(`Missing required configuration: ${envVar}`);
+      throw new Error(`Missing required configuration: ${envVar}`);
+    }
+  }
+}