import { TradingSdk, OrderKind, SupportedChainId } from '@cowprotocol/cow-sdk'

const sdk = new TradingSdk({
  chainId: SupportedChainId.MAINNET,
  appCode: 'MyApp',
  signer: wallet,
})

// Post a limit order
const result = await sdk.postLimitOrder({
  chainId: SupportedChainId.MAINNET,
  kind: OrderKind.SELL,
  sellToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH
  sellTokenDecimals: 18,
  buyToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
  buyTokenDecimals: 6,
  sellAmount: '1000000000000000000', // 1 WETH
  buyAmount: '2000000000', // 2000 USDC (minimum)
  slippageBps: 0, // No slippage for limit orders
})

console.log('Limit order created:', result.orderId)

import { JsonRpcProvider, Wallet } from 'ethers'
import {
  setGlobalAdapter,
  SupportedChainId,
  TradingSdk,
  OrderKind,
} from '@cowprotocol/cow-sdk'
import { EthersV6Adapter } from '@cowprotocol/sdk-ethers-v6-adapter'

const RPC_URL = 'https://eth.llamarpc.com'
const PRIVATE_KEY = '0x...'

async function createLimitOrder() {
  const chainId = SupportedChainId.MAINNET

  // Setup
  const provider = new JsonRpcProvider(RPC_URL, chainId)
  const wallet = new Wallet(PRIVATE_KEY, provider)
  const adapter = new EthersV6Adapter({ provider, signer: wallet })
  setGlobalAdapter(adapter)

  const sdk = new TradingSdk({
    chainId,
    appCode: 'LimitOrderExample',
    signer: wallet,
  })

  const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'
  const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'

  // Create limit order: Sell 1 WETH for at least 2000 USDC
  const result = await sdk.postLimitOrder({
    chainId,
    kind: OrderKind.SELL,
    sellToken: WETH,
    sellTokenDecimals: 18,
    buyToken: USDC,
    buyTokenDecimals: 6,
    sellAmount: '1000000000000000000', // 1 WETH
    buyAmount: '2000000000', // 2000 USDC minimum
    slippageBps: 0,
  })

  console.log('Limit order ID:', result.orderId)
  console.log('View at: https://explorer.cow.fi/orders/' + result.orderId)
}

createLimitOrder()

const result = await sdk.postLimitOrder(
  {
    // ... order parameters
  },
  {
    validTo: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 7, // Valid for 7 days
  }
)

const result = await sdk.postLimitOrder(
  {
    // ... order parameters
  },
  {
    additionalParams: {
      partiallyFillable: true,
    },
  }
)

const result = await sdk.postLimitOrder(
  {
    // ... order parameters
  },
  {
    appData: {
      metadata: {
        quote: {
          slippageBips: 0,
        },
        orderClass: {
          orderClass: 'limit',
        },
      },
    },
  }
)

import { OrderBookApi } from '@cowprotocol/sdk-order-book'

const orderBookApi = new OrderBookApi({ chainId })
const order = await orderBookApi.getOrder(result.orderId)

console.log('Status:', order.status) // 'open', 'filled', 'cancelled', 'expired'
console.log('Executed amount:', order.executedSellAmount)

const cancellation = await sdk.offChainCancelOrder({
  chainId,
  orderUid: result.orderId,
})

console.log('Order cancelled')

const tx = await sdk.cancelOrderOnChain({
  chainId,
  orderUid: result.orderId,
})

await tx.wait()
console.log('Order cancelled on-chain')

const result = await sdk.postLimitOrder({
  chainId,
  kind: OrderKind.BUY, // Buying exact amount
  sellToken: USDC,
  sellTokenDecimals: 6,
  buyToken: WETH,
  buyTokenDecimals: 18,
  sellAmount: '2000000000', // Max 2000 USDC to spend
  buyAmount: '1000000000000000000', // Buy exactly 1 WETH
  slippageBps: 0,
})

try {
  const result = await sdk.postLimitOrder(params)
  console.log('Order created:', result.orderId)
} catch (error) {
  if (error.message.includes('InsufficientAllowance')) {
    console.error('Need to approve tokens first')
  } else if (error.message.includes('InsufficientBalance')) {
    console.error('Not enough tokens')
  } else {
    console.error('Order creation failed:', error)
  }
}