import { Connection, Keypair } from '@solana/web3.js';
import { signAndSendTransaction } from 'dflow-sdk';
 
const connection = new Connection('https://api.mainnet-beta.solana.com');
const keypair = Keypair.fromSecretKey(/* your key */);
 
// order.transaction is base64 encoded
const signature = await signAndSendTransaction(
  connection,
  order.transaction,
  keypair
);
 
console.log(`Transaction sent: ${signature}`);

import { waitForConfirmation } from 'dflow-sdk';
 
const confirmation = await waitForConfirmation(
  connection,
  signature,
  'confirmed' // or 'finalized'
);
 
if (confirmation.err) {
  console.error('Transaction failed:', confirmation.err);
} else {
  console.log('Transaction confirmed at slot:', confirmation.slot);
}

import { signSendAndConfirm } from 'dflow-sdk';
 
const result = await signSendAndConfirm(
  connection,
  swap.transaction,
  keypair,
  'confirmed'
);
 
console.log(`Signature: ${result.signature}`);
console.log(`Status: ${result.confirmationStatus}`);
console.log(`Slot: ${result.slot}`);

interface TransactionConfirmation {
  signature: string;
  slot: number;
  confirmationStatus: 'processed' | 'confirmed' | 'finalized';
  err: unknown | null;
}

import { Connection, PublicKey } from '@solana/web3.js';
import { getTokenBalances } from 'dflow-sdk';
 
const connection = new Connection('https://api.mainnet-beta.solana.com');
const wallet = new PublicKey('...');
 
const balances = await getTokenBalances(connection, wallet);
 
for (const token of balances) {
  console.log(`Mint: ${token.mint}`);
  console.log(`  Balance: ${token.balance}`);
  console.log(`  Decimals: ${token.decimals}`);
}

interface TokenBalance {
  mint: string;
  rawBalance: string;  // Raw amount as string
  balance: number;     // UI amount with decimals
  decimals: number;
}

import { getUserPositions } from 'dflow-sdk';
 
const positions = await getUserPositions(
  connection,
  walletPublicKey,
  dflow.markets // Pass the markets API
);
 
for (const position of positions) {
  console.log(`Token: ${position.mint}`);
  console.log(`  Position: ${position.position}`); // 'YES', 'NO', or 'UNKNOWN'
  console.log(`  Balance: ${position.balance}`);
  
  if (position.market) {
    console.log(`  Market: ${position.market.title}`);
  }
}

interface UserPosition {
  mint: string;
  balance: number;
  decimals: number;
  position: 'YES' | 'NO' | 'UNKNOWN';
  market: Market | null;
}

import { isRedemptionEligible } from 'dflow-sdk';
 
for (const position of positions) {
  if (position.market) {
    const eligible = isRedemptionEligible(position.market, position.mint);
    
    if (eligible) {
      console.log(`Position ${position.mint} can be redeemed!`);
    }
  }
}

import { calculateScalarPayout } from 'dflow-sdk';
 
const payout = calculateScalarPayout(
  position.market,
  position.mint,
  position.balance
);
 
console.log(`Payout for ${position.balance} tokens: ${payout}`);

import { Connection, Keypair, PublicKey } from '@solana/web3.js';
import {
  DFlowClient,
  getUserPositions,
  isRedemptionEligible,
  calculateScalarPayout,
} from 'dflow-sdk';
 
async function checkPositions() {
  const dflow = new DFlowClient();
  const connection = new Connection('https://api.mainnet-beta.solana.com');
  const walletPubkey = new PublicKey('your-wallet-address');
 
  // Get all prediction market positions
  const positions = await getUserPositions(
    connection,
    walletPubkey,
    dflow.markets
  );
 
  console.log(`Found ${positions.length} positions:\n`);
 
  for (const position of positions) {
    console.log(`Position: ${position.position}`);
    console.log(`  Balance: ${position.balance}`);
    
    if (position.market) {
      console.log(`  Market: ${position.market.title}`);
      console.log(`  Status: ${position.market.status}`);
      console.log(`  Result: ${position.market.result || 'pending'}`);
 
      // Check if redeemable
      if (isRedemptionEligible(position.market, position.mint)) {
        console.log('  ✅ ELIGIBLE FOR REDEMPTION');
        
        // For scalar markets, calculate payout
        const payout = calculateScalarPayout(
          position.market,
          position.mint,
          position.balance
        );
        if (payout > 0) {
          console.log(`  Estimated payout: ${payout}`);
        }
      }
    }
    console.log('');
  }
}

// For trading, 'confirmed' is usually sufficient
const result = await signSendAndConfirm(connection, tx, keypair, 'confirmed');
 
// For critical operations like large redemptions
const result = await signSendAndConfirm(connection, tx, keypair, 'finalized');