@bitflowlabs/core-sdk 1.0.0

package/src/test/testMethods.ts

@@ -0,0 +1,227 @@
+import { BitflowSDK } from '../BitflowSDK';
+import { stringifyWithBigInt } from '../helpers/callReadOnlyHelper';
+import { Token, SelectedSwapRoute, QuoteResult } from '../types';
+
+class BitflowSDKTest {
+  private sdk: BitflowSDK;
+
+  constructor() {
+    this.sdk = new BitflowSDK();
+  }
+
+  public async testGetAvailableTokens(): Promise<void> {
+    const tokens = await this.sdk.getAvailableTokens();
+    console.log('Available Tokens:');
+    tokens.forEach(this.logToken);
+  }
+
+  public async testGetPossibleSwaps(tokenXName: string): Promise<void> {
+    try {
+      console.log(`Fetching possible swaps for token: ${tokenXName}`);
+      const possibleSwaps = await this.sdk.getPossibleSwaps(tokenXName);
+      console.log(
+        `Possible swaps for ${tokenXName}:`,
+        stringifyWithBigInt(possibleSwaps)
+      );
+    } catch (error) {
+      console.error(
+        `Error fetching possible swaps for token ${tokenXName}:`,
+        (error as Error).message
+      );
+    }
+  }
+
+  public async testGetAllPossibleTokenY(tokenXName: string): Promise<void> {
+    try {
+      console.log(`Fetching possible tokenY for token: ${tokenXName}`);
+      const possibleTokenY = await this.sdk.getAllPossibleTokenY(tokenXName);
+      console.log(
+        `Possible tokenY for ${tokenXName}:`,
+        stringifyWithBigInt(possibleTokenY)
+      );
+    } catch (error) {
+      console.error(
+        `Error fetching possible tokenY for token ${tokenXName}:`,
+        (error as Error).message
+      );
+    }
+  }
+
+  public async testGetAllPossibleTokenYRoutes(
+    tokenXName: string,
+    tokenYName: string
+  ): Promise<void> {
+    try {
+      console.log(`Fetching routes for ${tokenXName} to ${tokenYName}`);
+      const routes = await this.sdk.getAllPossibleTokenYRoutes(
+        tokenXName,
+        tokenYName
+      );
+      this.logRoutes(routes);
+    } catch (error) {
+      console.error(
+        `Error fetching routes for ${tokenXName} to ${tokenYName}:`,
+        (error as Error).message
+      );
+    }
+  }
+
+  public async testGetQuoteForRoute(
+    tokenXName: string,
+    tokenYName: string,
+    amountStr: string
+  ): Promise<void> {
+    try {
+      const amount = parseFloat(amountStr);
+      if (isNaN(amount)) {
+        throw new Error('Invalid amount input. Please provide a valid number.');
+      }
+
+      console.log(
+        `Fetching quotes for ${tokenXName} to ${tokenYName} with amount ${amount} (supports decimal input)`
+      );
+      const quoteResult = await this.sdk.getQuoteForRoute(
+        tokenXName,
+        tokenYName,
+        amount
+      );
+      this.logQuoteResult(quoteResult);
+    } catch (error) {
+      console.error(
+        'Error getting quotes for routes:',
+        (error as Error).message
+      );
+    }
+  }
+
+  private logQuote(
+    quote: QuoteResult['bestRoute'] | QuoteResult['allRoutes'][0] | null
+  ): void {
+    if (quote === null) {
+      console.log('  No quote available');
+      return;
+    }
+
+    if ('error' in quote && quote.quote === null) {
+      console.log(`  Error: ${quote.error}`);
+    } else if (quote.quote !== null) {
+      console.log(`  Converted quote result: ${quote.quote}`);
+    } else {
+      console.log('  Quote result unavailable');
+    }
+
+    console.log(`  Route:`);
+    console.log(`    DEX Path: ${quote.route.dex_path.join(' -> ')}`);
+    console.log(`    Token Path: ${quote.route.token_path.join(' -> ')}`);
+    console.log(`  Quote Data:`);
+    console.log(`    Contract: ${quote.route.quoteData.contract}`);
+    console.log(`    Function: ${quote.route.quoteData.function}`);
+    console.log(`    Parameters:`);
+    console.log(stringifyWithBigInt(quote.route.quoteData.parameters));
+    console.log(`  Swap Data:`);
+    console.log(`    Contract: ${quote.route.swapData.contract}`);
+    console.log(`    Function: ${quote.route.swapData.function}`);
+    console.log(`    Parameters:`);
+    console.log(stringifyWithBigInt(quote.route.swapData.parameters));
+  }
+
+  private logQuoteResult(quoteResult: QuoteResult): void {
+    console.log('Quote Result:');
+    console.log(`Input Data:`, stringifyWithBigInt(quoteResult.inputData));
+    console.log(`Best Route:`);
+    this.logQuote(quoteResult.bestRoute);
+    console.log(`All Routes:`);
+    quoteResult.allRoutes.forEach((route, index) => {
+      console.log(`Route ${index + 1}:`);
+      this.logQuote(route);
+    });
+  }
+
+  private logToken(token: Token): void {
+    console.log(`- ${token.name} (${token.symbol})`);
+    console.log(`  Status: ${token.status}`);
+    console.log(`  Decimals: ${token.tokenDecimals}`);
+    console.log(`  Contract: ${token.tokenContract || 'N/A'}`);
+    console.log(`  TokenId: ${token.tokenId || 'N/A'}`);
+    console.log('');
+  }
+
+  private logRoutes(routes: SelectedSwapRoute[]): void {
+    if (routes.length > 0) {
+      console.log(`Found ${routes.length} swap route(s):`);
+      routes.forEach((route, index) => {
+        console.log(`Route ${index + 1}:`);
+        console.log(`  DEX Path: ${route.dex_path.join(' -> ')}`);
+        console.log(`  Token Path: ${route.token_path.join(' -> ')}`);
+        console.log(`  Quote Data:`);
+        console.log(`    Contract: ${route.quoteData.contract}`);
+        console.log(`    Function: ${route.quoteData.function}`);
+        console.log(`    Parameters:`);
+        console.log(stringifyWithBigInt(route.quoteData.parameters));
+        console.log(`  Swap Data:`);
+        console.log(`    Contract: ${route.swapData.contract}`);
+        console.log(`    Function: ${route.swapData.function}`);
+        console.log(`    Parameters:`);
+        console.log(stringifyWithBigInt(route.swapData.parameters));
+        console.log(`PostConditions:`);
+        console.log(stringifyWithBigInt(route.postConditions));
+      });
+    } else {
+      console.log('No swap routes found');
+    }
+  }
+}
+
+const runTest = async (testName: string, ...args: string[]) => {
+  const sdkTest = new BitflowSDKTest();
+  switch (testName) {
+    case 'getAvailableTokens':
+      await sdkTest.testGetAvailableTokens();
+      break;
+    case 'getPossibleSwaps':
+      if (args.length < 1) {
+        console.error('Please provide tokenX for getPossibleSwaps');
+        process.exit(1);
+      }
+      await sdkTest.testGetPossibleSwaps(args[0]);
+      break;
+    case 'getAllPossibleTokenY':
+      if (args.length < 1) {
+        console.error('Please provide tokenX for getAllPossibleTokenY');
+        process.exit(1);
+      }
+      await sdkTest.testGetAllPossibleTokenY(args[0]);
+      break;
+    case 'getAllPossibleTokenYRoutes':
+      if (args.length < 2) {
+        console.error(
+          'Please provide tokenX and tokenY for getAllPossibleTokenYRoutes'
+        );
+        process.exit(1);
+      }
+      await sdkTest.testGetAllPossibleTokenYRoutes(args[0], args[1]);
+      break;
+    case 'getQuoteForRoute':
+      if (args.length < 3) {
+        console.error(
+          'Please provide tokenX, tokenY, and amount (integer or decimal) for getQuoteForRoute'
+        );
+        process.exit(1);
+      }
+      await sdkTest.testGetQuoteForRoute(args[0], args[1], args[2]);
+      break;
+    default:
+      console.error(`Unknown test: ${testName}`);
+      break;
+  }
+};
+
+const [testName, ...args] = process.argv.slice(2);
+if (!testName) {
+  console.error('Please provide a test name to run.');
+  process.exit(1);
+}
+
+runTest(testName, ...args).catch((error) => {
+  console.error('Test failed:', error);
+});

package/src/types.ts

@@ -0,0 +1,137 @@
+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;
+};