Use Cashout

import { usePrecalculatedCashouts, type Bet } from '@azuro-org/sdk'
 
type BetProps = {
  bet: Bet
}
 
const Bet: React.FC<BetProps> = ({ bet }) => {
  const {
    createdAt, status: graphBetStatus, amount, outcomes,
    payout, cashout, possibleWin, freebetId, txHash,
    isWin, isLose, isCanceled, isRedeemed, isCashedOut,
  } = bet
 
 
  const { data: cashoutData } = usePrecalculatedCashouts({
    bet,
  })
 
  const { cashoutAmount, isAvailable: isCashoutAvailable } = cashoutData || {}
 
  return (
    // render
  )
}

import { getPrecalculatedCashouts } from '@azuro-org/toolkit'
 
const { margin, marginMin, availables } = await getPrecalculatedCashouts({
  chainId: 137,
  conditionIds: [{...}]
})
 
// check if all conditions available for cashout
const isAvailable = availables.every(({ isAvailable }) => isAvailable)

type AvailableResponse = {
  margin: string
  marginMin: string
  availables: {
    conditionId: string
    available: boolean // cashout availability flag by condition
    outcomes: {
      outcomeId: number
      price: string // current price
    }[]
  }[]
}
 
const response = await fetch('https://api.onchainfeed.org/api/v1/public/cashout/get-available', {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    conditionIds,
  }),
})
 
const { margin, marginMin, availables }: AvailableResponse = await response.json()
 
// check if all conditions available for cashout
const isAvailable = availables.every(({ isAvailable }) => isAvailable)

import { useCashout, type Bet } from '@azuro-org/sdk'
 
export type CashoutModalProps = {
  bet: Bet
}
 
const CashoutModal: CashoutModalProps = (props) => {
  const { bet } = props
 
  const { calculationQuery } = useCashout({
    bet
  })
 
  const { data, error, isFetching: isCalculationFetching, refetch } = calculationQuery
  const { cashoutAmount, approveExpiredAt } = data || {}
 
  return (
    // render
  )
}

import { getCalculatedCashout } from '@azuro-org/toolkit'
 
const data = getCalculatedCashout({
  chainId: 137,
  account: '0x...',
  account: '0x...', // Bet owner address
  graphBetId: '...', // Bet ID from the Graph
})

enum Environment {
  GnosisDevXDAI = 'GnosisDevXDAI',
  GnosisXDAI = 'GnosisXDAI',
  PolygonUSDT = 'PolygonUSDT',
  PolygonAmoyUSDT = 'PolygonAmoyUSDT',
  ChilizWCHZ = 'ChilizWCHZ',
  ChilizSpicyWCHZ = 'ChilizSpicyWCHZ',
  BaseWETH = 'BaseWETH',
  BaseSepoliaWETH = 'BaseSepoliaWETH'
}
 
type CalculationResponse = {
    calculationId: string // Requirements for creating a cashout
    owner: string
    environment: string
    betId: string
    cashoutAmount: string // Сalculated cashout amount
    cashoutOdds: string // Calculated cashout as a coefficient
    expiredAt: number // The time during which the transaction must be completed, taking into account the execution on the contract
    approveExpiredAt: number // The time within which a request to create a cashout must be sent
    isLive: true
}
 
const response = await fetch(`${api}/cashout/get-calculation`, {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    environment: Environment.Polygon,
    owner: '0x...', // Bet owner address
    betId: '...', // Bet ID from the Graph
  }),
})
 
const data: CalculationResponse = await response.json()

import { useCashout, type Bet } from '@azuro-org/sdk'
 
export type CashoutModalProps = {
  bet: Bet
}
 
const CashoutModal: CashoutModalProps = (props) => {
  const { bet } = props
 
  const { submit } = useCashout({
    bet
  })
 
  return (
    <button onClick={submit}>Cashout</button>
  )
}

import { getCashoutTypedData } from '@azuro-org/toolkit'
 
const typedData = getCashoutTypedData({
  chainId: 137,
  account: '0x...', // user's wallet address
  attention: 'By signing this transaction, I agree to cash out on \'Azuro Example',
  tokenId: 234n, // bet tokenId
  cashoutOdds: 3135243n, // cashout odds from calculation
  expiredAt: 2348238n, // cashout expiry date
})
 
// sign typed data with wallet client
const signature = await walletClient!.data!.signTypedData(typedData)

import { createCashout } from '@azuro-org/toolkit'
 
const createdCashout = await createCashout({
  chainId: 137,
  calculationId: '...', // calculation id from prev step
  attention:  'By signing this transaction, I agree to cash out on \'Azuro Example',
  signature,
})

import { type SignTypedDataParameters, type TypedDataDomain } from 'viem'
 
export const CASHOUT_DATA_TYPES = {
  CashOutItem: [
    { name: 'betId', type: 'uint256' },
    { name: 'bettingContract', type: 'address' },
    { name: 'minOdds', type: 'uint64' },
  ],
  CashOutOrder: [
    { name: 'attention', type: 'string' },
    { name: 'chainId', type: 'uint256' },
    { name: 'items', type: 'CashOutItem[]' },
    { name: 'expiresAt', type: 'uint64' },
  ],
} as const
export const CASHOUT_TYPED_DATA_DOMAIN_NAME = 'Cash Out'
export const CASHOUT_TYPED_DATA_DOMAIN_VERSION = '1.0.0'
 
const EIP712Domain: TypedDataDomain = {
  name: CASHOUT_TYPED_DATA_DOMAIN_NAME,
  version: CASHOUT_TYPED_DATA_DOMAIN_VERSION,
  chainId: 137,
  verifyingContract: '0x...', // cashout contract address
}
 
const typedData: SignTypedDataParameters<typeof CASHOUT_DATA_TYPES> = {
  account: '0x...', // user's wallet address
  domain: EIP712Domain,
  primaryType: 'CashOutOrder',
  types: CASHOUT_DATA_TYPES,
  message: {
    attention: attention || 'By signing this transaction, I agree to cash out on \'Azuro SDK Example',
    chainId: BigInt(chainId),
    items: [
      {
        betId: 1283n, // bet tokenId
        bettingContract: '0x...', // core contract address
        minOdds: 100n // cashout odds from calculation
      },
    ],
    expiresAt: BigInt(142384), // cashout expiry date
  },
}
 
// sign typed data with wallet client
const signature = await walletClient!.data!.signTypedData(typedData)

type CreateRequest = {
  calculationId: string // calculation id from prev step
  signature: {
    verifyingContract: string // cashout contract address
    bettingContract: string // core contract address
    attention: string
    chainId: number
    ownerSignature: string // signed cashout data
  }
}
 
type CreateResponse = {
  id: string; // Cashout ID
  state: // Order state (PROCESSING, ACCEPTED, REJECTED, OPEN)
}
 
const signedCashout: CreateRequest = {...}
 
const response = await fetch(`${api}/cashout/create`, {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(signedCashout),
})
 
const createdCashout: CreateResponse = await response.json()

import { getCashout } from '@azuro-org/toolkit'
 
const cashout = await getCashout({
  chainId: 137,
  orderId: createdCashout.id,
})

type OrderResponse = {
  id: string; // Cashout ID
  state: // Order state (PROCESSING, ACCEPTED, REJECTED, OPEN)
  txHash: string; // Transaction id
  error?: string; // Error code
  errorMessage?: string; // // Error message
}
 
const response = await fetch(`${api}/cashout/${orderId}`)
 
const cashout: OrderResponse = await response.json()