# Limits & Stops SDK

### Autonomy Limit Order / Stop Loss SDK interface

#### Installation:

To install the Limit/Stop interface you can use `yarn` or `npm` in your project.

 `yarn add -D @autonomylabs/limit-orders-react`

or

`npm install --save-dev @autonomylabs/limit-orders-react`

#### **Getting Started:**

To start using the limit order and stop loss interface we have created an `AutonomyProvider`. You can easily wrap your app with the provider and pass the autonomy reducers into your redux store.

```
import { configureStore } from "@reduxjs/toolkit";
import { save, load } from "redux-localstorage-simple";
import { autonomyReducers } from "@autonomylabs/limit-orders-react";

const PERSISTED_KEYS: string[] = ["your_keys"];
const store = configureStore({
  reducer: {
    ...your_reducers,
    // Pass the autonomy reducers
    ...autonomyReducers,
  },
  middleware: [save({ states: PERSISTED_KEYS, debounce: 1000 })],
  preloadedState: load({ states: PERSISTED_KEYS }),
});
export default store;
```

You can then go to your main file and wrap your app with the `AutonomyProvider`.

```
import React from "react";
import ReactDOM from "react-dom";
import { AutonomyProvider } from "@autonomylabs/limit-orders-react";
import { useActiveWeb3React } from "hooks/web3";
import { injected } from "connectors";

function Autonomy({ children }: { children?: React.ReactNode }) {
  const { library, chainId, account, activate } = useActiveWeb3React();
  return (
    <AutonomyProvider
      library={library}
      chainId={chainId}
      account={account ?? undefined}
      // Optionally pass the handler to be able to connect to a wallet via the component button
      onConnectWallet={() => activate(injected)}
      // By default `useDefaultTheme` is set to true, will use Autonomy SDK default theme if set
      useDefaultTheme={true}
      // By default `useDarkMode` is set to true
      usDarkMode={true}
      // Optionally pass any DEX router information to be used in the sdk. By default ApeSwap router will be used on BSC, and TraderJoe will be used on Avalanche.
      routerInfo={{
        routerAddress: "",
        factoryAddress: "",
        initCodeHash: "",
      }}
    >
      {children}
    </AutonomyProvider>
  );
}

ReactDOM.render(
  <StrictMode>
    <FixedGlobalStyle />
    <Web3ReactProvider getLibrary={getLibrary}>
      <Web3ProviderNetwork getLibrary={getLibrary}>
        <Provider store={store}>
          <ThemeProvider>
            <ThemedGlobalStyle />
            <HashRouter>
              <Autonomy>
                <App />
              </Autonomy>
            </HashRouter>
          </ThemeProvider>
        </Provider>
      </Web3ProviderNetwork>
    </Web3ReactProvider>
  </StrictMode>,
  document.getElementById("root")
);
```

#### Add the Limits Orders and Stops Losses:

You can easily then pass the order type (Limit or StopLoss) to our order components, `AutonomyOrderPanel` and `AutonomyOrderHistoryPanel`.

```
import React from "react";
import { AutonomyOrderPanel, AutonomyOrderHistoryPanel } from "@autonomylabs/limit-orders-react";
export default function App() {
  return (
    <div style={{ display: "flex", flexDirection: "column", alignItems: "center", justifyContent: "center" }}>
      <AutonomyOrderPanel orderType="Limit" />
      <AutonomyOrderHistoryPanel orderType="Limit" />
    </div>
  ):
}
```

### Autonomy Limit Order / Stop Loss SDK orders

Place limit & stoploss orders on any EVM chain.

#### Installation:

`yarn add -D @autonomylabs/limit-stop-orders`

or

`npm install --save-dev @autonomylabs/limit-stop-orders`

#### Initialize the SDK:

```
import { AutonomyLimitStopOrders } from "@autonomylabs/limit-stop-orders";

const autonomyLimitStopOrders = new AutonomyLimitStopOrders(
  chainId, // BSC = 56, Avalanche = 43114
  signerOrProvider, // Web3 Signer or Provider
  routerAddress, // DEX router address, Apeswap by default on BSC / TraderJoe by default on Avalanche
  factoryAddress, // DEX factory adderss, Apeswap by default on BSC / TraderJoe by default on Avalanche
  initCodeHash // DEX init code hash, Apeswap by default on BSC / TraderJoe by default on Avalanche
);
```

#### Approve Tokens:

To create limit orders and stop losses you must first approve the tokens on the Autonomy router.

```
await autonomyLimitStopOrders.approve(
  inputToken, // input token address
  inputAmount, // input amount in BigNumber
  recipient // recipient address
);
```

#### Submit an Order:

```
await autonomyLimitStopOrders.submitOrder(
  orderType, // Limit or Stop
  inputToken, // input token address
  inputAmount, // input amount in BigNumber
  outputToken, // output token address
  outputAmount, // output amount in BigNumber
  recipient, // recipient address
  autonomyPrepay // if true, small amount will be pre-paid
);
```

#### Cancel an Order:

```
await autonomyLimitStopOrders.cancelOrder(order);
```

#### Order History:

Get all Orders:

```
const allOrders = await autonomyLimitStopOrders.getOrders(requesterAddress);
```

Get open Orders:&#x20;

```
const openOrders = await autonomyLimitStopOrders.getOpenOrders(requesterAddress);
```

Get executed Orders:

```
const executedOrders = await autonomyLimitStopOrders.getExecutedOrders(requesterAddress);
```

Get cancelled Orders:

```
const cancelledOrders = await autonomyLimitStopOrders.getCancelledOrders(requesterAddress);
```

Get Orders by type:

```
const limitOrders = await autonomyLimitStopOrders.getOrdersByType(requesterAddress, "Limit");
const stopLossOrders = await autonomyLimitStopOrders.getOrdersByType(requesterAddress, "Stop");
```

### Reference integrations

Coming soon

<br>

<br>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.autonomynetwork.io/autonomy-docs/autonomy-network/products/autoswap/limits-and-stops-sdk.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.