new BorrowSDK(config: BorrowSDKConfig)

import { BorrowSDK, ChainType } from '@satsterminal-sdk/borrow';

const sdk = new BorrowSDK({
  apiKey: 'your-api-key',
  chain: ChainType.ARBITRUM,
  wallet: {
    address: 'bc1q...',
    signMessage: async (msg) => wallet.signMessage(msg)
  }
});

readonly userStatus: UserStatus

readonly baseWalletAddress: string | null

async setup(): Promise<{
  baseWallet: { address: string; signature: string };
  userStatus: UserStatus;
  activeSession: ActiveSession;
  transactions: UserTransaction[];
}>

const { baseWallet, userStatus, activeSession } = await sdk.setup();
console.log('Smart Account:', baseWallet.address);

async startNewLoan(): Promise<{
  userStatus: UserStatus;
  activeSession: ActiveSession;
}>

const { userStatus, activeSession } = await sdk.startNewLoan();
// Now ready to execute borrow

async getLoan(options: GetLoanOptions): Promise<LoanResult>

const result = await sdk.getLoan({
  collateralBTC: 0.1,
  loanAmountUSD: 5000,
  onStatusUpdate: (s) => console.log(s.label),
  onComplete: () => console.log('Done!')
});

async getQuotes(params: QuoteRequest): Promise<Quote[]>

const quotes = await sdk.getQuotes({
  collateralAmount: '0.1',
  loanAmount: '5000',
  ltv: 70
});

async executeBorrow(quote: Quote, options?: {
  destinationAddress?: string;
}): Promise<string>

const workflowId = await sdk.executeBorrow(selectedQuote);

async repay(
  originalBorrowId: string,
  repayAmount: string,
  options?: {
    useCollateral?: boolean;
    collateralToWithdraw?: string;
    userBtcWithdrawAddress?: string;
    trackWorkflow?: boolean;
    callbacks?: WorkflowCallbacks;
  }
): Promise<string>

await sdk.repay(loanId, '1000', {
  collateralToWithdraw: '0.01',
  userBtcWithdrawAddress: 'bc1q...',
  trackWorkflow: true,
  callbacks: {
    onComplete: () => console.log('Repaid!')
  }
});

async withdrawCollateral(
  originalBorrowId: string,
  collateralAmount: string,
  btcWithdrawAddress: string,
  options?: {
    trackWorkflow?: boolean;
    callbacks?: WorkflowCallbacks;
  }
): Promise<string>

await sdk.withdrawCollateral(
  loanId,
  '0.01',
  'bc1q...',
  { trackWorkflow: true, callbacks }
);

async getLoanCollateralInfo(loanId: string): Promise<LoanCollateralInfo | null>

{
  totalCollateral: string;
  availableCollateral: string;
  maxWithdrawable: string;
  totalDebt: string;
  remainingDebt: string;
}

async getLoanHistory(options?: {
  page?: number;
  limit?: number;
  status?: 'active' | 'pending' | 'all';
}): Promise<PaginatedResponse<UserTransaction>>

const history = await sdk.getLoanHistory({
  page: 1,
  limit: 20,
  status: 'active'
});

async getPendingLoans(): Promise<UserTransaction[]>

async getRepayTransactions(loanId?: string): Promise<RepayTransaction[]>

async getRepayStatus(transactionId: string): Promise<RepayTransactionStatusResponse>

async trackWorkflow(
  workflowId: string,
  callbacks: WorkflowCallbacks,
  workflowType?: 'borrow' | 'repay'
): Promise<void>

async resumeLoan(workflowId: string, callbacks?: WorkflowCallbacks): Promise<void>

async getStatus(workflowId: string): Promise<any>

async sendBitcoin(toAddress: string, satoshis: number): Promise<string>

async getFees(params: FeesRequest): Promise<FeesResponseData>

const fees = await sdk.getFees({
  chain: ChainType.ARBITRUM,
  collateralAmount: '0.1'
});

async getWalletPositions(params?: {
  filterPositions?: string;
  filterTrash?: string;
}): Promise<WalletPositionsResponse>

async getWalletPortfolio(filter?: string): Promise<WalletPortfolioResponse>

async withdrawToBitcoin(params: WithdrawToBitcoinRequest): Promise<string>

async getWithdrawStatus(transactionId: string): Promise<WithdrawStatusResponse>

async withdrawToEVM(params: WithdrawToEVMRequest): Promise<string>

// Withdraw USDC to your personal wallet (gasless)
const txHash = await sdk.withdrawToEVM({
  chain: ChainType.ARBITRUM,
  amount: '100',
  destinationAddress: '0x742d35Cc6634C0532925a3b844Bc9e7595f...'
});

console.log('Transaction hash:', txHash);
// Verify on block explorer: https://arbiscan.io/tx/{txHash}

clearSession(): void

function useBorrow(config: BorrowSDKConfig): BorrowSDK

import { useBorrow, ChainType } from '@satsterminal-sdk/borrow';

const sdk = useBorrow({
  apiKey: 'your-api-key',
  chain: ChainType.ARBITRUM,
  wallet: walletProvider
});