@bitflowlabs/core-sdk 1.0.1 → 2.0.0

package/src/keeper/keeperAPI.ts

@@ -0,0 +1,435 @@
+import {
+  ActionFunctionArgs,
+  CancelGroupOrderResponse,
+  CancelOrderResponse,
+  CreateGroupOrderParams,
+  CreateGroupOrderResponse,
+  CreateOrderParams,
+  CreateOrderResponse,
+  GetGroupOrderResponse,
+  GetKeeperContractParams,
+  GetKeeperContractResponse,
+  GetOrderResponse,
+  GetQuoteParams,
+  GetQuoteResponse,
+  GetUserResponse,
+  KEEPER_API_BASE_URL,
+  KeeperContract,
+  KeeperOrder,
+} from "./types";
+
+export async function getOrCreateKeeperContractAPI(
+  params: GetKeeperContractParams
+): Promise<GetKeeperContractResponse> {
+  try {
+    const queryParams = new URLSearchParams({
+      stacksAddress: params.stacksAddress,
+      keeperType: params.keeperType,
+    });
+
+    if (params.bitcoinAddress) {
+      queryParams.append("bitcoinAddress", params.bitcoinAddress);
+    }
+    if (typeof params.deployContract === "boolean") {
+      queryParams.append("deployContract", params.deployContract.toString());
+    }
+    if (typeof params.allActionsApproved === "boolean") {
+      queryParams.append(
+        "allActionsApproved",
+        params.allActionsApproved.toString()
+      );
+    }
+
+    const url = `${KEEPER_API_BASE_URL}/getOrCreateKeeperContract?${queryParams.toString()}`;
+
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(
+        errorData.error || `HTTP error! status: ${response.status}`
+      );
+    }
+
+    const data = await response.json();
+    return data as GetKeeperContractResponse;
+  } catch (error) {
+    console.error("Error in getOrCreateKeeperContract:", error);
+    throw error;
+  }
+}
+
+export async function getOrderAPI(orderId: string): Promise<GetOrderResponse> {
+  try {
+    const queryParams = new URLSearchParams({
+      orderId: orderId,
+    });
+
+    const url = `${KEEPER_API_BASE_URL}/getOrder?${queryParams.toString()}`;
+
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(
+        errorData.error || `HTTP error! status: ${response.status}`
+      );
+    }
+
+    const data = await response.json();
+
+    if (data.order) {
+      data.order.creationDate = new Date(data.order.creationDate);
+      data.order.lastUpdated = new Date(data.order.lastUpdated);
+    }
+
+    return data as GetOrderResponse;
+  } catch (error) {
+    console.error("Error in getOrder:", error);
+    throw error;
+  }
+}
+
+export async function getUserAPI(
+  stacksAddress: string
+): Promise<GetUserResponse> {
+  try {
+    const queryParams = new URLSearchParams({
+      stacksAddress: stacksAddress,
+    });
+
+    const url = `${KEEPER_API_BASE_URL}/getUser?${queryParams.toString()}`;
+
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(
+        errorData.error || `HTTP error! status: ${response.status}`
+      );
+    }
+
+    const data = (await response.json()) as GetUserResponse;
+
+    if (data.user) {
+      data.user.creationDate = new Date(data.user.creationDate);
+      data.user.lastUpdated = new Date(data.user.lastUpdated);
+
+      const contracts = data.user.keeperContracts as Record<
+        string,
+        KeeperContract
+      >;
+      for (const contractKey in contracts) {
+        const contract = contracts[contractKey];
+        if (contract.deploymentDate) {
+          contract.deploymentDate = new Date(contract.deploymentDate);
+        }
+      }
+
+      const orders = data.user.keeperOrders as Record<string, KeeperOrder>;
+      for (const orderKey in orders) {
+        const order = orders[orderKey];
+        order.creationDate = new Date(order.creationDate);
+        order.lastUpdated = new Date(order.lastUpdated);
+      }
+    }
+
+    return data;
+  } catch (error) {
+    console.error("Error in getUser:", error);
+    throw error;
+  }
+}
+
+export async function createOrderAPI(
+  params: CreateOrderParams
+): Promise<CreateOrderResponse> {
+  try {
+    const url = `${KEEPER_API_BASE_URL}/createOrder`;
+
+    const requestBody = {
+      stacksAddress: params.stacksAddress,
+      keeperType: params.keeperType,
+      contractIdentifier: params.contractIdentifier,
+      bitcoinAddress: params.bitcoinAddress || "",
+      actionAmount: params.actionAmount || "",
+      minReceived: params.minReceived || {
+        amount: "",
+        autoAdjust: false,
+      },
+      feeRecipient: params.feeRecipient || "",
+      tokenOrder: params.tokenOrder || [],
+      actionType: params.actionType,
+      bitcoinTxId: params.bitcoinTxId,
+    };
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(
+        errorData.error || `HTTP error! status: ${response.status}`
+      );
+    }
+
+    const data = (await response.json()) as CreateOrderResponse;
+
+    if (data.order) {
+      data.order.creationDate = new Date(data.order.creationDate);
+      data.order.lastUpdated = new Date(data.order.lastUpdated);
+    }
+
+    return data;
+  } catch (error) {
+    console.error("Error in createOrder:", error);
+    throw error;
+  }
+}
+
+export async function getQuoteAPI(
+  params: GetQuoteParams
+): Promise<GetQuoteResponse> {
+  try {
+    const queryParams = new URLSearchParams();
+
+    // Add required params
+    queryParams.append("stacksAddress", params.stacksAddress);
+    queryParams.append("actionAmount", params.actionAmount);
+    queryParams.append("keeperType", params.keeperType);
+
+    // Add optional params
+    if (params.actionType) {
+      queryParams.append("actionType", params.actionType);
+    }
+
+    if (params.tokenXId && params.tokenYId) {
+      queryParams.append("tokenXId", params.tokenXId);
+      queryParams.append("tokenYId", params.tokenYId);
+    }
+
+    if (params.minReceived) {
+      queryParams.append("minReceived[amount]", params.minReceived.amount);
+      queryParams.append(
+        "minReceived[autoAdjust]",
+        params.minReceived.autoAdjust.toString()
+      );
+    }
+
+    if (params.feeRecipient) {
+      queryParams.append("feeRecipient", params.feeRecipient);
+    }
+
+    if (params.bitcoinAddress) {
+      queryParams.append("bitcoinAddress", params.bitcoinAddress);
+    }
+
+    const url = `${KEEPER_API_BASE_URL}/getQuote?${queryParams.toString()}`;
+    const response = await fetch(url);
+    const responseText = await response.text();
+
+    if (!response.ok) {
+      throw new Error(`Unable to get quote: ${responseText}`);
+    }
+
+    return JSON.parse(responseText) as GetQuoteResponse;
+  } catch (error) {
+    console.error("Error in getQuote:", error);
+    throw error;
+  }
+}
+
+export async function createGroupOrderAPI(
+  params: CreateGroupOrderParams
+): Promise<CreateGroupOrderResponse> {
+  try {
+    const url = `${KEEPER_API_BASE_URL}/createGroupOrder`;
+
+    const requestBody: any = {
+      stacksAddress: params.stacksAddress,
+      amountPerOrder: params.amountPerOrder,
+      minReceived: params.minReceived,
+      numberOfOrders: params.numberOfOrders,
+      executionFrequency: params.executionFrequency,
+      feeRecipient: params.feeRecipient,
+      fundingTokens: params.fundingTokens,
+      bitcoinTxId: params.bitcoinTxId,
+      stacksTxId: params.stacksTxId,
+      keeperType: params.keeperType,
+      actionType: params.actionType,
+      actionFunctionArgs: params.actionFunctionArgs,
+      actionPostConditions: params.actionPostConditions,
+      actionAggregatorTokens: params.actionAggregatorTokens,
+      bitcoinAddress: params.bitcoinAddress || "",
+      nextExecutionAfter: params.nextExecutionAfter?.toISOString(),
+    };
+
+    if (params.priceRange) {
+      requestBody.priceRange = params.priceRange;
+    }
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(
+        errorData.error || `HTTP error! status: ${response.status}`
+      );
+    }
+
+    const data = await response.json();
+
+    if (data.groupOrder) {
+      data.groupOrder.creationDate = new Date(data.groupOrder.creationDate);
+      data.groupOrder.lastUpdated = new Date(data.groupOrder.lastUpdated);
+      if (data.groupOrder.orders) {
+        data.groupOrder.orders.forEach((order: KeeperOrder) => {
+          order.creationDate = new Date(order.creationDate);
+          order.lastUpdated = new Date(order.lastUpdated);
+        });
+      }
+    }
+
+    return data as CreateGroupOrderResponse;
+  } catch (error) {
+    console.error("Error in createGroupOrder:", error);
+    throw error;
+  }
+}
+
+export async function getGroupOrderAPI(
+  groupId: string,
+  includeOrders: boolean = false
+): Promise<GetGroupOrderResponse> {
+  try {
+    const queryParams = new URLSearchParams({
+      groupId: groupId,
+      includeOrders: includeOrders.toString(),
+    });
+
+    const url = `${KEEPER_API_BASE_URL}/getGroupOrder?${queryParams.toString()}`;
+
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(
+        errorData.error || `HTTP error! status: ${response.status}`
+      );
+    }
+
+    const data = await response.json();
+
+    // Convert date strings to Date objects
+    if (data.groupOrder) {
+      data.groupOrder.creationDate = new Date(data.groupOrder.creationDate);
+      data.groupOrder.lastUpdated = new Date(data.groupOrder.lastUpdated);
+      data.groupOrder.nextExecutionAfter = new Date(
+        data.groupOrder.nextExecutionAfter
+      );
+    }
+
+    if (data.groupOrders && Array.isArray(data.groupOrders)) {
+      data.groupOrders.forEach((order: KeeperOrder) => {
+        order.creationDate = new Date(order.creationDate);
+        order.lastUpdated = new Date(order.lastUpdated);
+      });
+    }
+
+    return data as GetGroupOrderResponse;
+  } catch (error) {
+    console.error("Error in getGroupOrder:", error);
+    throw error;
+  }
+}
+
+export async function cancelOrderAPI(
+  orderId: string
+): Promise<CancelOrderResponse> {
+  try {
+    const url = `${KEEPER_API_BASE_URL}/cancelOrder`;
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ orderId }),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(
+        errorData.error || `HTTP error! status: ${response.status}`
+      );
+    }
+
+    return (await response.json()) as CancelOrderResponse;
+  } catch (error) {
+    console.error("Error in cancelOrder:", error);
+    throw error;
+  }
+}
+
+export async function cancelGroupOrderAPI(
+  groupId: string
+): Promise<CancelGroupOrderResponse> {
+  try {
+    const url = `${KEEPER_API_BASE_URL}/cancelGroupOrder`;
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ groupId }),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(
+        errorData.error || `HTTP error! status: ${response.status}`
+      );
+    }
+
+    return (await response.json()) as CancelGroupOrderResponse;
+  } catch (error) {
+    console.error("Error in cancelGroupOrder:", error);
+    throw error;
+  }
+}

package/src/keeper/types.ts

@@ -0,0 +1,293 @@
+export const ALLOWED_CONTRACTS = new Set([
+  "SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-core-v-1-1",
+  "SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-core-v-1-2",
+  "SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.xyk-swap-helper-v-1-2",
+  "SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.stableswap-core-v-1-1",
+  "SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.stableswap-core-v-1-2",
+  "SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.stableswap-swap-helper-v-1-2",
+  "SM1793C4R5PZ4NS4VQ4WMP7SKKYVH8JZEWSZ9HCCR.router-xyk-stableswap-v-1-1",
+]);
+
+export enum ActionType {
+  SWAP_XYK_SWAP_HELPER = "SWAP_XYK_SWAP_HELPER",
+  SWAP_XYK_STABLESWAP_SWAP_HELPER = "SWAP_XYK_STABLESWAP_SWAP_HELPER",
+  SWAP_STABLESWAP_SWAP_HELPER = "SWAP_STABLESWAP_SWAP_HELPER",
+}
+
+export enum KeeperType {
+  SWAP_BTC_TO_STX = "SWAP_BTC_TO_STX",
+  SWAP_RUNES_TO_RUNES_BRIDGE_OUT = "SWAP_RUNES_TO_RUNES_BRIDGE_OUT",
+  SWAP_BTC_TO_RUNES_BRIDGE_OUT = "SWAP_BTC_TO_RUNES_BRIDGE_OUT",
+  SWAP_RUNES_TO_BTC_BRIDGE_OUT = "SWAP_RUNES_TO_BTC_BRIDGE_OUT",
+  MULTI_ACTION_V1 = "MULTI_ACTION_V1",
+}
+
+export enum KeeperTransactionType {
+  BITCOIN = "bitcoinTx",
+  STACKS = "stacksTx",
+  DEPLOY = "deployTx",
+  ACTION = "actionTx",
+  PONTIS = "pontisTx",
+}
+
+export enum KeeperContractStatus {
+  ContractDeploymentNotStarted = "contractDeploymentNotStarted",
+  ContractDeploymentPending = "contractDeploymentPending",
+  ContractDeploymentSuccess = "contractDeploymentSuccess",
+  ContractDeploymentFailed = "contractDeploymentFailed",
+  ContractDeploymentRetry = "contractDeploymentRetry",
+}
+
+export enum KeeperOrderStatus {
+  OrderCreated = "orderCreated",
+  OrderComplete = "orderComplete",
+  OrderFailed = "orderFailed",
+  ContractDeploymentPending = "contractDeploymentPending",
+  ContractDeploymentFailed = "contractDeploymentFailed",
+  ContractDeploymentRetry = "contractDeploymentRetry",
+  FundingPending = "fundingPending",
+  FundingFailed = "fundingFailed",
+  ActionPending = "actionPending",
+  ActionFailed = "actionFailed",
+  ActionRetry = "actionRetry",
+}
+
+export interface KeeperContract {
+  contractIdentifier: string;
+  contractStatus: KeeperContractStatus;
+  deploymentDate?: Date;
+}
+
+export interface GetKeeperContractResponse {
+  keeperContract: KeeperContract;
+  error?: string;
+}
+
+export interface GetKeeperContractParams {
+  stacksAddress: string;
+  keeperType: KeeperType;
+  bitcoinAddress?: string;
+  deployContract?: boolean;
+  allActionsApproved?: boolean;
+}
+
+export interface MinReceived {
+  amount: string;
+  autoAdjust: boolean;
+}
+
+export interface TxRetries {
+  deploys: number;
+  actions: number;
+}
+
+export interface KeeperOrder {
+  orderId: string;
+  userStacksAddress: string;
+  userBitcoinAddress: string;
+  contractIdentifier: string;
+  actionAmount: string;
+  minReceived: MinReceived;
+  feeRecipient: string;
+  tokenOrder: string[];
+  txIds: Record<string, string>;
+  keeperType: KeeperType;
+  requiresPontisTx: boolean;
+  status: KeeperOrderStatus;
+  txRetries: TxRetries;
+  creationDate: Date;
+  lastUpdated: Date;
+}
+
+export interface GetOrderResponse {
+  order: KeeperOrder;
+  error?: string;
+}
+
+export interface User {
+  stacksAddress: string;
+  bitcoinAddress: string;
+  keeperContracts: Record<string, KeeperContract>;
+  keeperOrders: Record<string, KeeperOrder>;
+  creationDate: Date;
+  lastUpdated: Date;
+}
+
+export interface GetUserResponse {
+  user: User;
+  error?: string;
+}
+
+export interface CreateOrderParams {
+  stacksAddress: string;
+  keeperType: KeeperType;
+  contractIdentifier: string;
+  bitcoinAddress?: string;
+  actionAmount?: string;
+  minReceived?: {
+    amount: string;
+    autoAdjust: boolean;
+  };
+  feeRecipient?: string;
+  tokenOrder?: string[];
+  actionType: string;
+  bitcoinTxId: string;
+  actionFunctionArgs?: {
+    tokenList?: Record<string, string>;
+    xykPoolList?: Record<string, string>;
+    stableswapPoolList?: Record<string, string>;
+    boolList?: Record<string, string>;
+    [key: string]: any;
+  };
+}
+
+export interface CreateOrderResponse {
+  order: KeeperOrder;
+  error?: string;
+}
+
+export interface ActionFunctionArgs {
+  actionTrait?: string;
+  tokenList?: Record<string, string>;
+  xykPoolList?: Record<string, string>;
+  stableswapPoolList?: Record<string, string>;
+  boolList?: Record<string, string>;
+}
+
+export interface GetQuoteParams {
+  stacksAddress: string;
+  actionAmount: string;
+  keeperType: KeeperType;
+  actionType?: string;
+  tokenXId?: string;
+  tokenYId?: string;
+  minReceived?: {
+    amount: string;
+    autoAdjust: boolean;
+  };
+  feeRecipient?: string;
+  bitcoinAddress?: string;
+}
+
+export interface GetQuoteResponse {
+  quote: string;
+  quoteWithSlippage: string;
+  keeperType: KeeperType;
+  actionType?: string;
+  tokenOrder: string[];
+  error?: string;
+}
+
+export interface AggregatorRouteData {
+  tokenX: string;
+  tokenY: string;
+  amountX: number;
+  routes: SwapRoute[];
+  dexPath: string[];
+  tokenPath: string[];
+  bestRoute?: SwapRoute;
+  keeperOrderData?: KeeperOrderRouteData;
+}
+
+export interface SwapRoute {
+  poolRoute: string[];
+  expectedOutput: number;
+  tokenRoute: string[];
+  dexRoute: string[];
+}
+
+export interface KeeperOrderRouteData {
+  tokenList: Record<string, string>;
+  xykPoolList: Record<string, string>;
+  stableswapPoolList: Record<string, string>;
+  boolList: Record<string, string>;
+}
+
+export interface GroupOrder {
+  groupId: string;
+  userStacksAddress: string;
+  orders: KeeperOrder[];
+  status: GroupOrderStatus;
+  creationDate: Date;
+  lastUpdated: Date;
+}
+
+export enum GroupOrderStatus {
+  Active = "active",
+  Completed = "completed",
+  Cancelled = "cancelled",
+}
+
+export interface CreateGroupOrderParams {
+  stacksAddress: string;
+  amountPerOrder: number;
+  numberOfOrders: number;
+  executionFrequency: number;
+  feeRecipient: string;
+  fundingTokens: {
+    [key: string]: string;
+  };
+  bitcoinTxId?: string;
+  stacksTxId?: string;
+  keeperType: KeeperType;
+  actionType?: string;
+  actionFunctionArgs?: ActionFunctionArgs;
+  actionPostConditions?: any[];
+  actionAggregatorTokens?: {
+    tokenXId: string;
+    tokenYId: string;
+  };
+  bitcoinAddress?: string;
+  nextExecutionAfter?: Date;
+  executeActionAfter?: Date;
+  minReceived: {
+    amount: string;
+    autoAdjust: boolean;
+  };
+  priceRange?: {
+    amount: string;
+    minPrice: string;
+    maxPrice: string;
+  };
+}
+
+export interface CreateGroupOrderResponse {
+  keeperGroupOrder: {
+    groupId: string;
+    orderIds: string[];
+    userStacksAddress: string;
+    userBitcoinAddress: string;
+    contractIdentifier: string;
+    amountPerOrder: string;
+    numberOfOrders: string;
+    remainingOrders: string;
+    executionFrequency: string;
+    txIds: {
+      bitcoinTxId?: string;
+      stacksTxId?: string;
+    };
+    nextExecutionAfter: Date;
+    creationDate: Date;
+    lastUpdated: Date;
+  };
+  error?: string;
+}
+
+export interface GetGroupOrderResponse {
+  groupOrder: GroupOrder;
+  error?: string;
+}
+
+export interface CancelOrderResponse {
+  success: boolean;
+  error?: string;
+}
+
+export interface CancelGroupOrderResponse {
+  success: boolean;
+  error?: string;
+}
+
+export const KEEPER_API_BASE_URL =
+  "https://bitflow-keeper-7owjsmt8.uc.gateway.dev";
+// "http://localhost:8080";