OrderlyConfigProvider

props

React.PropsWithChildren

context

React.ReactNode

OrderlyProvider

**NOTE**: Exotic components are not callable.

React.ProviderProps

SWRConfig

useAccount

account

createAccount

createOrderlyKey

state

useAccountInfo

SWRResponse

API.AccountInfo

useAccountInstance

Account

useBoolean

initialValue

useChain

token

chains

isLoading

useChains

networkId

NetworkId

options

useCollateral

Options

CollateralOutputs

useConfig

ConfigKey

defaultValue

ConfigStore

useConstant

useCrossSwap

bridgeStatus

loading

message

status

swap

useDebounce

value

delay

DebouncedState

useDebouncedCallback

returns

example

```ts
// Avoid costly calculations while the window size is in flux.
const resizeHandler = useDebouncedCallback(calculateLayout, 150);
window.addEventListener('resize', resizeHandler)

// Invoke `sendMail` when clicked, debouncing subsequent calls.
const clickHandler = useDebouncedCallback(sendMail, 300, {
  leading: true,
  trailing: false,
})
<button onClick={clickHandler}>click me</button>

// Ensure `batchLog` is invoked once after 1 second of debounced calls.
const debounced = useDebouncedCallback(batchLog, 250, { 'maxWait': 1000 })
const source = new EventSource('/stream')
source.addEventListener('message', debounced)

// Cancel the trailing debounced invocation.
window.addEventListener('popstate', debounced.cancel)

// Check for pending invocations.
const status = debounced.pending() ? "Pending..." : "Ready"
```

Creates a debounced function that delays invoking `func` until after `wait`
milliseconds have elapsed since the last time the debounced function was
invoked, or until the next browser frame is drawn.

The debounced function comes with a `cancel` method to cancel delayed `func`
invocations and a `flush` method to immediately invoke them.

Provide `options` to indicate whether `func` should be invoked on the leading
and/or trailing edge of the `wait` timeout. The `func` is invoked with the
last arguments provided to the debounced function.

Subsequent calls to the debounced function return the result of the last
`func` invocation.

**Note:** If `leading` and `trailing` options are `true`, `func` is
invoked on the trailing edge of the timeout only if the debounced function
is invoked more than once during the `wait` timeout.

If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
until the next tick, similar to `setTimeout` with a timeout of `0`.

If `wait` is omitted in an environment with `requestAnimationFrame`, `func`
invocation will be deferred until the next frame is drawn (typically about
16ms).

See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
for details over the differences between `debounce` and `throttle`.

func

The number of milliseconds to delay; if omitted, `requestAnimationFrame` is
 used (if available, otherwise it will be setTimeout(...,0)).

wait

The options object.
 Controls if `func` should be invoked on the leading edge of the timeout.

useDeposit

useDepositOptions

allowance

allowanceRevalidating

approve

balance

balanceRevalidating

deposit

fetchBalance

fetchBalances

isNativeToken

useEventEmitter

EventEmitter

useFundingRate

symbol

countDown

est_funding_rate

est_funding_rate_timestamp

last_funding_rate

last_funding_rate_timestamp

next_funding_time

sum_unitary_funding

useHoldingStream

data

usdc

useIndexPrice

SWRSubscriptionResponse

useLazyQuery

description

query

SWRMutationResponse

useLeverage

useLocalStorage

useMarginRatio

currentLeverage

marginRatio

useMarkPrice

useMarkPricesStream

useMarketTradeStream

MarketTradeStreamOptions

useMarketsStream

useMaxQty

side

OrderSide

reduceOnly

useMutation

method

HTTP_METHOD

SWRMutationConfiguration

useOrderEntry

UseOrderEntryOptions

freeCollateral

helper

markPrice

maxQty

onSubmit

symbolConfig

useOrderStream

params

Params

useOrderbookStream

name

React hook that returns the current orderbook for a given market

initial

OrderbookData

OrderbookOptions

usePositionStream

Partial

usePreLoadData

done

error

usePrivateDataObserver

usePrivateQuery

useQueryOptions

useQuery

useSWR

link

```jsx
import useSWR from 'swr'
function Profile() {
  const { data, error, isLoading } = useSWR('/api/user', fetcher)
  if (error) return <div>failed to load</div>
  if (isLoading) return <div>loading...</div>
  return <div>hello {data.name}!</div>
}
```

SWRKey

Data

Error

StrictKey

fetcher

config

SWROptions

useSessionStorage

useSettleSubscription

useSwap

useSymbolsInfo

Record

useThrottledCallback

```ts
// Avoid excessively updating the position while scrolling.
const scrollHandler = useThrottledCallback(updatePosition, 100)
window.addEventListener('scroll', scrollHandler)

// Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
const { callback } = useThrottledCallback(renewToken, 300000, { 'trailing': false })
<button onClick={callback}>click</button>

// Cancel the trailing throttled invocation.
window.addEventListener('popstate', throttled.cancel);
```

Creates a throttled function that only invokes `func` at most once per
every `wait` milliseconds (or once per browser frame).

The throttled function comes with a `cancel` method to cancel delayed `func`
invocations and a `flush` method to immediately invoke them.

Provide `options` to indicate whether `func` should be invoked on the leading
and/or trailing edge of the `wait` timeout. The `func` is invoked with the
last arguments provided to the throttled function.

Subsequent calls to the throttled function return the result of the last
`func` invocation.

**Note:** If `leading` and `trailing` options are `true`, `func` is
invoked on the trailing edge of the timeout only if the throttled function
is invoked more than once during the `wait` timeout.

If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
until the next tick, similar to `setTimeout` with a timeout of `0`.

If `wait` is omitted in an environment with `requestAnimationFrame`, `func`
invocation will be deferred until the next frame is drawn (typically about
16ms).

See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
for details over the differences between `throttle` and `debounce`.

The number of milliseconds to throttle invocations to; if omitted,
 `requestAnimationFrame` is used (if available, otherwise it will be setTimeout(...,0)).

CallOptions

useTickerStream

API.MarketInfo

useWS

useWalletSubscription

useWithdraw

availableBalance

maxAmount

unsettledPnL

withdraw

useWooCrossSwapQuery

useWooSwapQuery

Controls if the function should be invoked on the leading edge of the timeout.

leading

Controls if the function should be invoked on the trailing edge of the timeout.

trailing

ConfigProviderProps

brokerId

configStore

getWalletAdapter

getWalletAdapterFunc

keyStore

OrderlyKeyStore

ControlFunctions

cancel

__type

flush

isPending

Subsequent calls to the debounced function `debounced.callback` return the result of the last func invocation.
Note, that if there are no previous invocations it's mean you will get undefined. You should check it in your code properly.

The maximum time the given function is allowed to be delayed before it's invoked.

@orderly.network/hooks

Interface

Variable

Function