// Ensure apiKey is provided and not empty
const sdk = new BorrowSDK({
  apiKey: process.env.API_KEY!, // Check this isn't undefined
  // ...
});

const sdk = new BorrowSDK({
  wallet: {
    address: btcAddress,
    signMessage: async (message: string) => {
      // This must be an async function that returns a string
      return await yourWallet.signMessage(message);
    }
  }
});

try {
  await sdk.setup();
} catch (error) {
  if (error instanceof SmartAccountError) {
    console.log('Original cause:', error.cause);

    // Try clearing session and retry
    sdk.clearSession();
    await sdk.setup();
  }
}

try {
  await sdk.setup();
} catch (error) {
  if (error.message.includes('rejected') ||
      error.message.includes('cancelled')) {
    showMessage('Please sign the message to continue.');
  }
}

wallet: {
  signMessage: async (message: string) => {
    const signature = await yourWallet.signMessage(message);

    // Ensure signature is base64 string
    if (typeof signature !== 'string') {
      throw new Error('Invalid signature format');
    }

    // Some wallets return hex, convert if needed
    if (signature.startsWith('0x')) {
      return Buffer.from(signature.slice(2), 'hex').toString('base64');
    }

    return signature;
  }
}

// Check your parameters
const quotes = await sdk.getQuotes({
  collateralAmount: '0.1', // Minimum ~0.01 BTC
  loanAmount: '5000'       // Must fit within the collateral value
});

if (quotes.length === 0) {
  // Try with different parameters
  const smallerLoanQuotes = await sdk.getQuotes({
    collateralAmount: '0.1',
    loanAmount: '3500'
  });
}

onDepositReady: (info) => {
  console.log('Deposit to:', info.address);
  console.log('Amount:', info.amountBTC, 'BTC');
  console.log('Satoshis:', info.amount);

  // Save this info for verification
  saveDepositInfo(info);
}

// Resume tracking if interrupted
const pendingWorkflowId = localStorage.getItem('workflowId');

if (pendingWorkflowId) {
  // Check status
  const status = await sdk.getStatus(pendingWorkflowId);

  if (!status.isComplete && !status.isFailed) {
    // Resume tracking
    await sdk.resumeLoan(pendingWorkflowId, callbacks);
  }
}

// Verify BTC address before withdrawal
function validateBtcAddress(address: string): boolean {
  // Bech32
  if (address.startsWith('bc1')) {
    return /^bc1[a-zA-HJ-NP-Z0-9]{39,59}$/.test(address);
  }
  // Legacy
  return /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/.test(address);
}

// Check status after bridge failure
const status = await sdk.getRepayStatus(transactionId);
console.log('Bridge state:', status.transactionState);

// Check session before operations
if (!sdk.userStatus.hasActiveSession ||
    Date.now() / 1000 > (sdk.userStatus.sessionExpiry || 0)) {
  await sdk.setup(); // Refresh session
}

// Or handle in error handler
try {
  await sdk.getLoanHistory();
} catch (error) {
  if (error.message.includes('session')) {
    await sdk.setup();
    await sdk.getLoanHistory(); // Retry
  }
}

// Optional: preload or refresh account/session state for dashboard flows
async function initializeSDK() {
  const sdk = new BorrowSDK(config);
  await sdk.setup();
  return sdk;
}

// Add delay between requests
async function rateLimitedFetch<T>(operation: () => Promise<T>): Promise<T> {
  try {
    return await operation();
  } catch (error) {
    if (error instanceof ApiError && error.statusCode === 429) {
      console.log('Rate limited, waiting...');
      await new Promise(r => setTimeout(r, 5000));
      return await operation();
    }
    throw error;
  }
}

// Or configure retry
const sdk = new BorrowSDK({
  retryConfig: {
    maxRetries: 3,
    retryDelay: 2000,
    retryableStatusCodes: [429]
  }
});

// Use custom storage with cleanup
const sdk = new BorrowSDK({
  storage: {
    _data: new Map(),
    getItem(key) {
      return this._data.get(key) || localStorage.getItem(key);
    },
    setItem(key, value) {
      try {
        localStorage.setItem(key, value);
      } catch {
        // Fallback to memory
        this._data.set(key, value);
      }
    },
    removeItem(key) {
      localStorage.removeItem(key);
      this._data.delete(key);
    },
    clear() {
      // Only clear SDK keys
      const prefix = '@satsterminal/borrow';
      for (let i = localStorage.length - 1; i >= 0; i--) {
        const key = localStorage.key(i);
        if (key?.startsWith(prefix)) {
          localStorage.removeItem(key);
        }
      }
      this._data.clear();
    }
  }
});

useEffect(() => {
  let mounted = true;

  sdk.trackWorkflow(workflowId, {
    onStatusUpdate: (status) => {
      if (mounted) {
        setStatus(status);
      }
    },
    onComplete: () => {
      if (mounted) {
        setComplete(true);
      }
    }
  }, 'borrow');

  return () => {
    mounted = false;
    // Stop tracking if needed
  };
}, []);

const sdk = new BorrowSDK({
  logger: {
    debug: (msg) => console.debug('[SDK Debug]', msg),
    info: (msg) => console.info('[SDK Info]', msg),
    warn: (msg) => console.warn('[SDK Warn]', msg),
    error: (msg) => console.error('[SDK Error]', msg)
  }
});